actions.h

Go to the documentation of this file.

/* Copyright 2013-2019 Barefoot Networks, Inc.
 * Copyright 2019 VMware, 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
 *
 */
 
 
 
#ifndef BM_BM_SIM_ACTIONS_H_
#define BM_BM_SIM_ACTIONS_H_
 
#include <functional>
#include <iosfwd>
#include <limits>
#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <cassert>
 
#include "phv.h"
#include "named_p4object.h"
#include "expressions.h"
#include "stateful.h"
#include "_assert.h"
 
namespace bm {
 
class P4Objects;  // forward declaration for deserialize
 
// some forward declarations for needed p4 objects
class Packet;
class NamedCalculation;
class MeterArray;
class CounterArray;
 
// forward declaration of ActionPrimitive_
class ActionPrimitive_;
 
// Maps primitive names to primitive implementations (functors).
// Targets are responsible for defining their own primitives and registering
// them in this map using the REGISTER_PRIMITIVE(primitive_name) macro.
class ActionOpcodesMap {
 public:
  using ActionPrimitiveFactoryFn =
      std::function<std::unique_ptr<ActionPrimitive_>()>;
  static ActionOpcodesMap *get_instance();
  bool register_primitive(const char *name, ActionPrimitiveFactoryFn primitive);
 
  std::unique_ptr<ActionPrimitive_> get_primitive(const std::string &name);
 private:
  ActionOpcodesMap();
 
  // Maps primitive names to their implementation.
  // The same pointer is used system-wide, even if a primitive is called from
  // different actions. As such, one has to be careful if some state is
  // maintained byt the primitive functor.
  std::unordered_map<std::string, ActionPrimitiveFactoryFn> map_{};
};
 
#define REGISTER_PRIMITIVE(primitive_name)                                  \
  bool primitive_name##_create_ =                                           \
      bm::ActionOpcodesMap::get_instance()->register_primitive(             \
          #primitive_name,                                                  \
          [](){ return std::unique_ptr<::bm::ActionPrimitive_>(             \
              new primitive_name()); })
 
#define REGISTER_PRIMITIVE_W_NAME(primitive_name, primitive)            \
  bool primitive##_create_ =                                            \
      bm::ActionOpcodesMap::get_instance()->register_primitive(         \
          primitive_name,                                               \
          [](){ return std::unique_ptr<::bm::ActionPrimitive_>(         \
              new primitive()); })
 
struct ActionData {
  const Data &get(int offset) const { return action_data[offset]; }
 
  void push_back_action_data(const Data &data) {
    action_data.push_back(data);
  }
 
  void push_back_action_data(unsigned int data) {
    action_data.emplace_back(data);
  }
 
  void push_back_action_data(const char *bytes, int nbytes) {
    action_data.emplace_back(bytes, nbytes);
  }
 
  size_t size() const { return action_data.size(); }
 
  std::vector<Data> action_data{};
};
 
struct ActionEngineState;
 
class ExternType;
 
// A simple tagged union, which holds the definition of an action parameter. For
// example, if an action parameter is a field, this struct will hold the header
// id and the offset for this field. If an action parameter is a meter array,
// the struct will hold a raw, non-owning pointer to the MeterArray object.
struct ActionParam {
  // some old P4 primitives take a calculation as a parameter, I don't know if I
  // will keep it around but for now I need it
  enum {CONST, FIELD, HEADER, ACTION_DATA, REGISTER_REF, REGISTER_GEN,
        HEADER_STACK, LAST_HEADER_STACK_FIELD,
        CALCULATION,
        METER_ARRAY, COUNTER_ARRAY, REGISTER_ARRAY,
        EXPRESSION, EXPRESSION_HEADER, EXPRESSION_HEADER_STACK,
        EXPRESSION_HEADER_UNION, EXPRESSION_HEADER_UNION_STACK,
        EXTERN_INSTANCE,
        STRING,
        HEADER_UNION, HEADER_UNION_STACK, PARAMS_VECTOR, FIELD_LIST} tag;
 
  union {
    unsigned int const_offset;
 
    struct {
      header_id_t header;
      int field_offset;
    } field;
 
    header_id_t header;
 
    unsigned int action_data_offset;
 
