DPDK backend: Add support for meter and counter PSA externs

CMakeLists.txt

@@ -377,6 +377,11 @@ add_custom_target(update_includes ALL
     ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/\$$h ${P4C_BINARY_DIR}/p4include \;
   done
   )
+if (ENABLE_DPDK)
+add_custom_target(dpdk_includes ALL
+  COMMAND ${CMAKE_COMMAND} -E make_directory ${P4C_BINARY_DIR}/p4include/dpdk
+  COMMAND ${CMAKE_COMMAND} -E copy_if_different ${P4C_SOURCE_DIR}/p4include/dpdk/psa.p4 ${P4C_BINARY_DIR}/p4include/dpdk)
+endif ()
 
 # Installation
 # Targets install themselves. Here we install the core headers

backends/dpdk/DpdkXfail.cmake

@@ -10,10 +10,15 @@ p4c_add_xfail_reason("dpdk"
   )
 
 p4c_add_xfail_reason("dpdk"
-  "Meter Not implemented"
+  "LHS of meter execute"
+  testdata/p4_16_samples/psa-meter1.p4
+)
+
+p4c_add_xfail_reason("dpdk"
+  "Expected atleast 2 arguments"
   testdata/p4_16_samples/psa-meter3.p4
   testdata/p4_16_samples/psa-meter7-bmv2.p4
-  )
+)
 
 # symbolic evaluator does not support verify() statement
 p4c_add_xfail_reason("dpdk"

backends/dpdk/dpdk.def

@@ -433,17 +433,27 @@ class DpdkVerifyStatement: DpdkAsmStatement, IDPDKNode {
 #nodbprint
 }
 
+class DpdkMeterDeclStatement: DpdkAsmStatement {
+    cstring meter;
+    Expression size;
+    std::ostream& toSpec(std::ostream& out) const override;
+#nodbprint
+}
+
 class DpdkMeterExecuteStatement: DpdkAsmStatement, IDPDKNode {
     cstring meter;
     Expression index;
-    Expression color;
+    NullOK Expression length;
+    Expression color_in;
+    Expression color_out;
     std::ostream& toSpec(std::ostream& out) const override;
 #nodbprint
 }
 
 class DpdkCounterCountStatement: DpdkAsmStatement, IDPDKNode {
     cstring counter;
     Expression index;
+    NullOK optional Expression incr;
     std::ostream& toSpec(std::ostream& out) const override;
 #nodbprint
 }

backends/dpdk/dpdkArch.h

@@ -446,32 +446,95 @@ class ConvertInternetChecksum : public PassManager {
  * for emitting to the .spec file later */
 class CollectRegisterDeclaration : public Inspector {
     std::map<const IR::Declaration_Instance *, cstring> *reg_map;
-
+    P4::TypeMap *typeMap;
+
   public:
     CollectRegisterDeclaration(
-        std::map<const IR::Declaration_Instance *, cstring> *reg_map, P4::TypeMap *)
-        : reg_map(reg_map) {}
+        std::map<const IR::Declaration_Instance *, cstring> *reg_map, P4::TypeMap *typeMap)
+        : reg_map(reg_map),  typeMap(typeMap) {}
 
     bool preorder(const IR::Declaration_Instance *d) override {
         if (d->type->is<IR::Type_Specialized>()) {
             auto type = d->type->to<IR::Type_Specialized>();
             auto externTypeName = type->baseType->path->name.name;
             if (externTypeName == "Register"){
-              if (d->arguments->size() != 1 and d->arguments->size() != 2 ) {
-                  ::error("%1%: expected size and optionally init_val as arguments", d);
-              }
-              reg_map->emplace(d, d->name);
+                if (d->arguments->size() != 1 and d->arguments->size() != 2 ) {
+                    ::error("%1%: expected size and optionally init_val as arguments", d);
+                }
+                reg_map->emplace(d, d->name);
+            }
+        }
+        return false;
+    }
+};
+
+/* This pass collects PSA meter declaration instances and push them to a map
+ * for emitting to the .spec file later */
+class CollectMeterDeclaration : public Inspector {
+    std::map<const IR::Declaration_Instance *, cstring> *met_map;
+    P4::TypeMap *typeMap;
+
+  public:
+    CollectMeterDeclaration(
+        std::map<const IR::Declaration_Instance *, cstring> *met_map, P4::TypeMap *typeMap)
+        : met_map(met_map) , typeMap(typeMap) {}
+
+    bool preorder(const IR::Declaration_Instance *d) override {
+        if (d->type->is<IR::Type_Specialized>()) {
+            auto type = d->type->to<IR::Type_Specialized>();
+            auto externTypeName = type->baseType->path->name.name;
+            if (externTypeName == "Meter"){
+                if (d->arguments->size() != 2) {
+                    ::error("%1%: expected number of meters and type of meter as arguments", d);
+                } else {
+                    if (d->arguments->at(1) == 0)
+                        ::warning(ErrorType::WARN_UNSUPPORTED,
+                                  "%1%: Packet metering is not supported." \
+                                  " Falling back to byte metering.", d);
+                    met_map->emplace(d, d->name);
+                }
             }
          }
          return false;
     }
 };
 
-class AddRegisterDeclaration : public PassManager {
+/* This pass collects PSA counter declaration instances and push them to a map
+ * for emitting to the .spec file later */
+class CollectCounterDeclaration : public Inspector {
+    std::map<const IR::Declaration_Instance *, cstring> *cnt_map;
+    P4::TypeMap *typeMap;
+
+  public:
+    CollectCounterDeclaration(
+        std::map<const IR::Declaration_Instance *, cstring> *cnt_map, P4::TypeMap *typeMap)
+        : cnt_map(cnt_map) , typeMap(typeMap) {}
+
+    bool preorder(const IR::Declaration_Instance *d) override {
+        if (d->type->is<IR::Type_Specialized>()) {
+            auto type = d->type->to<IR::Type_Specialized>();
+            auto externTypeName = type->baseType->path->name.name;
+            if (externTypeName == "Counter"){
+                if (d->arguments->size() != 2 ) {
+                    ::error("%1%: expected n_counters and counter type as arguments", d);
+                }
+                cnt_map->emplace(d, d->name);
+            }
+        }
+        return false;
+    }
+};
+
+/* This passmanager is for collecting the extern declarations for register meter and counter */
+class AddExternDeclaration : public PassManager {
   public:
     std::map<const IR::Declaration_Instance *, cstring> reg_map;
-    AddRegisterDeclaration(P4::TypeMap *typeMap) {
+    std::map<const IR::Declaration_Instance *, cstring> cnt_map;
+    std::map<const IR::Declaration_Instance *, cstring> met_map;
+    AddExternDeclaration(P4::TypeMap *typeMap) {
         passes.push_back(new CollectRegisterDeclaration(&reg_map, typeMap));
+        passes.push_back(new CollectCounterDeclaration(&cnt_map, typeMap));
+        passes.push_back(new CollectMeterDeclaration(&met_map, typeMap));
     }
 };
 
@@ -584,6 +647,8 @@ class RewriteToDpdkArch : public PassManager {
         *args_struct_map;
     std::map<const IR::Declaration_Instance *, cstring> *csum_map;
     std::map<const IR::Declaration_Instance *, cstring> *reg_map;
+    std::map<const IR::Declaration_Instance *, cstring> *cnt_map;
+    std::map<const IR::Declaration_Instance *, cstring> *met_map;
     RewriteToDpdkArch(P4::ReferenceMap *refMap, P4::TypeMap *typeMap,
                       DpdkVariableCollector *collector) {
         setName("RewriteToDpdkArch");
@@ -631,9 +696,11 @@ class RewriteToDpdkArch : public PassManager {
         args_struct_map = &p->args_struct_map;
         passes.push_back(p);
         passes.push_back(new ConvertLogicalExpression);
-        auto insertRegDeclaration = new AddRegisterDeclaration(typeMap);
-        passes.push_back(insertRegDeclaration);
-        reg_map = &insertRegDeclaration->reg_map;
+        auto insertExternDeclaration = new AddExternDeclaration(typeMap);
+        passes.push_back(insertExternDeclaration);
+        reg_map = &insertExternDeclaration->reg_map;
+        cnt_map = &insertExternDeclaration->cnt_map;
+        met_map = &insertExternDeclaration->met_map;
     }
 };
 

backends/dpdk/dpdkHelpers.cpp

@@ -73,6 +73,27 @@ bool ConvertStatementToDpdk::preorder(const IR::AssignmentStatement *a) {
                     i = new IR::DpdkGetChecksumStatement(
                         left, e->object->getName(), intermediate);
                 }
+            } else if (e->originalExternType->getName().name == "Meter") {
+                if (e->method->getName().name == "execute") {
+                    auto argSize = e->expr->arguments->size();
+
+                    // DPDK target needs index and packet length as mandatory parameters
+                    if (argSize < 2)
+                        ::error(ErrorType::ERR_UNEXPECTED, "Expected atleast 2 arguments for %1%",
+                                e->object->getName());
+                    const IR::Expression *color_in = nullptr;
+                    const IR::Expression *length = nullptr;
+                    auto index = (*e->expr->arguments)[0]->expression;
+                    if (argSize == 2) {
+                        length = (*e->expr->arguments)[1]->expression;
+                        color_in = new IR::Constant(1);
+                    } else if (argSize == 3) {
+                        length = (*e->expr->arguments)[2]->expression;
+                        color_in = (*e->expr->arguments)[1]->expression;
+                    }
+                    i = new IR::DpdkMeterExecuteStatement(
+                         e->object->getName(), index, length, color_in, left);
+                }
             } else if (e->originalExternType->getName().name == "Register") {
                 if (e->method->getName().name == "read") {
                     auto index = (*e->expr->arguments)[0]->expression;
@@ -402,21 +423,46 @@ bool ConvertStatementToDpdk::preorder(const IR::MethodCallStatement *s) {
             }
         } else if (a->originalExternType->getName().name == "Meter") {
             if (a->method->getName().name == "execute") {
-                auto args = a->expr->arguments;
-                auto index = args->at(0)->expression;
-                auto color = args->at(1)->expression;
-                auto meter = a->object->getName();
-                add_instr(
-                    new IR::DpdkMeterExecuteStatement(meter, index, color));
+                // DPDK target requires the result of meter execute method is assigned to a
+                // variable of PSA_MeterColor_t type.
+                ::error(ErrorType::ERR_UNSUPPORTED, "LHS of meter execute statement is missing " \
+                        "Use this format instead : color_out = %1%.execute(index, color_in)",
+                         a->object->getName());
             } else {
                 BUG("Meter function not implemented.");
             }
         } else if (a->originalExternType->getName().name == "Counter") {
+            auto di = a->object->to<IR::Declaration_Instance>();
+            auto declArgs = di->arguments;
+            unsigned value = 0;
+            auto counter_type = declArgs->at(1)->expression;
+            if (counter_type->is<IR::Constant>())
+                value = counter_type->to<IR::Constant>()->asUnsigned();
             if (a->method->getName().name == "count") {
                 auto args = a->expr->arguments;
-                auto index = args->at(0)->expression;
-                auto counter = a->object->getName();
-                add_instr(new IR::DpdkCounterCountStatement(counter, index));
+                if (args->size() < 1){
+                    ::error(ErrorType::ERR_UNEXPECTED, "Expected atleast 1 arguments for %1%",
+                            a->object->getName());
+                } else {
+                    const IR::Expression *incr = nullptr;
+                    auto index = args->at(0)->expression;
+                    auto counter = a->object->getName();
+                    if (args->size() == 2)
+                        incr = args->at(1)->expression;
+                    if (value == 2) {
+                        if (incr) {
+                            add_instr(new IR::DpdkCounterCountStatement(counter+"_packets",
+                                                                        index, incr));
+                            add_instr(new IR::DpdkCounterCountStatement(counter+"_bytes",
+                                                                        index));
+                        } else {
+                           ::error(ErrorType::ERR_UNEXPECTED,
+                                   "Expected packet length argument for %1%", a->object->getName());
+                        }
+                     } else {
+                         add_instr(new IR::DpdkCounterCountStatement(counter, index, incr));
+                     }
+                }
             } else {
                 BUG("Counter function not implemented");
             }

backends/dpdk/dpdkProgram.cpp

@@ -164,6 +164,20 @@ const IR::DpdkAsmProgram *ConvertToDpdkProgram::create(IR::P4Program *prog) {
         externDecls.push_back(st);
     }
 
+    /* Pushing Counter declarations */
+    for (auto kv : *cnt_map) {
+        auto s = kv.first;
+        auto st = new IR::DpdkExternDeclaration(s->name, s->annotations, s->type, s->arguments);
+        externDecls.push_back(st);
+    }
+
+    /* Pushing Meter declarations */
+    for (auto kv : *met_map) {
+        auto s = kv.first;
+        auto st = new IR::DpdkExternDeclaration(s->name, s->annotations, s->type, s->arguments);
+        externDecls.push_back(st);
+    }
+
     return new IR::DpdkAsmProgram(
         headerType, structType, externDecls, ingress_converter->getActions(),
         ingress_converter->getTables(), statements, collector->get_globals());

backends/dpdk/dpdkProgram.h

@@ -58,6 +58,8 @@ class ConvertToDpdkProgram : public Transform {
         *args_struct_map;
     std::map<const IR::Declaration_Instance *, cstring> *csum_map;
     std::map<const IR::Declaration_Instance *, cstring> *reg_map;
+    std::map<const IR::Declaration_Instance *, cstring> *cnt_map;
+    std::map<const IR::Declaration_Instance *, cstring> *met_map;
 
   public:
     ConvertToDpdkProgram(BMV2::PsaProgramStructure &structure,
@@ -70,6 +72,8 @@ class ConvertToDpdkProgram : public Transform {
         args_struct_map = dpdkarch->args_struct_map;
         csum_map = dpdkarch->csum_map;
         reg_map = dpdkarch->reg_map;
+        cnt_map = dpdkarch->cnt_map;
+        met_map = dpdkarch->met_map;
     }
 
     const IR::DpdkAsmProgram *create(IR::P4Program *prog);

backends/dpdk/spec.cpp

@@ -163,10 +163,41 @@ std::ostream &IR::DpdkExternDeclaration::toSpec(std::ostream &out) const {
         }
     }
     else if ( DPDK::toStr(this->getType()) == "Counter") {
-    //TODO yet to be implemented
+        auto args = this->arguments;
+        unsigned value = 0;
+        if (args->size() < 2) {
+          ::error ("Counter extern declaration %1% must contain 2 parameters\n", this->Name());
+        } else {
+          auto n_counters = args->at(0)->expression;
+          auto counter_type = args->at(1)->expression;
+          if (counter_type->is<IR::Constant>())
+              value = counter_type->to<IR::Constant>()->asUnsigned();
+          if (value == 2) {
+              /* For PACKETS_AND_BYTES counter type, two regarray declarations are emitted and
+                 the counter name is suffixed with _packets and _bytes */
+              auto regDecl = new IR::DpdkRegisterDeclStatement(this->Name()+"_packets", n_counters,
+                                                               new IR::Constant(0));
+              regDecl->toSpec(out) << std::endl << std::endl;
+              regDecl = new IR::DpdkRegisterDeclStatement(this->Name()+"_bytes", n_counters,
+                                                          new IR::Constant(0));
+              regDecl->toSpec(out) << std::endl;
+          } else {
+              auto regDecl = new IR::DpdkRegisterDeclStatement(this->Name(), n_counters,
+                                                               new IR::Constant(0));
+              regDecl->toSpec(out) << std::endl;
+          }
+        }
     }
     else if ( DPDK::toStr(this->getType()) == "Meter") {
-    //TODO yet to be implemented
+        auto args = this->arguments;
+        if (args->size() < 2) {
+          ::error ("Meter extern declaration %1% must contain a size parameter \
+                    and meter type parameter", this->Name());
+        } else {
+          auto n_meters = args->at(0)->expression;
+          auto metDecl = new IR::DpdkMeterDeclStatement(this->Name(), n_meters);
+          metDecl->toSpec(out) << std::endl;
+        }
     }
     return out;
 }
@@ -392,7 +423,9 @@ std::ostream &IR::DpdkAction::toSpec(std::ostream &out) const {
     out << "{" << std::endl;
     for (auto i : statements) {
         out << "\t";
-        i->toSpec(out) << std::endl;
+        i->toSpec(out);
+        if (!i->to<IR::DpdkLabelStatement>())
+            out << std::endl;
     }
     out << "\treturn" << std::endl;
     out << "}";
@@ -449,14 +482,26 @@ std::ostream &IR::DpdkVerifyStatement::toSpec(std::ostream &out) const {
     return out;
 }
 
+std::ostream &IR::DpdkMeterDeclStatement::toSpec(std::ostream &out) const {
+    out << "metarray " << meter << " size " << DPDK::toStr(size);
+    return out;
+}
+
 std::ostream &IR::DpdkMeterExecuteStatement::toSpec(std::ostream &out) const {
-    out << "meter_execute " << meter << " " << DPDK::toStr(index) << " "
-        << DPDK::toStr(color);
+    out << "meter " << meter << " " << DPDK::toStr(index) << " " << DPDK::toStr(length);
+    out << " " << DPDK::toStr(color_in) << " " << DPDK::toStr(color_out);
     return out;
 }
 
+/* DPDK target uses Registers for implementing using Counters, atomic register add instruction
+   is used for incrementing the counter. Packet counters are incremented by packet length
+   specified as parameter and byte counters are incremente by 1 */
 std::ostream &IR::DpdkCounterCountStatement::toSpec(std::ostream &out) const {
-    out << "counter_count " << counter << " " << DPDK::toStr(index);
+    out << "regadd " << counter << " " << DPDK::toStr(index) << " ";
+    if (incr)
+        out << DPDK::toStr(incr);
+    else
+        out << "1";
     return out;
 }