souffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::NegativeLabellingTransformer Class Reference

Runs the first stage of the labelling algorithm. More...

#include <MagicSet.h>

Inheritance diagram for souffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::NegativeLabellingTransformer:

Collaboration diagram for souffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::NegativeLabellingTransformer:

Public Member Functions
NegativeLabellingTransformer *	clone () const override
std::string	getName () const override
Public Member Functions inherited from souffle::ast::transform::Transformer
bool	apply (TranslationUnit &translationUnit)
virtual	~Transformer ()=default

Private Member Functions
bool	transform (TranslationUnit &translationUnit) override

Static Private Member Functions
static QualifiedName	getNegativeLabel (const QualifiedName &name)
	Provide a unique name for negatively-labelled relations. More...

Detailed Description

Runs the first stage of the labelling algorithm.

Separates out negated appearances of relations from the main SCC graph, preventing them from affecting stratification once magic dependencies are added.

Definition at line 185 of file MagicSet.h.

Member Function Documentation

clone()

NegativeLabellingTransformer* souffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::NegativeLabellingTransformer::clone ( ) const

inlineoverridevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 191 of file MagicSet.h.

                                                         {
        return new NegativeLabellingTransformer();
    }

getName()

std::string souffle::ast::transform::MagicSetTransformer::LabelDatabaseTransformer::NegativeLabellingTransformer::getName ( ) const

inlineoverridevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 187 of file MagicSet.h.

                                       {
        return "NegativeLabellingTransformer";
    }

getNegativeLabel()

QualifiedName souffle::ast::transform::NegativeLabellingTransformer::getNegativeLabel ( const QualifiedName &  name )

staticprivate

Provide a unique name for negatively-labelled relations.

Definition at line 781 of file MagicSet.cpp.

                                                                                                    {
    std::stringstream label;
    label << "@poscopy_" << count;
    QualifiedName labelledName(name);
    labelledName.prepend(label.str());

References souffle::test::count(), and souffle::ast::QualifiedName::prepend().

Here is the call graph for this function:

transform()

bool souffle::ast::transform::NegativeLabellingTransformer::transform ( TranslationUnit &  translationUnit )

overrideprivatevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 801 of file MagicSet.cpp.

                                                      {
        auto* atom = neg.getAtom();
        auto relName = atom->getQualifiedName();
        if (contains(relationsToNotLabel, relName)) return;
        atom->setQualifiedName(getNegativeLabel(relName));
        relationsToLabel.insert(relName);
    });
    visitDepthFirst(program, [&](const Aggregator& aggr) {
        visitDepthFirst(aggr, [&](const Atom& atom) {
            auto relName = atom.getQualifiedName();
            if (contains(relationsToNotLabel, relName)) return;
            const_cast<Atom&>(atom).setQualifiedName(getNegativeLabel(relName));
            relationsToLabel.insert(relName);
        });
    });
 
    // Copy over the rules for labelled relations one stratum at a time
    for (size_t stratum = 0; stratum < sccGraph.getNumberOfSCCs(); stratum++) {
        // Check which relations to label in this stratum
        const auto& stratumRels = sccGraph.getInternalRelations(stratum);
        std::map<QualifiedName, QualifiedName> newSccFriendNames;
        for (const auto* rel : stratumRels) {
            auto relName = rel->getQualifiedName();
            if (contains(relationsToNotLabel, relName)) continue;
            relationsToLabel.insert(relName);
            newSccFriendNames[relName] = getNegativeLabel(relName);
        }
 
        // Negatively label the relations in a new copy of this stratum
        for (const auto* rel : stratumRels) {
            if (contains(relationsToNotLabel, rel->getQualifiedName())) continue;
            for (auto* clause : getClauses(program, rel->getQualifiedName())) {
                auto neggedClause = souffle::clone(clause);
                renameAtoms(*neggedClause, newSccFriendNames);
                clausesToAdd.insert(std::move(neggedClause));
            }
        }
    }
 
    // Add in all the relations that were labelled
    for (const auto& relName : relationsToLabel) {
        const auto* originalRel = getRelation(program, relName);
        assert(originalRel != nullptr && "unlabelled relation does not exist");
        auto labelledRelation = souffle::clone(originalRel);
        labelledRelation->setQualifiedName(getNegativeLabel(relName));
        program.addRelation(std::move(labelledRelation));
    }
 
    // Add in all the negged clauses
    for (const auto& clause : clausesToAdd) {
        program.addClause(souffle::clone(clause));
    }
 
    return !relationsToLabel.empty();
}
 
bool PositiveLabellingTransformer::transform(TranslationUnit& translationUnit) {
    Program& program = translationUnit.getProgram();
    const auto& sccGraph = *translationUnit.getAnalysis<analysis::SCCGraphAnalysis>();
    const auto& precedenceGraph = translationUnit.getAnalysis<analysis::PrecedenceGraphAnalysis>()->graph();
    const auto& relationsToNotLabel = getRelationsToNotLabel(translationUnit);

---

The documentation for this class was generated from the following files:

• ast/transform/MagicSet.h
• ast/transform/MagicSet.cpp