souffle::ast::transform::MaterializeSingletonAggregationTransformer Class Reference

Replaces literals containing single-valued aggregates with a synthesised relation. More...

#include <MaterializeSingletonAggregation.h>

Inheritance diagram for souffle::ast::transform::MaterializeSingletonAggregationTransformer:

Collaboration diagram for souffle::ast::transform::MaterializeSingletonAggregationTransformer:

Public Member Functions
MaterializeSingletonAggregationTransformer *	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
void	groundInjectedParameters (const TranslationUnit &translationUnit, Clause &aggClause, const Clause &originalClause)
	Modify the aggClause by adding in grounding literals for every variable that appears in the clause ungrounded. More...
bool	transform (TranslationUnit &translationUnit) override

Static Private Member Functions
static bool	isSingleValued (const TranslationUnit &tu, const Aggregator &agg, const Clause &clause)
	Determines whether an aggregate is single-valued, ie the aggregate does not depend on the outer scope. More...

Detailed Description

Replaces literals containing single-valued aggregates with a synthesised relation.

Definition at line 40 of file MaterializeSingletonAggregation.h.

Member Function Documentation

clone()

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

inlineoverridevirtual

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

Definition at line 53 of file MaterializeSingletonAggregation.h.

getName()

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

inlineoverridevirtual

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

Definition at line 49 of file MaterializeSingletonAggregation.h.

groundInjectedParameters()

void souffle::ast::transform::MaterializeSingletonAggregationTransformer::groundInjectedParameters ( const TranslationUnit &  translationUnit, Clause &  aggClause, const Clause &  originalClause  )

private

Modify the aggClause by adding in grounding literals for every variable that appears in the clause ungrounded.

The source of literals to copy from is the originalClause.

isSingleValued()

bool souffle::ast::transform::MaterializeSingletonAggregationTransformer::isSingleValued ( const TranslationUnit &  tu, const Aggregator &  agg, const Clause &  clause  )

staticprivate

Determines whether an aggregate is single-valued, ie the aggregate does not depend on the outer scope.

Definition at line 141 of file MaterializeSingletonAggregation.cpp.

transform()

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

overrideprivatevirtual

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

Definition at line 49 of file MaterializeSingletonAggregation.cpp.

                                                        {
        visitDepthFirst(agg, [&](const Aggregator& innerAgg) {
            if (agg != innerAgg) {
                innerAggregates.insert(&innerAgg);
            }
        });
    });
 
    // collect references to clause / aggregate pairs
    visitDepthFirst(program, [&](const Clause& clause) {
        visitDepthFirst(clause, [&](const Aggregator& agg) {
            // only unroll one level at a time
            if (innerAggregates.find(&agg) != innerAggregates.end()) {
                return;
            }
            // if the aggregate isn't single valued
            // (ie it relies on a grounding from the outer scope)
            // or it's a constituent of the only atom in the clause,
            // then there's no point materialising it!
            if (!isSingleValued(translationUnit, agg, clause) || clause.getBodyLiterals().size() == 1) {
                return;
            }
            auto* foundAggregate = const_cast<Aggregator*>(&agg);
            auto* foundClause = const_cast<Clause*>(&clause);
            pairs.insert(std::make_pair(foundAggregate, foundClause));
        });
    });
    for (auto pair : pairs) {
        // Clone the aggregate that we're going to be deleting.
        auto aggregate = souffle::clone(pair.first);
        Clause* clause = pair.second;
        // synthesise an aggregate relation
        // __agg_rel_0()
        auto aggRel = mk<Relation>();
        auto aggHead = mk<Atom>();
        auto aggClause = mk<Clause>();
 
        std::string aggRelName = analysis::findUniqueRelationName(program, "__agg");
        aggRel->setQualifiedName(aggRelName);
        aggHead->setQualifiedName(aggRelName);
 
        // create a synthesised variable to replace the aggregate term!
        std::string variableName = analysis::findUniqueVariableName(*clause, "z");
        auto variable = mk<ast::Variable>(variableName);
 
        // __agg_rel_0(z) :- ...
        aggHead->addArgument(souffle::clone(variable));
        aggRel->addAttribute(mk<Attribute>(variableName, "number"));
        aggClause->setHead(souffle::clone(aggHead));
 
        //    A(x) :- x = sum .., B(x).
        // -> A(x) :- x = z, B(x), __agg_rel_0(z).
        auto equalityLiteral = mk<BinaryConstraint>(
                BinaryConstraintOp::EQ, souffle::clone(variable), souffle::clone(aggregate));
        // __agg_rel_0(z) :- z = sum ...
        aggClause->addToBody(std::move(equalityLiteral));
        program.addRelation(std::move(aggRel));
        program.addClause(std::move(aggClause));
 
        // the only thing left to do is just replace the aggregate terms in the original
        // clause with the synthesised variable
        struct replaceAggregate : public NodeMapper {
            const Aggregator& aggregate;
            const Own<ast::Variable> variable;
            replaceAggregate(const Aggregator& aggregate, Own<ast::Variable> variable)
                    : aggregate(aggregate), variable(std::move(variable)) {}
            Own<Node> operator()(Own<Node> node) const override {
                if (auto* current = dynamic_cast<Aggregator*>(node.get())) {
                    if (*current == aggregate) {
                        auto replacement = souffle::clone(variable);
                        assert(replacement != nullptr);
                        return replacement;
                    }
                }
                node->apply(*this);
                return node;
            }
        };
        replaceAggregate update(*aggregate, std::move(variable));
        clause->apply(update);
        clause->addToBody(std::move(aggHead));
    }
    return pairs.size() > 0;
}
 
bool MaterializeSingletonAggregationTransformer::isSingleValued(
        const TranslationUnit& tu, const Aggregator& agg, const Clause& clause) {
    // An aggregate is single valued as long as it is not complex.

References souffle::ast::visitDepthFirst().

Here is the call graph for this function:

---

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

• ast/transform/MaterializeSingletonAggregation.h
• ast/transform/MaterializeSingletonAggregation.cpp