souffle::ram::transform::ParallelTransformer Class Reference

Transforms Choice/IndexChoice/IndexScan/Scan into parallel versions. More...

#include <Parallel.h>

Inheritance diagram for souffle::ram::transform::ParallelTransformer:

Collaboration diagram for souffle::ram::transform::ParallelTransformer:

Public Member Functions
std::string	getName () const override
	@Brief get name of the transformer More...
bool	parallelizeOperations (Program &program)
	Parallelize 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::RelationAnalysis *	relAnalysis {nullptr}

Detailed Description

Transforms Choice/IndexChoice/IndexScan/Scan into parallel versions.

For example ..

QUERY
  FOR t0 in A
   ...

will be rewritten to

QUERY
  PARALLEL FOR t0 in A
   ...

Definition at line 50 of file Parallel.h.

Member Function Documentation

getName()

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

inlineoverridevirtual

@Brief get name of the transformer

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

Definition at line 52 of file Parallel.h.

         :
    bool transform(TranslationUnit& translationUnit) override {

parallelizeOperations()

bool souffle::ram::transform::ParallelTransformer::parallelizeOperations

(

Program &

program

)

Parallelize operations.

Parameters

program

Program that is transformed

Returns

Flag showing whether the program has been changed by the transformation

Definition at line 36 of file Parallel.cpp.

                                                     {
        std::function<Own<Node>(Own<Node>)> parallelRewriter = [&](Own<Node> node) -> Own<Node> {
            if (const Scan* scan = dynamic_cast<Scan*>(node.get())) {
                const Relation& rel = relAnalysis->lookup(scan->getRelation());
                if (scan->getTupleId() == 0 && rel.getArity() > 0) {
                    if (!isA<Project>(&scan->getOperation())) {
                        changed = true;
                        return mk<ParallelScan>(scan->getRelation(), scan->getTupleId(),
                                souffle::clone(&scan->getOperation()), scan->getProfileText());
                    }
                }
            } else if (const Choice* choice = dynamic_cast<Choice*>(node.get())) {
                if (choice->getTupleId() == 0) {
                    changed = true;
                    return mk<ParallelChoice>(choice->getRelation(), choice->getTupleId(),
                            souffle::clone(&choice->getCondition()), souffle::clone(&choice->getOperation()),
                            choice->getProfileText());
                }
            } else if (const IndexScan* indexScan = dynamic_cast<IndexScan*>(node.get())) {
                if (indexScan->getTupleId() == 0) {
                    changed = true;
                    RamPattern queryPattern = clone(indexScan->getRangePattern());
                    return mk<ParallelIndexScan>(indexScan->getRelation(), indexScan->getTupleId(),
                            std::move(queryPattern), souffle::clone(&indexScan->getOperation()),
                            indexScan->getProfileText());
                }
            } else if (const IndexChoice* indexChoice = dynamic_cast<IndexChoice*>(node.get())) {
                if (indexChoice->getTupleId() == 0) {
                    changed = true;
                    RamPattern queryPattern = clone(indexChoice->getRangePattern());
                    return mk<ParallelIndexChoice>(indexChoice->getRelation(), indexChoice->getTupleId(),
                            souffle::clone(&indexChoice->getCondition()), std::move(queryPattern),
                            souffle::clone(&indexChoice->getOperation()), indexChoice->getProfileText());
                }
            } else if (const Aggregate* aggregate = dynamic_cast<Aggregate*>(node.get())) {
                const Relation& rel = relAnalysis->lookup(aggregate->getRelation());
                if (aggregate->getTupleId() == 0 && !rel.isNullary()) {
                    changed = true;
                    return mk<ParallelAggregate>(Own<Operation>(aggregate->getOperation().clone()),
                            aggregate->getFunction(), aggregate->getRelation(),
                            Own<Expression>(aggregate->getExpression().clone()),
                            Own<Condition>(aggregate->getCondition().clone()), aggregate->getTupleId());
                }
            } else if (const IndexAggregate* indexAggregate = dynamic_cast<IndexAggregate*>(node.get())) {
                const Relation& rel = relAnalysis->lookup(indexAggregate->getRelation());
                if (indexAggregate->getTupleId() == 0 && !rel.isNullary()) {
                    changed = true;
                    RamPattern queryPattern = clone(indexAggregate->getRangePattern());
                    return mk<ParallelIndexAggregate>(Own<Operation>(indexAggregate->getOperation().clone()),
                            indexAggregate->getFunction(), indexAggregate->getRelation(),
                            Own<Expression>(indexAggregate->getExpression().clone()),
                            Own<Condition>(indexAggregate->getCondition().clone()), std::move(queryPattern),
                            indexAggregate->getTupleId());
                }
            }
            node->apply(makeLambdaRamMapper(parallelRewriter));
            return node;
        };
        const_cast<Query*>(&query)->apply(makeLambdaRamMapper(parallelRewriter));
    });
    return changed;
}
 
}  // namespace souffle::ram::transform

References souffle::ram::transform::Transformer::apply(), souffle::clone(), souffle::ram::analysis::RelationAnalysis::lookup(), souffle::ram::makeLambdaRamMapper(), rel(), and relAnalysis.

Here is the call graph for this function:

transform()

bool souffle::ram::transform::ParallelTransformer::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 64 of file Parallel.h.

                                         {nullptr};
};
 
}  // namespace souffle::ram::transform

Field Documentation

relAnalysis

analysis::RelationAnalysis* souffle::ram::transform::ParallelTransformer::relAnalysis {nullptr}

protected

Definition at line 68 of file Parallel.h.

Referenced by parallelizeOperations().

---

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

• ram/transform/Parallel.h
• ram/transform/Parallel.cpp