learning.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_LEARNING_H_
#define BM_BM_SIM_LEARNING_H_
 
#include <string>
#include <vector>
#include <memory>
#include <functional>
 
#include "device_id.h"
#include "transport.h"
#include "phv_forward.h"
 
namespace bm {
 
class Packet;
 
// TODO(antonin): automate learning (i.e. make it target-independent)?
 
class LearnEngineIface {
 public:
  using list_id_t = int;
  using buffer_id_t = uint64_t;
 
  enum LearnErrorCode {
    SUCCESS = 0,
    INVALID_LIST_ID,
    INVALID_LIST_NAME,
    ERROR
  };
 
  // the header size for notifications is always 32 bytes
  struct msg_hdr_t {
    char sub_topic[4];
    s_device_id_t switch_id;
    s_cxt_id_t cxt_id;
    int list_id;
    uint64_t buffer_id;
    unsigned int num_samples;
  } __attribute__((packed));
 
  using LearnCb = std::function<void(const msg_hdr_t &, size_t,
                                     std::unique_ptr<char[]>, void *)>;
 
  virtual ~LearnEngineIface() { }
 
  virtual void list_create(list_id_t list_id, const std::string &list_name,
                           size_t max_samples = 1,
                           unsigned int timeout_ms = 1000) = 0;
 
  virtual void list_set_learn_writer(
      list_id_t list_id, std::shared_ptr<TransportIface> learn_writer) = 0;
 
  virtual void list_set_learn_cb(list_id_t list_id, const LearnCb &learn_cb,
                                 void * cookie) = 0;
 
  virtual void list_push_back_field(list_id_t list_id, header_id_t header_id,
                                    int field_offset) = 0;
 
  virtual void list_push_back_constant(list_id_t list_id,
                                       const std::string &hexstring) = 0;
 
  virtual void list_init(list_id_t list_id) = 0;
 
  virtual LearnErrorCode list_set_timeout(list_id_t list_id,
                                          unsigned int timeout_ms) = 0;
 
  virtual LearnErrorCode list_set_max_samples(list_id_t list_id,
                                              size_t max_samples) = 0;
 
  virtual LearnErrorCode list_get_name_from_id(
      list_id_t list_id, std::string *list_name) const = 0;
 
  virtual LearnErrorCode list_get_id_from_name(
      const std::string &list_name, list_id_t *list_id) const = 0;
 
  virtual void learn(list_id_t list_id, const Packet &pkt) = 0;
 
  virtual LearnErrorCode ack(list_id_t list_id, buffer_id_t buffer_id,
                             int sample_id) = 0;
  virtual LearnErrorCode ack(list_id_t list_id, buffer_id_t buffer_id,
                             const std::vector<int> &sample_ids) = 0;
  virtual LearnErrorCode ack_buffer(list_id_t list_id,
                                    buffer_id_t buffer_id) = 0;
 
  virtual void reset_state() = 0;
 
  static std::unique_ptr<LearnEngineIface> make(device_id_t device_id = 0,
                                                cxt_id_t cxt_id = 0);
};
 
}  // namespace bm
 
#endif  // BM_BM_SIM_LEARNING_H_