souffle::ram::analysis::LevelAnalysis Class Reference

A Ram Analysis for determining the level of a expression/condition. More...

#include <Level.h>

Inheritance diagram for souffle::ram::analysis::LevelAnalysis:

Collaboration diagram for souffle::ram::analysis::LevelAnalysis:

Public Member Functions
int	getLevel (const Node *value) const
	Get level of a RAM expression/condition. More...
	LevelAnalysis (const char *id)
void	run (const TranslationUnit &tUnit) override
	Run analysis for a RAM translation unit. More...
Public Member Functions inherited from souffle::ram::analysis::Analysis
	Analysis (const char *id)
virtual const std::string &	getName () const
	get name of the analysis More...
virtual void	print (std::ostream &) const
	Print the analysis result in HTML format. More...
virtual	~Analysis ()=default

Static Public Attributes
static constexpr const char *	name = "level-analysis"

Protected Attributes
RelationAnalysis *	ra {nullptr}
Protected Attributes inherited from souffle::ram::analysis::Analysis
std::string	identifier
	name of analysis instance More...

Detailed Description

A Ram Analysis for determining the level of a expression/condition.

The expression is determined by the TupleElement of an expression/condition with the highest tuple-id number. Note in the implementation we assume that the tuple-id of TupleOperation operations are ordered, i.e., the most-outer loop has the smallest tuple-id and the most inner-loop has the largest tuple-id number.

If an expression/condition does not contain an TupleElement accessing an element of a tuple, the analysis yields -1 for denoting that the expression/condition can be executed outside of the loop-nest, i.e., the expression/condition is independent of data stemming from relations.

Definition at line 51 of file Level.h.

Constructor & Destructor Documentation

LevelAnalysis()

souffle::ram::analysis::LevelAnalysis::LevelAnalysis ( const char *  id )

inline

Definition at line 53 of file Level.h.

:
    RelationAnalysis* ra{nullptr};

Member Function Documentation

getLevel()

int souffle::ram::analysis::LevelAnalysis::getLevel

(

const Node *

value

)

const

Get level of a RAM expression/condition.

