Introduced new checksum APIs in v1model.p4 (#939)

Author: Mihai Budiu

backends/bmv2/backend.cpp

@@ -92,6 +92,7 @@ Backend::process(const IR::ToplevelBlock* tlb, BMV2Options& options) {
         simpleSwitch->setPipelineControls(tlb, &pipeline_controls, &pipeline_namemap);
         simpleSwitch->setNonPipelineControls(tlb, &non_pipeline_controls);
         simpleSwitch->setUpdateChecksumControls(tlb, &update_checksum_controls);
+        simpleSwitch->setVerifyChecksumControls(tlb, &verify_checksum_controls);
         simpleSwitch->setDeparserControls(tlb, &deparser_controls);
     } else if (target == Target::PORTABLE) {
         P4C_UNIMPLEMENTED("PSA architecture is not yet implemented");
@@ -107,7 +108,6 @@ Backend::process(const IR::ToplevelBlock* tlb, BMV2Options& options) {
         new P4::ConstantFolding(refMap, typeMap, false),
         new P4::TypeChecking(refMap, typeMap),
         new RemoveComplexExpressions(refMap, typeMap, new ProcessControls(&pipeline_controls)),
-        new FixupChecksum(&update_checksum_controls),
         new P4::SimplifyControlFlow(refMap, typeMap),
         new P4::RemoveAllUnusedDeclarations(refMap),
         new DiscoverStructure(&structure),

backends/bmv2/backend.h

@@ -85,6 +85,7 @@ class Backend : public PassManager {
     std::set<cstring>                pipeline_controls;
     std::set<cstring>                non_pipeline_controls;
     std::set<cstring>                update_checksum_controls;
+    std::set<cstring>                verify_checksum_controls;
     std::set<cstring>                deparser_controls;
 
     // bmv2 expects 'ingress' and 'egress' pipeline to have fixed name.

backends/bmv2/control.cpp

@@ -738,14 +738,21 @@ bool ChecksumConverter::preorder(const IR::PackageBlock *block) {
 
 bool ChecksumConverter::preorder(const IR::ControlBlock* block) {
     auto it = backend->update_checksum_controls.find(block->container->name);
-    if (it == backend->update_checksum_controls.end()) {
-        return false;
-    }
-
-    if (backend->target == Target::SIMPLE) {
-        P4V1::SimpleSwitch* ss = backend->getSimpleSwitch();
-        ss->convertChecksumUpdate(block->container, backend->json->checksums,
-                                  backend->json->calculations);
+    if (it != backend->update_checksum_controls.end()) {
+        if (backend->target == Target::SIMPLE) {
+            P4V1::SimpleSwitch* ss = backend->getSimpleSwitch();
+            ss->convertChecksum(block->container->body, backend->json->checksums,
+                                backend->json->calculations, false);
+        }
+    } else {
+        it = backend->verify_checksum_controls.find(block->container->name);
+        if (it != backend->verify_checksum_controls.end()) {
+            if (backend->target == Target::SIMPLE) {
+                P4V1::SimpleSwitch* ss = backend->getSimpleSwitch();
+                ss->convertChecksum(block->container->body, backend->json->checksums,
+                                    backend->json->calculations, true);
+            }
+        }
     }
     return false;
 }

backends/bmv2/lower.cpp

@@ -135,249 +135,6 @@ const IR::Node* LowerExpressions::postorder(IR::Concat* expression) {
 /////////////////////////////////////////////////////////////
 
 namespace {
-
-/**
-A list of assignments that all write to a "variable".
-This really only handles scalar variables.
-It is customized for the needs of FixupChecksum.
-*/
-struct VariableWriters {
-    std::set<const IR::AssignmentStatement*> writers;
-    VariableWriters() = default;
-    explicit VariableWriters(const IR::AssignmentStatement* writer)
-    { writers.emplace(writer); }
-    VariableWriters* join(const VariableWriters* other) const {
-        auto result = new VariableWriters();
-        result->writers = writers;
-        for (auto e : other->writers)
-            result->writers.emplace(e);
-        return result;
-    }
-    /**
-       This function returns a non-null value only if there is exaclty one writer statement.
-       In that case it returns the RHS of the assignment
-    */
-    const IR::Expression* substitution() const {
-        if (writers.size() != 1)
-            return nullptr;
-        auto first = *writers.begin();
-        return first->right;
-    }
-};
-
-/**
-Maintains a map from variable names to VariableWriters
-It is customized for the needs of FixupChecksum.
-*/
-struct VariableDefinitions {
-    std::map<cstring, const VariableWriters*> writers;
-    VariableDefinitions(const VariableDefinitions& other) = default;
-    VariableDefinitions() = default;
-    VariableDefinitions* clone() const {
-        return new VariableDefinitions(*this);
-    }
-    VariableDefinitions* join(const VariableDefinitions* other) const {
-        auto result = clone();
-        for (auto e : other->writers) {
-            auto &prev = result->writers[e.first];
-            prev = prev ? prev->join(e.second) : e.second;
-        }
-        return result;
-    }
-    void declare(const IR::Declaration_Variable* decl) {
-        writers.emplace(decl->getName().name, new VariableWriters());
-    }
-    const VariableWriters* getWriters(const IR::Path* path) {
-        if (path->absolute)
-            return nullptr;
-        return ::get(writers, path->name.name);
-    }
-    VariableDefinitions* setDefinition(const IR::Path* path,
-                                       const IR::AssignmentStatement* statement) {
-        auto w = getWriters(path);
-        if (w == nullptr)
-            // Path does not represent a variable
-            return this;
-        auto result = clone();
-        result->writers[path->name.name] = new VariableWriters(statement);
-        return result;
-    }
-};
-
-/**
-Maintain def-use information.
-It is customized for the needs of FixupChecksum.
-*/
-struct PathSubstitutions {
-    std::map<const IR::PathExpression*, const IR::Expression*> definitions;
-    std::set<const IR::AssignmentStatement*> haveUses;
-    PathSubstitutions() = default;
-    void add(const IR::PathExpression* path, const IR::Expression* expression) {
-        definitions.emplace(path, expression);
-        LOG3("Will substitute " << dbp(path) << " with " << expression);
-    }
-    const IR::Expression* get(const IR::PathExpression* path) const {
-        return ::get(definitions, path);
-    }
-    void foundUses(const VariableWriters* writers) {
-        for (auto w : writers->writers)
-            haveUses.emplace(w);
-    }
-    void foundUses(const IR::AssignmentStatement* statement) {
-        haveUses.emplace(statement);
-    }
-    bool hasUses(const IR::AssignmentStatement* statement) const {
-        return haveUses.find(statement) != haveUses.end();
-    }
-};
-
-/**
-See the SimpleCopyProp pass below for the context in which this
-analysis is run.  We take advantage that some more complex code
-patterns have already been eliminated.
-*/
-class Accesses : public Inspector {
-    PathSubstitutions* substitutions;
-    VariableDefinitions* currentDefinitions;
-
-    bool notSupported(const IR::Node* node) {
-        ::error("%1%: not supported in checksum update control", node);
-        return false;
-    }
-
- public:
-    explicit Accesses(PathSubstitutions* substitutions): substitutions(substitutions) {
-        CHECK_NULL(substitutions); setName("Accesses");
-        currentDefinitions = new VariableDefinitions();
-    }
-
-    bool preorder(const IR::Declaration_Variable* decl) override {
-        // we assume all variable declarations are at the beginning
-        currentDefinitions->declare(decl);
-        return false;
-    }
-
-    // This is only invoked for read expressions
-    bool preorder(const IR::PathExpression* expression) override {
-        auto writers = currentDefinitions->getWriters(expression->path);
-        if (writers != nullptr) {
-            if (auto s = writers->substitution())
-                substitutions->add(expression, s);
-            else
-                substitutions->foundUses(writers);
-        }
-        return false;
-    }
-
-    bool preorder(const IR::AssignmentStatement* statement) override {
-        visit(statement->right);
-        if (statement->left->is<IR::PathExpression>()) {
-            auto pe = statement->left->to<IR::PathExpression>();
-            currentDefinitions = currentDefinitions->setDefinition(pe->path, statement);
-        } else {
-            substitutions->foundUses(statement);
-        }
-        return false;
-    }
-
-    bool preorder(const IR::IfStatement* statement) override {
-        visit(statement->condition);
-        auto defs = currentDefinitions->clone();
-        visit(statement->ifTrue);
-        auto afterTrue = currentDefinitions;
-        if (statement->ifFalse != nullptr) {
-            currentDefinitions = defs;
-            visit(statement->ifFalse);
-            currentDefinitions = afterTrue->join(currentDefinitions);
-        } else {
-            currentDefinitions = defs->join(afterTrue);
-        }
-        return false;
-    }
-
-    bool preorder(const IR::SwitchStatement* statement) override
-    { return notSupported(statement); }
-
-    bool preorder(const IR::P4Action* action) override
-    { return notSupported(action); }
-
-    bool preorder(const IR::P4Table* table) override
-    { return notSupported(table); }
-
-    bool preorder(const IR::ReturnStatement* statement) override
-    { return notSupported(statement); }
-
-    bool preorder(const IR::ExitStatement* statement) override
-    { return notSupported(statement); }
-};
-
-class Replace : public Transform {
-    const PathSubstitutions* substitutions;
- public:
-    explicit Replace(const PathSubstitutions* substitutions): substitutions(substitutions) {
-        CHECK_NULL(substitutions); setName("Replace"); }
-
-    const IR::Node* postorder(IR::AssignmentStatement* statement) override {
-        if (!substitutions->hasUses(getOriginal<IR::AssignmentStatement>()))
-            return new IR::EmptyStatement();
-        return statement;
-    }
-
-    const IR::Node* postorder(IR::PathExpression* expression) override {
-        auto repl = substitutions->get(getOriginal<IR::PathExpression>());
-        if (repl != nullptr) {
-            Replace rpl(substitutions);
-            auto recurse = repl->apply(rpl);
-            return recurse;
-        }
-        return expression;
-    }
-};
-
-/**
-This analysis is only executed on the control which performs
-checksum update computations.
-
-This is a simpler variant of copy propagation; it just finds
-patterns of the form:
-tmp = X;
-...
-out = tmp;
-
-then it substitutes the definition into the use.
-The LocalCopyPropagation pass does not do this, because
-it won't consider replacing definitions where the RHS has side-effects.
-Since the only method call we accept in the checksum update block
-is a checksum unit "get" method (this is not checked here, but
-in the json code generator), we know that this method has no side-effects,
-so we can safely reorder calls to methods.
-Also, this is run after eliminating struct and tuple operations,
-so we know that all assignments operate on scalar values.
-*/
-class SimpleCopyProp : public PassManager {
-    PathSubstitutions substitutions;
- public:
-    SimpleCopyProp() {
-        setName("SimpleCopyProp");
-        passes.push_back(new Accesses(&substitutions));
-        passes.push_back(new Replace(&substitutions));
-    }
-};
-
-}  // namespace
-
-const IR::Node* FixupChecksum::preorder(IR::P4Control* control) {
-    if (updateChecksumBlocks->find(control->name) != updateChecksumBlocks->end()) {
-        SimpleCopyProp scp;
-        return control->apply(scp);
-    }
-    return control;
-}
-
-////////////////////////////////////////////////////////////////////////////////////
-
-namespace {
-
 /**
 Detect whether a Select expression is too complicated for BMv2.
 Also used to detect complex expressions that are arguments

backends/bmv2/lower.h

@@ -49,24 +49,6 @@ class LowerExpressions : public Transform {
     { prune(); return table; }  // don't simplify expressions in table
 };
 
-/**
-This pass is a hack to work around current BMv2 limitations:
-checksum computations must be expressed in a restricted way, since
-the JSON code generator uses simple pattern-matching.
-
-The real solution to this problem is to have the BMv2 simulator use a
-real extern for computing and verifying checksums.  Then this hack
-would not be necessary anymore.
-*/
-class FixupChecksum : public Transform {
-    const std::set<cstring>* updateChecksumBlocks;
- public:
-    explicit FixupChecksum(const std::set<cstring>* updateChecksumBlocks) :
-            updateChecksumBlocks(updateChecksumBlocks)
-    { setName("FixupChecksum"); }
-    const IR::Node* preorder(IR::P4Control* control) override;
-};
-
 /**
 Policy which selects the control blocks where remove
 complex expression is applied.

backends/bmv2/portableSwitch.cpp

@@ -94,12 +94,3 @@ std::ostream& operator<<(std::ostream &out, P4::Extern_Model* p) {
     }
     return out;
 }
-
-// getSkipControls();
-
-// getPipelineControls();
-
-// getUpdateChecksum();
-
-
-