souffle::ast::transform::ReorderLiteralsTransformer Class Reference

Transformation pass to reorder body literals. More...

#include <ReorderLiterals.h>

Inheritance diagram for souffle::ast::transform::ReorderLiteralsTransformer:

Collaboration diagram for souffle::ast::transform::ReorderLiteralsTransformer:

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

Static Public Member Functions
static Clause *	reorderClauseWithSips (const SipsMetric &sips, const Clause *clause)
	Reorder the clause based on a given SIPS function. More...

Private Member Functions
bool	transform (TranslationUnit &translationUnit) override

Detailed Description

Transformation pass to reorder body literals.

Definition at line 34 of file ReorderLiterals.h.

Member Function Documentation

clone()

ReorderLiteralsTransformer* souffle::ast::transform::ReorderLiteralsTransformer::clone ( ) const

inlineoverridevirtual

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

Definition at line 40 of file ReorderLiterals.h.

                                                       {
        return new ReorderLiteralsTransformer();
    }

getName()

std::string souffle::ast::transform::ReorderLiteralsTransformer::getName ( ) const

inlineoverridevirtual

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

Definition at line 36 of file ReorderLiterals.h.

                                       {
        return "ReorderLiteralsTransformer";
    }

reorderClauseWithSips()

Clause * souffle::ast::transform::ReorderLiteralsTransformer::reorderClauseWithSips ( const SipsMetric &  sips, const Clause *  clause  )

static

Reorder the clause based on a given SIPS function.

Parameters

sipsFunction	SIPS metric to use
clause	clause to reorder

Returns

nullptr if no change, otherwise a new reordered clause

Definition at line 46 of file ReorderLiterals.cpp.

                                                          {
        if (newOrdering[i] != i) {
            changeNeeded = true;
        }
    }
 
    // reorder if needed
    return changeNeeded ? reorderAtoms(clause, newOrdering) : nullptr;
}
 
bool ReorderLiteralsTransformer::transform(TranslationUnit& translationUnit) {
    bool changed = false;
    Program& program = translationUnit.getProgram();
 
    // --- SIPS-based static reordering ---
    // ordering is based on the given SIPS

References i.

transform()

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

overrideprivatevirtual

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

Definition at line 67 of file ReorderLiterals.cpp.

                                    {
        sipsChosen = Global::config().get("SIPS");
    }
    auto sipsFunction = SipsMetric::create(sipsChosen, translationUnit);
 
    // literal reordering is a rule-local transformation
    std::vector<Clause*> clausesToRemove;
 
    for (Clause* clause : program.getClauses()) {
        Clause* newClause = reorderClauseWithSips(*sipsFunction, clause);
        if (newClause != nullptr) {
            // reordering needed - swap around
            clausesToRemove.push_back(clause);
            program.addClause(Own<Clause>(newClause));
        }
    }
 
    changed |= !clausesToRemove.empty();
    for (auto* clause : clausesToRemove) {
        program.removeClause(clause);
    }
 
    // --- profile-guided reordering ---
    if (Global::config().has("profile-use")) {
        // parse supplied profile information
        auto profilerSips = SipsMetric::create("profiler", translationUnit);
 
        // change the ordering of literals within clauses
        std::vector<Clause*> clausesToRemove;
        for (Clause* clause : program.getClauses()) {
            Clause* newClause = reorderClauseWithSips(*profilerSips, clause);
            if (newClause != nullptr) {
                // reordering needed - swap around
                clausesToRemove.push_back(clause);
                program.addClause(Own<Clause>(newClause));
            }
        }
 
        changed |= !clausesToRemove.empty();
        for (auto* clause : clausesToRemove) {
            program.removeClause(clause);
        }
    }
 
    return changed;
}
 
}  // namespace souffle::ast::transform

References souffle::Global::config().

Here is the call graph for this function:

---

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

• ast/transform/ReorderLiterals.h
• ast/transform/ReorderLiterals.cpp