Definition at line 64 of file Level.cpp.

                                            {
            return -1;
        }
 
        // false
        int visitFalse(const False&) override {
            return -1;
        }
 
        // tuple element access
        int visitTupleElement(const TupleElement& elem) override {
            return elem.getTupleId();
        }
 
        // scan
        int visitScan(const Scan&) override {
            return -1;
        }
 
        // index scan
        int visitIndexScan(const IndexScan& indexScan) override {
            int level = -1;
            for (auto& index : indexScan.getRangePattern().first) {
                level = std::max(level, visit(index));
            }
            for (auto& index : indexScan.getRangePattern().second) {
                level = std::max(level, visit(index));
            }
            return level;
        }
 
        // choice
        int visitChoice(const Choice& choice) override {
            return std::max(-1, visit(choice.getCondition()));
        }
 
        // index choice
        int visitIndexChoice(const IndexChoice& indexChoice) override {
            int level = -1;
            for (auto& index : indexChoice.getRangePattern().first) {
                level = std::max(level, visit(index));
            }
            for (auto& index : indexChoice.getRangePattern().second) {
                level = std::max(level, visit(index));
            }
            return std::max(level, visit(indexChoice.getCondition()));
        }
 
        // aggregate
        int visitAggregate(const Aggregate& aggregate) override {
            return std::max(visit(aggregate.getExpression()), visit(aggregate.getCondition()));
        }
 
        // index aggregate
        int visitIndexAggregate(const IndexAggregate& indexAggregate) override {
            int level = -1;
            for (auto& index : indexAggregate.getRangePattern().first) {
                level = std::max(level, visit(index));
            }
            for (auto& index : indexAggregate.getRangePattern().second) {
                level = std::max(level, visit(index));
            }
            level = std::max(visit(indexAggregate.getExpression()), level);
            return std::max(level, visit(indexAggregate.getCondition()));
        }
 
        // unpack record
        int visitUnpackRecord(const UnpackRecord& unpack) override {
            return visit(unpack.getExpression());
        }
 
        // filter
        int visitFilter(const Filter& filter) override {
            return visit(filter.getCondition());
        }
 
        // break
        int visitBreak(const Break& b) override {
            return visit(b.getCondition());
        }
 
        // project
        int visitProject(const Project& project) override {
            int level = -1;
            for (auto& exp : project.getValues()) {
                level = std::max(level, visit(exp));
            }
            return level;
        }
 
        // return
        int visitSubroutineReturn(const SubroutineReturn& ret) override {
            int level = -1;
            for (auto& exp : ret.getValues()) {
                level = std::max(level, visit(exp));
            }
            return level;
        }
 
        // auto increment
        int visitAutoIncrement(const AutoIncrement&) override {
            return -1;
        }
 
        // undef value
        int visitUndefValue(const UndefValue&) override {
            return -1;
        }
 
        // intrinsic functors
        int visitIntrinsicOperator(const IntrinsicOperator& op) override {
            int level = -1;
            for (const auto& arg : op.getArguments()) {
                level = std::max(level, visit(arg));
            }
            return level;
        }
 
        // pack operator
        int visitPackRecord(const PackRecord& pack) override {
            int level = -1;
            for (const auto& arg : pack.getArguments()) {
                level = std::max(level, visit(arg));
            }
            return level;
        }
 
        // argument
        int visitSubroutineArgument(const SubroutineArgument&) override {
            return -1;
        }
 
        // user defined operator
        int visitUserDefinedOperator(const UserDefinedOperator& op) override {
            int level = -1;
            for (const auto& arg : op.getArguments()) {
                level = std::max(level, visit(arg));
            }
            return level;
        }
 
        // conjunction
        int visitConjunction(const Conjunction& conj) override {
            return std::max(visit(conj.getLHS()), visit(conj.getRHS()));
        }
 
        // negation
        int visitNegation(const Negation& neg) override {
            return visit(neg.getOperand());
        }
 
        // constraint
        int visitConstraint(const Constraint& binRel) override {
            return std::max(visit(binRel.getLHS()), visit(binRel.getRHS()));
        }
 
        // existence check
        int visitExistenceCheck(const ExistenceCheck& exists) override {
            int level = -1;
            for (const auto& cur : exists.getValues()) {
                level = std::max(level, visit(cur));
            }
            return level;
        }
 
        // provenance existence check
        int visitProvenanceExistenceCheck(const ProvenanceExistenceCheck& provExists) override {
            int level = -1;
            for (const auto& cur : provExists.getValues()) {
                level = std::max(level, visit(cur));
            }
            return level;
        }
 
        // emptiness check
        int visitEmptinessCheck(const EmptinessCheck&) override {
            return -1;  // can be in the top level
        }
 
        // default rule
        int visitNode(const Node&) override {
            fatal("Node not implemented!");
        }
    };
 
    assert((isA<Expression>(node) || isA<Condition>(node) || isA<Operation>(node)) &&
            "not an expression/condition/operation");
    return ValueLevelVisitor().visit(node);
}
 
}  // namespace souffle::ram::analysis

Referenced by souffle::ram::transform::MakeIndexTransformer::getExpressionPair(), souffle::ram::transform::HoistAggregateTransformer::hoistAggregate(), souffle::ram::transform::ChoiceConversionTransformer::rewriteIndexScan(), and souffle::ram::transform::ChoiceConversionTransformer::rewriteScan().

run()

void souffle::ram::analysis::LevelAnalysis::run ( const TranslationUnit &  translationUnit )

inlineoverridevirtual

Run analysis for a RAM translation unit.

Implements souffle::ram::analysis::Analysis.

Definition at line 57 of file Level.h.

         :
    RelationAnalysis* ra{nullptr};

Field Documentation

name

constexpr const char* souffle::ram::analysis::LevelAnalysis::name = "level-analysis"

staticconstexpr

Definition at line 55 of file Level.h.

ra

RelationAnalysis* souffle::ram::analysis::LevelAnalysis::ra {nullptr}

protected

Definition at line 67 of file Level.h.

---

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

• ram/analysis/Level.h
• ram/analysis/Level.cpp