#include <HoistAggregate.h>

Inheritance diagram for souffle::ram::transform::HoistAggregateTransformer:

Collaboration diagram for souffle::ram::transform::HoistAggregateTransformer:

Public Member Functions
std::string	getName () const override
	@Brief get name of the transformer More...

bool	hoistAggregate (Program &program)
	Apply hoistAggregate to the whole program. More...

Public Member Functions inherited from souffle::ram::transform::Transformer
bool	apply (TranslationUnit &translationUnit)
	@Brief apply the transformer to a translation unit @Param translationUnit that will be transformed. More...

virtual	~Transformer ()=default

Protected Member Functions
bool	transform (TranslationUnit &translationUnit) override
	@Brief transform the translation unit / used by apply @Param translationUnit that will be transformed. More...

Protected Attributes
analysis::LevelAnalysis *	rla {nullptr}

Detailed Description

Definition at line 38 of file HoistAggregate.h.

Member Function Documentation

◆ getName()

std::string souffle::ram::transform::HoistAggregateTransformer::getName ( ) const

inlineoverridevirtual

@Brief get name of the transformer

Implements souffle::ram::transform::Transformer.

Definition at line 40 of file HoistAggregate.h.

49 :

50 analysis::LevelAnalysis* rla{nullptr};

◆ hoistAggregate()

bool souffle::ram::transform::HoistAggregateTransformer::hoistAggregate ( Program & program )

Apply hoistAggregate to the whole program.

Parameters

RAM program

Returns: A flag indicating whether the RAM program has been changed.

Pushes an Aggregate up the loop nest if possible

Definition at line 34 of file HoistAggregate.cpp.

                                                      {
         Own<NestedOperation> newAgg;
         bool priorTupleOp = false;
         std::function<Own<Node>(Own<Node>)> aggRewriter = [&](Own<Node> node) -> Own<Node> {
             if (isA<Aggregate>(node.get())) {
                 auto* tupleOp = dynamic_cast<TupleOperation*>(node.get());
                 assert(tupleOp != nullptr && "aggregate conversion to tuple operation failed");
                 if (rla->getLevel(tupleOp) == -1 && !priorTupleOp) {
                     changed = true;
                     newAgg = souffle::clone(tupleOp);
                     assert(newAgg != nullptr && "failed to make a clone");
                     return souffle::clone(&tupleOp->getOperation());
                 }
             } else if (isA<TupleOperation>(node.get())) {
                 // tuple operation that is a non-aggregate
                 priorTupleOp = true;
             }
             node->apply(makeLambdaRamMapper(aggRewriter));
             return node;
         };
         const_cast<Query*>(&query)->apply(makeLambdaRamMapper(aggRewriter));
         if (newAgg != nullptr) {
             newAgg->rewrite(&newAgg->getOperation(), souffle::clone(&query.getOperation()));
             const_cast<Query*>(&query)->rewrite(&query.getOperation(), std::move(newAgg));
         }
     });
  
     // hoist a single aggregate to an outer scope that is data-dependent on a prior operation.
     visitDepthFirst(program, [&](const Query& query) {
         int newLevel = -1;
         Own<NestedOperation> newAgg;
         int priorOpLevel = -1;
  
         std::function<Own<Node>(Own<Node>)> aggRewriter = [&](Own<Node> node) -> Own<Node> {
             if (isA<AbstractAggregate>(node.get())) {
                 auto* tupleOp = dynamic_cast<TupleOperation*>(node.get());
                 assert(tupleOp != nullptr && "aggregate conversion to nested operation failed");
                 int dataDepLevel = rla->getLevel(tupleOp);
                 if (dataDepLevel != -1 && dataDepLevel < tupleOp->getTupleId() - 1) {
                     // If all tuple ops between the data-dependence level and agg
                     // are aggregates, then we do not hoist, i.e., we would
                     // continuously swap their positions.
                     if (dataDepLevel != priorOpLevel) {
                         changed = true;
                         newLevel = dataDepLevel;
                         newAgg = souffle::clone(tupleOp);
                         assert(newAgg != nullptr && "failed to make a clone");
                         return souffle::clone(&tupleOp->getOperation());
                     }
                 }
             } else if (const TupleOperation* tupleOp = dynamic_cast<TupleOperation*>(node.get())) {
                 priorOpLevel = tupleOp->getTupleId();
             }
             node->apply(makeLambdaRamMapper(aggRewriter));
             if (auto* search = dynamic_cast<TupleOperation*>(node.get())) {
                 if (newAgg != nullptr && search->getTupleId() == newLevel) {
                     newAgg->rewrite(&newAgg->getOperation(), souffle::clone(&search->getOperation()));
                     search->rewrite(&search->getOperation(), std::move(newAgg));
                 }
             }
             return node;
         };
         const_cast<Query*>(&query)->apply(makeLambdaRamMapper(aggRewriter));
     });
     return changed;
 }  // namespace souffle
  
 }  // namespace souffle::ram::transform