souffle::synthesiser::EqrelRelation Class Reference

#include <Relation.h>

Inheritance diagram for souffle::synthesiser::EqrelRelation:

Collaboration diagram for souffle::synthesiser::EqrelRelation:

Public Member Functions
void	computeIndices () override
	Generate index set for a eqrel relation. More...
	EqrelRelation (const ram::Relation &ramRel, const MinIndexSelection &indexSet, bool isProvenance)
void	generateTypeStruct (std::ostream &out) override
	Generate type struct of a eqrel relation. More...
std::string	getTypeName () override
	Generate type name of a eqrel relation. More...
Public Member Functions inherited from souffle::ram::Relation
Relation *	clone () const override
	Create a clone (i.e. More...
unsigned	getArity () const
	Get arity of relation. More...
const std::vector< std::string > &	getAttributeNames () const
	Get attribute names. More...
const std::vector< std::string > &	getAttributeTypes () const
	Get attribute types. More...
unsigned	getAuxiliaryArity () const
	Get number of auxiliary attributes. More...
const std::string &	getName () const
	Get name. More...
RelationRepresentation	getRepresentation () const
	Relation representation type. More...
bool	isNullary () const
	Is nullary relation. More...
bool	isTemp () const
	Is temporary relation (for semi-naive evaluation) More...
bool	operator< (const Relation &other) const
	Compare two relations via their name. More...
	Relation (std::string name, size_t arity, size_t auxiliaryArity, std::vector< std::string > attributeNames, std::vector< std::string > attributeTypes, RelationRepresentation representation)
Public Member Functions inherited from souffle::ram::Node
virtual void	apply (const NodeMapper &)
	Apply the mapper to all child nodes. More...
virtual std::vector< const Node * >	getChildNodes () const
	Obtain list of all embedded child nodes. More...
bool	operator!= (const Node &other) const
	Inequality check for two RAM nodes. More...
bool	operator== (const Node &other) const
	Equivalence check for two RAM nodes. More...
virtual void	rewrite (const Node *oldNode, Own< Node > newNode)
	Rewrite a child node. More...
virtual	~Node ()=default

Additional Inherited Members
Protected Member Functions inherited from souffle::ram::Relation
bool	equal (const Node &node) const override
	Equality check for two RAM nodes. More...
void	print (std::ostream &out) const override
	Print RAM node. More...
Protected Attributes inherited from souffle::ram::Relation
const size_t	arity
	Arity, i.e., number of attributes. More...
const std::vector< std::string >	attributeNames
	Name of attributes. More...
const std::vector< std::string >	attributeTypes
	Type of attributes. More...
const size_t	auxiliaryArity
	Number of auxiliary attributes (e.g. More...
const std::string	name
	Name of relation. More...
const RelationRepresentation	representation
	Data-structure representation. More...

Detailed Description

Definition at line 154 of file Relation.h.

Constructor & Destructor Documentation

EqrelRelation()

souffle::synthesiser::EqrelRelation::EqrelRelation ( const ram::Relation &  ramRel, const MinIndexSelection &  indexSet, bool  isProvenance  )

inline

Definition at line 156 of file Relation.h.

            : Relation(ramRel, indexSet, isProvenance) {}

Member Function Documentation

computeIndices()

void souffle::synthesiser::EqrelRelation::computeIndices ( )

override

Generate index set for a eqrel relation.

Definition at line 1143 of file Relation.cpp.

                                   {
    assert(!isProvenance && "eqrel cannot be used with provenance");
 
    masterIndex = 0;
    // {1, 0} is equivalent for an eqrel
    computedIndices = {{0, 1}};
}

generateTypeStruct()

void souffle::synthesiser::EqrelRelation::generateTypeStruct ( std::ostream &  out )

override

Generate type struct of a eqrel relation.

Definition at line 1157 of file Relation.cpp.

                                                      {
    constexpr souffle::Relation::arity_type arity = 2;
    const auto& inds = getIndices();
    size_t numIndexes = inds.size();
    std::map<MinIndexSelection::LexOrder, int> indexToNumMap;
 
    // struct definition
    out << "struct " << getTypeName() << " {\n";
    out << "static constexpr Relation::arity_type Arity = " << arity << ";\n";
 
    // eqrel is only for binary relations
    out << "using t_tuple = Tuple<RamDomain, " << arity << ">;\n";
    out << "using t_ind_" << masterIndex << " = EquivalenceRelation<t_tuple>;\n";
    out << "t_ind_" << masterIndex << " ind_" << masterIndex << ";\n";
 
    // generate auxiliary iterators that reorder tuples according to index orders
    // generate auxiliary iterators which orderOut
    out << "class iterator_0 : public std::iterator<std::forward_iterator_tag, t_tuple> {\n";
    out << "    using nested_iterator = typename t_ind_0::iterator;\n";
    out << "    nested_iterator nested;\n";
    out << "    t_tuple value;\n";
 
    out << "public:\n";
    out << "    iterator_0() = default;\n";
    out << "    iterator_0(const nested_iterator& iter) : nested(iter), value(orderOut_0(*iter)) {}\n";
    out << "    iterator_0(const iterator_0& other) = default;\n";
    out << "    iterator_0& operator=(const iterator_0& other) = default;\n";
 
    out << "    bool operator==(const iterator_0& other) const {\n";
    out << "        return nested == other.nested;\n";
    out << "    }\n";
 
    out << "    bool operator!=(const iterator_0& other) const {\n";
    out << "        return !(*this == other);\n";
    out << "    }\n";
 
    out << "    const t_tuple& operator*() const {\n";
    out << "        return value;\n";
    out << "    }\n";
 
    out << "    const t_tuple* operator->() const {\n";
    out << "        return &value;\n";
    out << "    }\n";
 
    out << "    iterator_0& operator++() {\n";
    out << "        ++nested;\n";
    out << "        value = orderOut_0(*nested);\n";
    out << "        return *this;\n";
    out << "    }\n";
    out << "};\n";
 
    out << "using iterator = iterator_" << masterIndex << ";\n";
 
    // Create a struct storing the context hints for each index
    out << "struct context {\n";
    out << "t_ind_" << masterIndex << "::operation_hints hints_" << masterIndex << ";\n";
    out << "};\n";
    out << "context createContext() { return context(); }\n";
 
    // insert methods
    out << "bool insert(const t_tuple& t) {\n";
    out << "return ind_" << masterIndex << ".insert(t[0], t[1]);\n";
    out << "}\n";
 
    out << "bool insert(const t_tuple& t, context& h) {\n";
    out << "return ind_" << masterIndex << ".insert(t[0], t[1], h.hints_" << masterIndex << ");\n";
    out << "}\n";
 
    out << "bool insert(const RamDomain* ramDomain) {\n";
    out << "RamDomain data[2];\n";
    out << "std::copy(ramDomain, ramDomain + 2, data);\n";
    out << "const t_tuple& tuple = reinterpret_cast<const t_tuple&>(data);\n";
    out << "context h;\n";
    out << "return insert(tuple, h);\n";
    out << "}\n";
 
    out << "bool insert(RamDomain a1, RamDomain a2) {\n";
    out << "RamDomain data[2] = {a1, a2};\n";
    out << "return insert(data);\n";
    out << "}\n";
 
    // extends method for eqrel
    // performs a delta extension, where we union the sets that share elements between this and other.
    //      i.e. if a in this, and a in other, union(set(this->a), set(other->a))
    out << "void extend(const " << getTypeName() << "& other) {\n";
    out << "ind_" << masterIndex << ".extend(other.ind_" << masterIndex << ");\n";
    out << "}\n";
 
    // contains methods
    out << "bool contains(const t_tuple& t) const {\n";
    out << "return ind_" << masterIndex << ".contains(t[0], t[1]);\n";
    out << "}\n";
 
    out << "bool contains(const t_tuple& t, context& h) const {\n";
    out << "return ind_" << masterIndex << ".contains(t[0], t[1]);\n";
    out << "}\n";
 
    // size method
    out << "std::size_t size() const {\n";
    out << "return ind_" << masterIndex << ".size();\n";
    out << "}\n";
 
    // find methods
    out << "iterator find(const t_tuple& t) const {\n";
    out << "return ind_" << masterIndex << ".find(orderIn_" << masterIndex << "(t));\n";
    out << "}\n";
 
    out << "iterator find(const t_tuple& t, context& h) const {\n";
    out << "return ind_" << masterIndex << ".find(orderIn_" << masterIndex << "(t));\n";
    out << "}\n";
 
    // lowerUpperRange methods, one for each of the 4 possible search patterns
    for (int i = 1; i < 4; i++) {
        SearchSignature s(arity);
        // if the bit is set then set it in the search signature
        for (size_t j = 0; j < arity; j++) {
            if (i & (1 << j)) {
                s[j] = analysis::AttributeConstraint::Equal;
            }
        }
 
        out << "range<iterator> lowerUpperRange_" << s;
        out << "(const t_tuple& lower, const t_tuple& upper, context& h) const {\n";
        // compute size of sub-index
        size_t indSize = 0;
        for (size_t column = 0; column < 2; column++) {
            if (((i >> column) & 1) != 0) {
                indSize++;
            }
        }
        out << "auto r = ind_" << masterIndex << ".template getBoundaries<" << indSize << ">(orderIn_"
            << masterIndex << "(lower), h.hints_" << masterIndex << ");\n";
        out << "return make_range(iterator(r.begin()), iterator(r.end()));\n";
        out << "}\n";
 
        out << "range<iterator> lowerUpperRange_" << s;
        out << "(const t_tuple& lower, const t_tuple& upper) const {\n";
        out << "context h; return lowerUpperRange_" << s << "(lower, upper, h);\n";
        out << "}\n";
    }
 
    // empty method
    out << "bool empty() const {\n";
    out << "return ind_" << masterIndex << ".size() == 0;\n";
    out << "}\n";
 
    // partition method
    out << "std::vector<range<iterator>> partition() const {\n";
    out << "std::vector<range<iterator>> res;\n";
    out << "for (const auto& cur : ind_" << masterIndex << ".partition(10000)) {\n";
    out << "    res.push_back(make_range(iterator(cur.begin()), iterator(cur.end())));\n";
    out << "}\n";
    out << "return res;\n";
    out << "}\n";
 
    // purge method
    out << "void purge() {\n";
    for (size_t i = 0; i < numIndexes; i++) {
        out << "ind_" << i << ".clear();\n";
    }
    out << "}\n";
 
    // begin and end iterators
    out << "iterator begin() const {\n";
    out << "return iterator_" << masterIndex << "(ind_" << masterIndex << ".begin());\n";
    out << "}\n";
 
    out << "iterator end() const {\n";
    out << "return iterator_" << masterIndex << "(ind_" << masterIndex << ".end());\n";
    out << "}\n";
 
    // printStatistics method
    out << "void printStatistics(std::ostream& o) const {\n";
    out << "o << \" eqrel index: no hint statistics supported\\n\";\n";
    out << "}\n";
 
    // generate orderIn and orderOut methods which reorder tuples
    // according to index orders
    for (size_t i = 0; i < numIndexes; i++) {
        auto ind = inds[i];
        out << "static t_tuple orderIn_" << i << "(const t_tuple& t) {\n";
        out << "t_tuple res;\n";
        for (size_t j = 0; j < ind.size(); j++) {
            out << "res[" << j << "] = t[" << ind[j] << "];\n";
        }
        out << "return res;\n";
        out << "}\n";
 
        out << "static t_tuple orderOut_" << i << "(const t_tuple& t) {\n";
        out << "t_tuple res;\n";
        for (size_t j = 0; j < ind.size(); j++) {
            out << "res[" << ind[j] << "] = t[" << j << "];\n";
        }
        out << "return res;\n";
        out << "}\n";
    }
 
    // end class
    out << "};\n";
}

References i, and j.

getTypeName()

std::string souffle::synthesiser::EqrelRelation::getTypeName ( )

override

Generate type name of a eqrel relation.

Definition at line 1152 of file Relation.cpp.

                                     {
    return "t_eqrel";
}

---

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

• synthesiser/Relation.h
• synthesiser/Relation.cpp