souffle::ast::transform::RemoveRedundantSumsTransformer Class Reference

Transformation pass to remove expressions of the form sum k : { ... More...

#include <RemoveRedundantSums.h>

Inheritance diagram for souffle::ast::transform::RemoveRedundantSumsTransformer:

Collaboration diagram for souffle::ast::transform::RemoveRedundantSumsTransformer:

Public Member Functions
RemoveRedundantSumsTransformer *	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

Detailed Description

Transformation pass to remove expressions of the form sum k : { ...

} and replace them with k * count : { ... } where k is a constant.

Definition at line 33 of file RemoveRedundantSums.h.

Member Function Documentation

clone()

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

inlineoverridevirtual

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

Definition at line 43 of file RemoveRedundantSums.h.

getName()

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

inlineoverridevirtual

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

Definition at line 39 of file RemoveRedundantSums.h.

       :
    bool transform(TranslationUnit& translationUnit) override;
};

transform()

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

overrideprivatevirtual

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

Definition at line 38 of file RemoveRedundantSums.cpp.

                                                            {
            // Apply to all aggregates of the form
            // sum k : { .. } where k is a constant
            if (auto* agg = dynamic_cast<Aggregator*>(node.get())) {
                if (agg->getBaseOperator() == AggregateOp::SUM) {
                    if (const auto* constant =
                                    dynamic_cast<const NumericConstant*>(agg->getTargetExpression())) {
                        changed = true;
                        // Then construct the new thing to replace it with
                        auto count = mk<Aggregator>(AggregateOp::COUNT);
                        // Duplicate the body of the aggregate
                        VecOwn<Literal> newBody;
                        for (const auto& lit : agg->getBodyLiterals()) {
                            newBody.push_back(souffle::clone(lit));
                        }
                        count->setBody(std::move(newBody));
                        auto number = souffle::clone(constant);
                        // Now it's constant * count : { ... }
                        auto result = mk<IntrinsicFunctor>("*", std::move(number), std::move(count));
 
                        return result;
                    }
                }
            }
            node->apply(*this);
            return node;
        }
 
        // variables
        mutable bool changed = false;
    };
 
    ReplaceSumWithCount update;
    Program& program = translationUnit.getProgram();
    program.apply(update);
    return update.changed;
}
 
}  // namespace souffle::ast::transform

References souffle::clone(), souffle::test::count(), souffle::COUNT, and souffle::SUM.

Here is the call graph for this function:

---

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

• ast/transform/RemoveRedundantSums.h
• ast/transform/RemoveRedundantSums.cpp