    // In theory, if registers cannot be resized, I could directly store a
    // pointer to the correct register cell, i.e. &(*array)[idx]. However, this
    // gives me more flexibility in case I want to be able to resize the
    // registers arbitrarily in the future.
    struct {
      RegisterArray *array;
      unsigned int idx;
    } register_ref;
 
    struct {
      RegisterArray *array;
      ArithExpression *idx;
    } register_gen;
 
    header_stack_id_t header_stack;
 
    // for lists of numerical values, used for the log_msg primitive and nothing
    // else at the moment
    struct {
      unsigned int start;
      unsigned int end;
    } params_vector;
 
    struct {
      unsigned int start;
      unsigned int end;
    } field_list;
 
    // special case when trying to access a field in the last header of a stack
    struct {
      header_stack_id_t header_stack;
      int field_offset;
    } stack_field;
 
    // non owning pointer
    const NamedCalculation *calculation;
 
    // non owning pointer
    MeterArray *meter_array;
 
    // non owning pointer
    CounterArray *counter_array;
 
    // non owning pointer
    RegisterArray *register_array;
 
    struct {
      unsigned int offset;  // only used for arithmetic ("Data") expressions
      // non owning pointer
      // in theory, could be an owning pointer, but the union makes this
      // complicated, so instead the ActionFn keeps a vector of owning pointers
      Expression *ptr;
    } expression;
 
    ExternType *extern_instance;
 
    // I use a pointer here to avoid complications with the union; the string
    // memory is owned by ActionFn (just like for Expression above)
    const std::string *str;
 
    header_union_stack_id_t header_union_stack;
 
    header_union_id_t header_union;
  };
 
  // convert to the correct type when calling a primitive
  template <typename T> T to(ActionEngineState *state) const;
};
 
struct ActionEngineState {
  Packet &pkt;
  PHV &phv;
  const ActionData &action_data;
  const std::vector<Data> &const_values;
  const std::vector<ActionParam> &parameters_vector;
  const std::vector<ActionParam> &field_list;
 
