dpdkContext.h

/*
 * Copyright 2021 Intel Corp.
 * SPDX-FileCopyrightText: 2021 Intel Corp.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef BACKENDS_DPDK_DPDKCONTEXT_H_
#define BACKENDS_DPDK_DPDKCONTEXT_H_
 
#include <regex>
 
#include "constants.h"
#include "control-plane/bfruntime.h"
#include "dpdkProgramStructure.h"
#include "lib/cstring.h"
#include "lib/json.h"
#include "lib/nullstream.h"
#include "options.h"
#include "p4/config/v1/p4info.pb.h"
 
namespace p4configv1 = ::p4::config::v1;

 
namespace P4::DPDK {
 
using namespace P4::literals;

struct TableAttributes {
    cstring direction;
    unsigned tableHandle;
    cstring tableType;
    bool is_add_on_miss;
    bool idle_timeout_with_auto_delete;
    bool isHidden;
    unsigned size;
    cstring controlName;
    cstring externalName;
    unsigned default_action_handle;
    /* Non selector table keys from original P4 program */
    std::vector<std::pair<cstring, cstring>> tableKeys;
};

struct actionAttributes {
    bool constant_default_action;
    bool is_compiler_added_action;
    bool allowed_as_hit_action;
    bool allowed_as_default_action;
    unsigned actionHandle;
    cstring externalName;
    IR::IndexedVector<IR::Parameter> *params;
};
 
struct externAttributes {
    cstring externalName;
    cstring externType;
    cstring counterType;
    unsigned table_id;
};

struct TopLevelCtxt {
    std::string progName;
    cstring buildDate;
    cstring compileCommand;
    cstring compilerVersion;
    void initTopLevelCtxt(DpdkOptions &options) {
        buildDate = options.getBuildDate();
        compileCommand = options.getCompileCommand();
        progName = options.file.stem();
        compilerVersion = options.compilerVersion;
    }
};

struct SelectionTable {
    unsigned max_n_groups;
    unsigned max_n_members_per_group;
    unsigned bound_to_action_data_table_handle;
    void setAttributes(const IR::P4Table *tbl,
                       const std::map<const cstring, struct TableAttributes> &tableAttrmap) {
        max_n_groups = 0;
        max_n_members_per_group = 0;
        auto n_groups = tbl->properties->getProperty("n_groups_max");
        if (n_groups) {
            auto n_groups_expr = n_groups->value->to<IR::ExpressionValue>()->expression;
            max_n_groups = n_groups_expr->to<IR::Constant>()->asInt();
        }
        auto n_members = tbl->properties->getProperty("n_members_per_group_max");
        if (n_members) {
            auto n_members_expr = n_members->value->to<IR::ExpressionValue>()->expression;
            max_n_members_per_group = n_members_expr->to<IR::Constant>()->asInt();
        }
        // Fetch associated member table handle
        cstring actionDataTableName = tbl->name.originalName.replace("_sel", "");
        auto actionTableAttr = ::P4::get(tableAttrmap, actionDataTableName);
        bound_to_action_data_table_handle = actionTableAttr.tableHandle;
    }
};

class DpdkContextGenerator : public Inspector {
    P4::ReferenceMap *refmap;
    DpdkProgramStructure *structure;
    const p4configv1::P4Info &p4info;
    DpdkOptions &options;
    IR::IndexedVector<IR::Declaration> tables;
    std::vector<const IR::Declaration_Instance *> externs;

    std::map<const cstring, struct TableAttributes> tableAttrmap;
    std::map<cstring, struct actionAttributes> actionAttrMap;
    std::map<cstring, struct externAttributes> externAttrMap;

    std::map<cstring, size_t> context_handle_map;
 
 public:
    DpdkContextGenerator(P4::ReferenceMap *refmap, DpdkProgramStructure *structure,
                         const p4configv1::P4Info &p4info, DpdkOptions &options)
        : refmap(refmap), structure(structure), p4info(p4info), options(options) {}
 
    void serializeContextJson(std::ostream *destination);
    const Util::JsonObject *genContextJsonObject();
    void addMatchTables(Util::JsonArray *tablesJson);
    size_t getHandleId(cstring name);
    void collectHandleId();
    void addExternInfo(Util::JsonArray *externsJson);
    Util::JsonObject *initTableCommonJson(const cstring name, const struct TableAttributes &attr);
    void addKeyField(Util::JsonArray *keyJson, const cstring name, const cstring annon,
                     const IR::KeyElement *key, int position);
    Util::JsonArray *addActions(const IR::P4Table *table, const cstring ctrlName, bool isMatch);
    bool addRefTables(const cstring tbl_name, const IR::P4Table **memberTable,
                      Util::JsonObject *tableJson);
    void addImmediateField(Util::JsonArray *paramJson, const cstring name, int dest_start,
                           int dest_Width);
    void addActionParam(Util::JsonArray *paramJson, const cstring name, int bitWidth, int position,
                        int byte_array_index);
    Util::JsonObject *addMatchAttributes(const IR::P4Table *table, const cstring ctrlName);
    void setActionAttributes(const IR::P4Table *table);
    void setDefaultActionHandle(const IR::P4Table *table);
    void CollectTablesAndSetAttributes();
    cstring removePipePrefix(cstring);
};
 
}  // namespace P4::DPDK
 
#endif /* BACKENDS_DPDK_DPDKCONTEXT_H_ */