Hosts conditions in a loop-nest to the most-outer/semantically-correct loop. More...

#include <HoistConditions.h>

Inheritance diagram for souffle::ram::transform::HoistConditionsTransformer:

Collaboration diagram for souffle::ram::transform::HoistConditionsTransformer:

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

bool	hoistConditions (Program &program)
	Hoist filter operations. 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

Hosts conditions in a loop-nest to the most-outer/semantically-correct loop.

Hoists the conditions to the earliest point in the loop nest where their evaluation is still semantically correct.

The transformations assumes that filter operations are stored verbose, i.e. a conjunction is expressed by two consecutive filter operations. For example ..

QUERY
 ...
  IF C1 /\ C2 then
   ...

should be rewritten / or produced by the translator as

QUERY
 ...
  IF C1
   IF C2
    ...

otherwise the levelling becomes imprecise, i.e., for both conditions the most outer-level is sought rather than considered separately.

If there are transformers prior to hoistConditions() that introduce conjunction, another transformer is required that splits the filter operations. However, at the moment this is not necessary because the translator delivers already the right RAM format.

TODO: break-up conditions while transforming so that this requirement is removed.

Definition at line 68 of file HoistConditions.h.

Member Function Documentation

◆ getName()

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

inlineoverridevirtual

@Brief get name of the transformer

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

Definition at line 70 of file HoistConditions.h.

83 :

84 analysis::LevelAnalysis* rla{nullptr};

◆ hoistConditions()

bool souffle::ram::transform::HoistConditionsTransformer::hoistConditions ( Program & program )

Hoist filter operations.

Parameters

program that is transformed

Returns: Flag showing whether the program has been changed by the transformation

There are two types of conditions in filter operations. The first type depends on tuples of TupleOperation operations. The second type are independent of tuple access. Both types of conditions will be hoisted to the most out-scope such that the program is still valid.

Definition at line 34 of file HoistConditions.cpp.

                                                                                          {
         if (condition == nullptr) {
             return c;
         } else {
             return mk<Conjunction>(std::move(condition), std::move(c));
         }
     };
  
     // hoist conditions to the most outer scope if they
     // don't depend on TupleOperations
     visitDepthFirst(program, [&](const Query& query) {
         Own<Condition> newCondition;
         std::function<Own<Node>(Own<Node>)> filterRewriter = [&](Own<Node> node) -> Own<Node> {
             if (auto* filter = dynamic_cast<Filter*>(node.get())) {
                 const Condition& condition = filter->getCondition();
                 // if filter condition is independent of any TupleOperation,
                 // delete the filter operation and collect condition
                 if (rla->getLevel(&condition) == -1) {
                     changed = true;
                     newCondition = addCondition(std::move(newCondition), souffle::clone(&condition));
                     node->apply(makeLambdaRamMapper(filterRewriter));
                     return souffle::clone(&filter->getOperation());
                 }
             }
             node->apply(makeLambdaRamMapper(filterRewriter));
             return node;
         };
         auto* mQuery = const_cast<Query*>(&query);
         mQuery->apply(makeLambdaRamMapper(filterRewriter));
         if (newCondition != nullptr) {
             // insert new filter operation at outer-most level of the query
             changed = true;
             auto* nestedOp = const_cast<Operation*>(&mQuery->getOperation());
             mQuery->rewrite(nestedOp, mk<Filter>(std::move(newCondition), souffle::clone(nestedOp)));
         }
     });
  
     // hoist conditions for each TupleOperation operation
     visitDepthFirst(program, [&](const TupleOperation& search) {
         Own<Condition> newCondition;
         std::function<Own<Node>(Own<Node>)> filterRewriter = [&](Own<Node> node) -> Own<Node> {
             if (auto* filter = dynamic_cast<Filter*>(node.get())) {
                 const Condition& condition = filter->getCondition();
                 // if filter condition matches level of TupleOperation,
                 // delete the filter operation and collect condition
                 if (rla->getLevel(&condition) == search.getTupleId()) {
                     changed = true;
                     newCondition = addCondition(std::move(newCondition), souffle::clone(&condition));
                     node->apply(makeLambdaRamMapper(filterRewriter));
                     return souffle::clone(&filter->getOperation());
                 }
             }
             node->apply(makeLambdaRamMapper(filterRewriter));
             return node;
         };
         auto* tupleOp = const_cast<TupleOperation*>(&search);
         tupleOp->apply(makeLambdaRamMapper(filterRewriter));
         if (newCondition != nullptr) {
             // insert new filter operation after the search operation
             changed = true;
             tupleOp->rewrite(&tupleOp->getOperation(),
                     mk<Filter>(std::move(newCondition), souffle::clone(&tupleOp->getOperation())));
         }
     });
     return changed;
 }
  
 }  // namespace souffle::ram::transform

◆ transform()

bool souffle::ram::transform::HoistConditionsTransformer::transform ( TranslationUnit & translationUnit )

inlineoverrideprotectedvirtual

@Brief transform the translation unit / used by apply @Param translationUnit that will be transformed.

@Return flag reporting whether the RAM program has changed

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

Definition at line 90 of file HoistConditions.h.

Field Documentation

◆ rla

analysis::LevelAnalysis* souffle::ram::transform::HoistConditionsTransformer::rla {nullptr}

protected

Definition at line 88 of file HoistConditions.h.

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

ram/transform/HoistConditions.h
ram/transform/HoistConditions.cpp

Public Member Functions

Protected Member Functions