  ActionEngineState(Packet *pkt,
                    const ActionData &action_data,
                    const std::vector<Data> &const_values,
                    const std::vector<ActionParam> &parameters_vector,
                    const std::vector<ActionParam> &field_list);
};
 
// template specializations for ActionParam "casting"
// they have to be declared outside of the class declaration, and "inline" is
// necessary to avoid linker errors
 
template <> inline
Data &ActionParam::to<Data &>(ActionEngineState *state) const {
  static thread_local Data data_temp;
 
  switch (tag) {
    case ActionParam::FIELD:
      return state->phv.get_field(field.header, field.field_offset);
    case ActionParam::REGISTER_REF:
      return register_ref.array->at(register_ref.idx);
    case ActionParam::REGISTER_GEN:
      register_gen.idx->eval_arith(state->phv, &data_temp,
                                   state->action_data.action_data);
      return register_ref.array->at(data_temp.get<size_t>());
    case ActionParam::EXPRESSION:
      return expression.ptr->eval_arith_lvalue(&state->phv,
                                               state->action_data.action_data);
    case ActionParam::LAST_HEADER_STACK_FIELD:
      return state->phv.get_header_stack(stack_field.header_stack).get_last()
          .get_field(stack_field.field_offset);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
template <> inline
const Data &ActionParam::to<const Data &>(ActionEngineState *state) const {
  // thread_local sounds like a good choice here
  // alternative would be to have one vector for each ActionFnEntry
  static thread_local unsigned int data_temps_size = 4;
  static thread_local std::vector<Data> data_temps(data_temps_size);
 
  switch (tag) {
    case ActionParam::CONST:
      return state->const_values[const_offset];
    case ActionParam::FIELD:
      return state->phv.get_field(field.header, field.field_offset);
    case ActionParam::ACTION_DATA:
      return state->action_data.get(action_data_offset);
    case ActionParam::REGISTER_REF:
      return register_ref.array->at(register_ref.idx);
    case ActionParam::REGISTER_GEN:
      register_gen.idx->eval_arith(state->phv, &data_temps[0],
                                   state->action_data.action_data);
      return register_ref.array->at(data_temps[0].get<size_t>());
    case ActionParam::EXPRESSION:
      while (data_temps_size <= expression.offset) {
        data_temps.emplace_back();
        data_temps_size++;
      }
      expression.ptr->eval_arith(state->phv, &data_temps[expression.offset],
                                 state->action_data.action_data);
      return data_temps[expression.offset];
    case ActionParam::LAST_HEADER_STACK_FIELD:
      return state->phv.get_header_stack(stack_field.header_stack).get_last()
          .get_field(stack_field.field_offset);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
// TODO(antonin): maybe I should use meta-programming for const type handling,
// but I cannot think of an easy way, so I am leaving it as is for now
 
template <> inline
Field &ActionParam::to<Field &>(ActionEngineState *state) const {
  assert(tag == ActionParam::FIELD);
  return state->phv.get_field(field.header, field.field_offset);
}
 
template <> inline
const Field &ActionParam::to<const Field &>(ActionEngineState *state) const {
  return ActionParam::to<Field &>(state);
}
 
template <> inline
Header &ActionParam::to<Header &>(ActionEngineState *state) const {
  switch (tag) {
    case ActionParam::HEADER:
      return state->phv.get_header(header);
    case ActionParam::EXPRESSION_HEADER:
      return expression.ptr->eval_header(&state->phv,
                                         state->action_data.action_data);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
template <> inline
const Header &ActionParam::to<const Header &>(ActionEngineState *state) const {
  return ActionParam::to<Header &>(state);
}
 
template <> inline
HeaderStack &ActionParam::to<HeaderStack &>(ActionEngineState *state) const {
  switch (tag) {
    case ActionParam::HEADER_STACK:
      return state->phv.get_header_stack(header_stack);
    case ActionParam::EXPRESSION_HEADER_STACK:
      return expression.ptr->eval_header_stack(&state->phv,
                                               state->action_data.action_data);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
template <> inline
const HeaderStack &ActionParam::to<const HeaderStack &>(
    ActionEngineState *state) const {
  return ActionParam::to<HeaderStack &>(state);
}
 
template <> inline
StackIface &ActionParam::to<StackIface &>(ActionEngineState *state) const {
  switch (tag) {
    case HEADER_STACK:
      return state->phv.get_header_stack(header_stack);
    case ActionParam::EXPRESSION_HEADER_STACK:
      return expression.ptr->eval_header_stack(
          &state->phv, state->action_data.action_data);
    case HEADER_UNION_STACK:
      return state->phv.get_header_union_stack(header_union_stack);
    case ActionParam::EXPRESSION_HEADER_UNION_STACK:
      return expression.ptr->eval_header_union_stack(
          &state->phv, state->action_data.action_data);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
template <> inline
const StackIface &ActionParam::to<const StackIface &>(
    ActionEngineState *state) const {
  return ActionParam::to<StackIface &>(state);
}
 
template <> inline
HeaderUnion &ActionParam::to<HeaderUnion &>(ActionEngineState *state) const {
  switch (tag) {
    case ActionParam::HEADER_UNION:
      return state->phv.get_header_union(header_union);
    case ActionParam::EXPRESSION_HEADER_UNION:
      return expression.ptr->eval_header_union(&state->phv,
                                               state->action_data.action_data);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
template <> inline
const HeaderUnion &ActionParam::to<const HeaderUnion &>(
    ActionEngineState *state) const {
  return ActionParam::to<HeaderUnion &>(state);
}
 
template <> inline
HeaderUnionStack &ActionParam::to<HeaderUnionStack &>(
    ActionEngineState *state) const {
  switch (tag) {
    case ActionParam::HEADER_UNION_STACK:
      return state->phv.get_header_union_stack(header_union_stack);
    case ActionParam::EXPRESSION_HEADER_UNION_STACK:
      return expression.ptr->eval_header_union_stack(
          &state->phv, state->action_data.action_data);
    default:
      _BM_UNREACHABLE("Default switch case should not be reachable");
  }
}
 
template <> inline
const HeaderUnionStack &ActionParam::to<const HeaderUnionStack &>(
    ActionEngineState *state) const {
  return ActionParam::to<HeaderUnionStack &>(state);
}
 
template <> inline
const NamedCalculation &ActionParam::to<const NamedCalculation &>(
    ActionEngineState *state) const {
  (void) state;
  assert(tag == ActionParam::CALCULATION);
  return *(calculation);
}
 
template <> inline
MeterArray &ActionParam::to<MeterArray &>(ActionEngineState *state) const {
  (void) state;
  assert(tag == ActionParam::METER_ARRAY);
  return *(meter_array);
}
 
template <> inline
const MeterArray &ActionParam::to<const MeterArray &>(
    ActionEngineState *state) const {
  return ActionParam::to<MeterArray &>(state);
}
 
template <> inline
CounterArray &ActionParam::to<CounterArray &>(ActionEngineState *state) const {
  (void) state;
  assert(tag == ActionParam::COUNTER_ARRAY);
  return *(counter_array);
}
 
template <> inline
const CounterArray &ActionParam::to<const CounterArray &>(
    ActionEngineState *state) const {
  return ActionParam::to<CounterArray &>(state);
}
 
template <> inline
RegisterArray &ActionParam::to<RegisterArray &>(
    ActionEngineState *state) const {
  (void) state;
  assert(tag == ActionParam::REGISTER_ARRAY);
  return *(register_array);
}
 
template <> inline
const RegisterArray &ActionParam::to<const RegisterArray &>(
    ActionEngineState *state) const {
  return ActionParam::to<RegisterArray &>(state);
}
 
template <> inline
ExternType *ActionParam::to<ExternType *>(ActionEngineState *state) const {
  (void) state;
  assert(tag == ActionParam::EXTERN_INSTANCE);
  return extern_instance;
}
 
template <> inline
const std::string &ActionParam::to<const std::string &>(
    ActionEngineState *state) const {
  assert(tag == ActionParam::STRING);
  (void) state;
  return *str;
}
 
// just a convenience function, I expect the version above to be the most used
// one
template <> inline
const char *ActionParam::to<const char *>(ActionEngineState *state) const {
  assert(tag == ActionParam::STRING);
  (void) state;
  return str->c_str();
}
 
// used for primitives that take as a parameter a "list" of values. Currently we
// only support "const std::vector<Data>" as the type used by the C++ primitive
// and currently this is only used by log_msg.
// TODO(antonin): more types (e.g. "const std::vector<const Data &>") if needed
// we can support list of other value types as well, e.g. list of headers
// we are not limited to using a vector as the data structure either
template <> inline
const std::vector<Data>
ActionParam::to<const std::vector<Data>>(ActionEngineState *state) const {
  _BM_ASSERT(tag == ActionParam::PARAMS_VECTOR && "not a params vector");
  std::vector<Data> vec;
 
  for (auto i = params_vector.start ; i < params_vector.end ; i++) {
    // re-use previously-defined cast method; note that we use to<const Data &>
    // and not to<const Data>, as it does not exists
    // if something in the parameters_vector cannot be cast to "const Data &",
    // the code will assert
    vec.push_back(state->parameters_vector[i].to<const Data &>(state));
  }
 
  return vec;
}
 
template <> inline
const std::vector<Field>
ActionParam::to<const std::vector<Field>>(ActionEngineState *state) const {
  _BM_ASSERT(tag == ActionParam::FIELD_LIST && "not a field list");
  std::vector<Field> vec;
 
  for (auto i = field_list.start ; i < field_list.end ; i++) {
    // re-use previously-defined cast method; note that we use to<const Field &>
    // and not to<const Field>, as it does not exists
    // if something in the field list cannot be cast to "const Field &",
    // the code will assert
    vec.push_back(state->field_list[i].to<const Field &>(state));
  }
 
  return vec;
}
 
/* This is adapted from stack overflow code:
   http://stackoverflow.com/questions/11044504/any-solution-to-unpack-a-vector-to-function-arguments-in-c
*/
 
template <std::size_t... Indices>
struct indices {
  using next = indices<Indices..., sizeof...(Indices)>;
};
 
template <std::size_t N>
struct build_indices {
  using type = typename build_indices<N-1>::type::next;
};
 
template <>
struct build_indices<0> {
  using type = indices<>;
};
 
template <std::size_t N>
using BuildIndices = typename build_indices<N>::type;
 
template <typename... Args>
struct unpack_caller {
 private:
  template <typename T, size_t... I>
  void call(T *pObj, ActionEngineState *state,
            const ActionParam *args,
            const indices<I...>) {
    // I guess we can have an unused parameter warning if an instantiation has
    // an empty indices list
    (void) state; (void) args;
#define ELEM_TYPE typename std::tuple_element<I, std::tuple<Args...>>::type
    (*pObj)(args[I].to<ELEM_TYPE>(state)...);
#undef ELEM_TYPE
  }
 
 public:
  template <typename T>
  void operator () (T* pObj, ActionEngineState *state,
                    const ActionParam *args){
    // assert(args.size() == sizeof...(Args)); // just to be sure
    call(pObj, state, args, BuildIndices<sizeof...(Args)>{});
  }
};
 
class ActionPrimitive_ {
 public:
  virtual ~ActionPrimitive_() { }
 
  virtual void execute(
      ActionEngineState *state,
      const ActionParam *args) = 0;
 
  virtual size_t get_num_params() const = 0;
 
  virtual size_t get_jump_offset(size_t current_offset) const {
    return current_offset + 1;
  }
 
  void _set_p4objects(P4Objects *p4objects) {
    this->p4objects = p4objects;
  }
 
  void set_source_info(SourceInfo *source_info) {
    call_source_info = source_info;
  }
 
 protected:
  // This used to be regular members in ActionPrimitive, but there could be a
  // race condition. Making them thread_local solves the issue. I moved these
  // from ActionPrimitive because g++4.8 has a bug when using thread_local class
  // variables with templates
  // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60056).
  static thread_local Packet *pkt;
  static thread_local PHV *phv;
  static thread_local SourceInfo *call_source_info;
 
  P4Objects *get_p4objects() {
    return p4objects;
  }
 
 private:
  P4Objects *p4objects{nullptr};
};
 
template <typename... Args>
class ActionPrimitive :  public ActionPrimitive_ {
 public:
  void execute(ActionEngineState *state, const ActionParam *args) override {
    phv = &(state->phv);
    pkt = &(state->pkt);
    caller(this, state, args);
  }
 
  // cannot make it constexpr because it is virtual
  size_t get_num_params() const override { return sizeof...(Args); }
 
  virtual void operator ()(Args...) = 0;
 
 protected:
  Field &get_field(const std::string &name) {
    return phv->get_field(name);
  }
 
  Header &get_header(const std::string &name) {
    return phv->get_header(name);
  }
 
  // in practice, regular primitives should not have to use this
  PHV &get_phv() {
    return *phv;
  }
 
  // so far used only for meter arrays and counter arrays
  Packet &get_packet() {
    return *pkt;
  }
 
 private:
  unpack_caller<Args...> caller;
  // See thread_local members in ActionPrimitive_ class
  // PHV *phv;
  // Packet *pkt;
};
 
 
// forward declaration
class ActionFnEntry;
 
class ActionPrimitiveCall {
 public:
  explicit ActionPrimitiveCall(
      ActionPrimitive_ *primitive, size_t param_offset,
      std::unique_ptr<SourceInfo> source_info = nullptr);
 
  void execute(ActionEngineState *state, const ActionParam *args) const;
 
  size_t get_num_params() const;
 
  size_t get_param_offset() const { return param_offset; }
 
  size_t get_jump_offset(size_t current_offset) const {
    return primitive->get_jump_offset(current_offset);
  }
 
  SourceInfo *get_source_info() const { return source_info.get(); }
 
 private:
  ActionPrimitive_ *primitive;
  size_t param_offset;
  std::unique_ptr<SourceInfo> source_info;
};
 
class ActionFn :  public NamedP4Object {
  friend class ActionFnEntry;
 
 public:
  ActionFn(const std::string &name, p4object_id_t id, size_t num_params);
 
  ActionFn(const std::string &name, p4object_id_t id, size_t num_params,
           std::unique_ptr<SourceInfo> source_info);
 
  // these parameter_push_back_* methods are not very well named. They are used
  // to push arguments to the primitives; and are independent of the actual
  // parameters for the P4 action
  void parameter_push_back_field(header_id_t header, int field_offset);
  void parameter_push_back_header(header_id_t header);
  void parameter_push_back_header_stack(header_stack_id_t header_stack);
  void parameter_push_back_last_header_stack_field(
      header_stack_id_t header_stack, int field_offset);
  void parameter_push_back_header_union(header_union_id_t header_union);
  void parameter_push_back_header_union_stack(
      header_union_stack_id_t header_union_stack);
  void parameter_push_back_const(const Data &data);
  void parameter_push_back_action_data(int action_data_offset);
  void parameter_push_back_register_ref(RegisterArray *register_array,
                                        unsigned int idx);
  void parameter_push_back_register_gen(RegisterArray *register_array,
                                        std::unique_ptr<ArithExpression> idx);
  void parameter_push_back_calculation(const NamedCalculation *calculation);
  void parameter_push_back_meter_array(MeterArray *meter_array);
  void parameter_push_back_counter_array(CounterArray *counter_array);
  void parameter_push_back_register_array(RegisterArray *register_array);
  void parameter_push_back_expression(std::unique_ptr<Expression> expr);
  void parameter_push_back_expression(std::unique_ptr<Expression> expr,
                                      ExprType expr_type);
  void parameter_push_back_extern_instance(ExternType *extern_instance);
  void parameter_push_back_string(const std::string &str);
 
  // These methods are used when we need to push a "vector of parameters"
  // (i.e. when a primitive, such as log_msg, uses a list of values as one of
  // its parameters). First parameter_start_vector is called to signal the
  // beginning of the "vector of parameters", then the parameter_push_back_*
  // methods are called as usual, and finally parameter_end_vector is called to
  // signal the end.
  void parameter_start_vector();
  void parameter_end_vector();
  void parameter_start_field_list();
  void parameter_end_field_list();
 
  void push_back_primitive(ActionPrimitive_ *primitive,
                           std::unique_ptr<SourceInfo> source_info = nullptr);
 
  void grab_register_accesses(RegisterSync *register_sync) const;
 
  size_t get_num_params() const;
 
 private:
  using ParameterList = std::vector<ActionParam>;
 
  std::vector<ActionPrimitiveCall> primitives{};
  ParameterList params{};
  ParameterList sub_params{};
  RegisterSync register_sync{};
  std::vector<Data> const_values{};
  // should I store the objects in the vector, instead of pointers?
  std::vector<std::unique_ptr<Expression> > expressions{};
  std::vector<std::string> strings{};
  size_t num_params;
 
 private:
  static size_t nb_data_tmps;
};
 
class ActionFnEntry {
 public:
  ActionFnEntry() { }
 
  ActionFnEntry(const ActionFn *action_fn, ActionData action_data)
    : action_fn(action_fn), action_data(std::move(action_data)) { }
 
  explicit ActionFnEntry(const ActionFn *action_fn)
    : action_fn(action_fn) { }
 
  // log event, notify debugger if needed, lock registers, then call execute()
  void operator()(Packet *pkt) const;
 
  void execute(Packet *pkt) const;
 
  void push_back_action_data(const Data &data);
 
  void push_back_action_data(unsigned int data);
 
  void push_back_action_data(const char *bytes, int nbytes);
 
  size_t action_data_size() const { return action_data.size(); }
 
  const Data &get_action_data_at(int offset) const {
    return action_data.get(offset);
  }
 
  const ActionData &get_action_data() const {
    return action_data;
  }
 
  void dump(std::ostream *stream) const;
 
  void serialize(std::ostream *out) const;
  void deserialize(std::istream *in, const P4Objects &objs);
 
  p4object_id_t get_action_id() const {
    if (!action_fn) return std::numeric_limits<p4object_id_t>::max();
    return action_fn->get_id();
  }
 
  const ActionFn *get_action_fn() const {
    return action_fn;
  }
 
  ActionFnEntry(const ActionFnEntry &other) = default;
  ActionFnEntry &operator=(const ActionFnEntry &other) = default;
 
  // NOLINTNEXTLINE(whitespace/operators)
  ActionFnEntry(ActionFnEntry &&other) /*noexcept*/ = default;
  // NOLINTNEXTLINE(whitespace/operators)
  ActionFnEntry &operator=(ActionFnEntry &&other) /*noexcept*/ = default;
 
 private:
  const ActionFn *action_fn{nullptr};
  ActionData action_data{};
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_ACTIONS_H_