souffle::ram::analysis::ComplexityAnalysis Class Reference

A Ram Analysis for determining the number of relational operations in a condition / expression. More...

#include <Complexity.h>

Inheritance diagram for souffle::ram::analysis::ComplexityAnalysis:

Collaboration diagram for souffle::ram::analysis::ComplexityAnalysis:

Public Member Functions
	ComplexityAnalysis (const char *id)
int	getComplexity (const Node *value) const
	Get complexity of a RAM expression/condition. More...
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 = "complexity-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 number of relational operations in a condition / expression.

Definition at line 41 of file Complexity.h.

Constructor & Destructor Documentation

ComplexityAnalysis()

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

inline

Definition at line 43 of file Complexity.h.

:
    RelationAnalysis* ra{nullptr};

Member Function Documentation

getComplexity()

int souffle::ram::analysis::ComplexityAnalysis::getComplexity

(

const Node *

value

)

const

Get complexity of a RAM expression/condition.

Definition at line 38 of file Complexity.cpp.

                                                               {
            return visit(conj.getLHS()) + visit(conj.getRHS());
        }
 
        // negation
        int visitNegation(const Negation& neg) override {
            return visit(neg.getOperand());
        }
 
        // existence check
        int visitExistenceCheck(const ExistenceCheck&) override {
            return 2;
        }
 
        // provenance existence check
        int visitProvenanceExistenceCheck(const ProvenanceExistenceCheck&) override {
            return 2;
        }
 
        // emptiness check
        int visitEmptinessCheck(const EmptinessCheck& emptiness) override {
            // emptiness check for nullary relations is for free; others have weight one
            return (ra->lookup(emptiness.getRelation()).getArity() > 0) ? 1 : 0;
        }
 
        // default rule
        int visitNode(const Node&) override {
            return 0;
        }
 
    protected:
        RelationAnalysis* ra{nullptr};
    };
 
    assert((isA<Expression>(node) || isA<Condition>(node)) && "not an expression/condition/operation");
    return ValueComplexityVisitor(ra).visit(node);
}
 
}  // namespace souffle::ram::analysis

References souffle::ram::Conjunction::getLHS(), and souffle::ram::Conjunction::getRHS().

Here is the call graph for this function:

run()

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

inlineoverridevirtual

Run analysis for a RAM translation unit.

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

Definition at line 47 of file Complexity.h.

         :
    RelationAnalysis* ra{nullptr};

Field Documentation

name

constexpr const char* souffle::ram::analysis::ComplexityAnalysis::name = "complexity-analysis"

staticconstexpr

Definition at line 45 of file Complexity.h.

ra

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

protected

Definition at line 57 of file Complexity.h.

---

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

• ram/analysis/Complexity.h
• ram/analysis/Complexity.cpp