From c3336129d97a4faf7abcdfca6e3763df103bcc81 Mon Sep 17 00:00:00 2001 From: Abdul Zreika Date: Fri, 16 Oct 2020 15:00:52 +1100 Subject: [PATCH] Changed translateRelation to getConcreteRelationName. --- src/ast2ram/AstToRamTranslator.cpp | 42 +++++++++++++++--------------- src/ast2ram/AstToRamTranslator.h | 8 +++--- src/ast2ram/ClauseTranslator.cpp | 28 +++++++++++--------- 3 files changed, 40 insertions(+), 38 deletions(-) diff --git a/src/ast2ram/AstToRamTranslator.cpp b/src/ast2ram/AstToRamTranslator.cpp index 79df42143ba..818bdf9e90d 100644 --- a/src/ast2ram/AstToRamTranslator.cpp +++ b/src/ast2ram/AstToRamTranslator.cpp @@ -201,21 +201,21 @@ std::vector> AstToRamTranslator::getOutputDir return outputDirectives; } -std::string AstToRamTranslator::translateRelation(const ast::Atom* atom) { +std::string AstToRamTranslator::getConcreteRelationName(const ast::Atom* atom) { return getRelationName(atom->getQualifiedName()); } -std::string AstToRamTranslator::translateRelation( +std::string AstToRamTranslator::getConcreteRelationName( const ast::Relation* rel, const std::string relationNamePrefix) { return relationNamePrefix + getRelationName(rel->getQualifiedName()); } std::string AstToRamTranslator::translateDeltaRelation(const ast::Relation* rel) { - return translateRelation(rel, "@delta_"); + return getConcreteRelationName(rel, "@delta_"); } std::string AstToRamTranslator::translateNewRelation(const ast::Relation* rel) { - return translateRelation(rel, "@new_"); + return getConcreteRelationName(rel, "@new_"); } Own AstToRamTranslator::translateValue(const ast::Argument* arg, const ValueIndex& index) { @@ -360,8 +360,8 @@ Own AstToRamTranslator::translateConstraint( values.push_back(translator.translateValue(args[arity + height], index)); } } - return mk( - mk(translator.translateRelation(atom), std::move(values))); + return mk(mk( + translator.getConcreteRelationName(atom), std::move(values))); } /** for negations */ @@ -373,7 +373,7 @@ Own AstToRamTranslator::translateConstraint( if (arity == 0) { // for a nullary, negation is a simple emptiness check - return mk(translator.translateRelation(atom)); + return mk(translator.getConcreteRelationName(atom)); } // else, we construct the atom and create a negation @@ -386,7 +386,7 @@ Own AstToRamTranslator::translateConstraint( values.push_back(mk()); } return mk( - mk(translator.translateRelation(atom), std::move(values))); + mk(translator.getConcreteRelationName(atom), std::move(values))); } }; return ConstraintTranslator(*this, index)(*lit); @@ -431,7 +431,7 @@ Own AstToRamTranslator::translateNonRecursiveRelation( /* start with an empty sequence */ VecOwn res; - std::string relName = translateRelation(&rel); + std::string relName = getConcreteRelationName(&rel); /* iterate over all clauses that belong to the relation */ for (ast::Clause* clause : relDetail->getClauses(rel.getQualifiedName())) { @@ -559,7 +559,7 @@ Own AstToRamTranslator::translateRecursiveRelation(const std::se for (const ast::Relation* rel : scc) { /* create update statements for fixpoint (even iteration) */ Own updateRelTable = - mk(genMerge(rel, translateRelation(rel), translateNewRelation(rel)), + mk(genMerge(rel, getConcreteRelationName(rel), translateNewRelation(rel)), mk(translateDeltaRelation(rel), translateNewRelation(rel)), mk(translateNewRelation(rel))); @@ -577,7 +577,7 @@ Own AstToRamTranslator::translateRecursiveRelation(const std::se /* Generate code for non-recursive part of relation */ /* Generate merge operation for temp tables */ appendStmt(preamble, translateNonRecursiveRelation(*rel, recursiveClauses)); - appendStmt(preamble, genMerge(rel, translateDeltaRelation(rel), translateRelation(rel))); + appendStmt(preamble, genMerge(rel, translateDeltaRelation(rel), getConcreteRelationName(rel))); /* Add update operations of relations to parallel statements */ appendStmt(updateTable, std::move(updateRelTable)); @@ -711,9 +711,9 @@ Own AstToRamTranslator::translateRecursiveRelation(const std::se for (const ast::Relation* rel : scc) { addCondition(exitCond, mk(translateNewRelation(rel))); if (ioType->isLimitSize(rel)) { - Own limit = - mk(BinaryConstraintOp::GE, mk(translateRelation(rel)), - mk(ioType->getLimitSize(rel))); + Own limit = mk(BinaryConstraintOp::GE, + mk(getConcreteRelationName(rel)), + mk(ioType->getLimitSize(rel))); appendStmt(exitStmts, mk(std::move(limit))); } } @@ -900,7 +900,7 @@ Own AstToRamTranslator::makeNegationSubproofSubroutine(const ast if (auto atom = dynamic_cast(lit)) { size_t auxiliaryArity = auxArityAnalysis->getArity(atom); - auto relName = translateRelation(atom); + auto relName = getConcreteRelationName(atom); // construct a query VecOwn query; @@ -944,7 +944,7 @@ Own AstToRamTranslator::makeNegationSubproofSubroutine(const ast auto atom = neg->getAtom(); size_t auxiliaryArity = auxArityAnalysis->getArity(atom); - auto relName = translateRelation(atom); + auto relName = getConcreteRelationName(atom); // construct a query VecOwn query; @@ -1040,12 +1040,12 @@ void AstToRamTranslator::translateProgram(const ast::TranslationUnit& translatio // a function to load relations const auto& makeRamLoad = [&](VecOwn& current, const ast::Relation* relation) { for (auto directives : getInputDirectives(relation)) { - Own statement = mk(translateRelation(relation), directives); + Own statement = mk(getConcreteRelationName(relation), directives); if (Global::config().has("profile")) { const std::string logTimerStatement = LogStatement::tRelationLoadTime( toString(relation->getQualifiedName()), relation->getSrcLoc()); statement = mk( - std::move(statement), logTimerStatement, translateRelation(relation)); + std::move(statement), logTimerStatement, getConcreteRelationName(relation)); } appendStmt(current, std::move(statement)); } @@ -1054,12 +1054,12 @@ void AstToRamTranslator::translateProgram(const ast::TranslationUnit& translatio // a function to store relations const auto& makeRamStore = [&](VecOwn& current, const ast::Relation* relation) { for (auto directives : getOutputDirectives(relation)) { - Own statement = mk(translateRelation(relation), directives); + Own statement = mk(getConcreteRelationName(relation), directives); if (Global::config().has("profile")) { const std::string logTimerStatement = LogStatement::tRelationSaveTime( toString(relation->getQualifiedName()), relation->getSrcLoc()); statement = mk( - std::move(statement), logTimerStatement, translateRelation(relation)); + std::move(statement), logTimerStatement, getConcreteRelationName(relation)); } appendStmt(current, std::move(statement)); } @@ -1067,7 +1067,7 @@ void AstToRamTranslator::translateProgram(const ast::TranslationUnit& translatio // a function to drop relations const auto& makeRamClear = [&](VecOwn& current, const ast::Relation* relation) { - appendStmt(current, mk(translateRelation(relation))); + appendStmt(current, mk(getConcreteRelationName(relation))); }; // create all Ram relations in ramRels diff --git a/src/ast2ram/AstToRamTranslator.h b/src/ast2ram/AstToRamTranslator.h index 8eb1ebc06de..0c593222ac3 100644 --- a/src/ast2ram/AstToRamTranslator.h +++ b/src/ast2ram/AstToRamTranslator.h @@ -91,11 +91,11 @@ class AstToRamTranslator { /** translate an AST argument to a RAM value */ Own translateValue(const ast::Argument* arg, const ValueIndex& index); - /** a utility to translate atoms to relations */ - std::string translateRelation(const ast::Atom* atom); + /** Get the corresponding concretised RAM relation name for the atom */ + std::string getConcreteRelationName(const ast::Atom* atom); - /** translate an AST relation to a RAM relation */ - std::string translateRelation(const ast::Relation* rel, const std::string relationNamePrefix = ""); + /** Get the corresponding concretised RAM relation name for the relation */ + std::string getConcreteRelationName(const ast::Relation* rel, const std::string relationNamePrefix = ""); /** determine the auxiliary for relations */ size_t getEvaluationArity(const ast::Atom* atom) const; diff --git a/src/ast2ram/ClauseTranslator.cpp b/src/ast2ram/ClauseTranslator.cpp index d16444d6d67..3bc9c7b291c 100644 --- a/src/ast2ram/ClauseTranslator.cpp +++ b/src/ast2ram/ClauseTranslator.cpp @@ -70,7 +70,7 @@ Own ClauseTranslator::translateClause( } // create a fact statement - return mk(mk(translator.translateRelation(head), std::move(values))); + return mk(mk(translator.getConcreteRelationName(head), std::move(values))); } // the rest should be rules @@ -186,8 +186,8 @@ Own ClauseTranslator::translateClause( auto expr = translator.translateValue(agg->getTargetExpression(), *valueIndex); // add Ram-Aggregation layer - op = mk(std::move(op), agg->getOperator(), translator.translateRelation(atom), - expr ? std::move(expr) : mk(), + op = mk(std::move(op), agg->getOperator(), + translator.getConcreteRelationName(atom), expr ? std::move(expr) : mk(), aggCond ? std::move(aggCond) : mk(), level); } else if (const auto* func = dynamic_cast(cur)) { VecOwn args; @@ -235,14 +235,14 @@ Own ClauseTranslator::translateClause( // add check for emptiness for an atom op = mk( - mk(mk(translator.translateRelation(atom))), + mk(mk(translator.getConcreteRelationName(atom))), std::move(op)); // add a scan level if (atom->getArity() != 0 && !isAllArgsUnnamed) { if (head->getArity() == 0) { - op = mk( - mk(mk(translator.translateRelation(head))), + op = mk(mk(mk( + translator.getConcreteRelationName(head))), std::move(op)); } if (Global::config().has("profile")) { @@ -256,9 +256,10 @@ Own ClauseTranslator::translateClause( ss << stringify(toString(*atom)) << ';'; ss << stringify(toString(originalClause)) << ';'; ss << level << ';'; - op = mk(translator.translateRelation(atom), level, std::move(op), ss.str()); + op = mk( + translator.getConcreteRelationName(atom), level, std::move(op), ss.str()); } else { - op = mk(translator.translateRelation(atom), level, std::move(op)); + op = mk(translator.getConcreteRelationName(atom), level, std::move(op)); } } @@ -293,11 +294,12 @@ Own ClauseTranslator::createOperation(const ast::Clause& clause) values.push_back(translator.translateValue(arg, *valueIndex)); } - Own project = mk(translator.translateRelation(head), std::move(values)); + Own project = + mk(translator.getConcreteRelationName(head), std::move(values)); if (head->getArity() == 0) { project = mk( - mk(translator.translateRelation(head)), std::move(project)); + mk(translator.getConcreteRelationName(head)), std::move(project)); } // build up insertion call @@ -310,7 +312,7 @@ Own ClauseTranslator::createCondition(const ast::Clause& origina // add stopping criteria for nullary relations // (if it contains already the null tuple, don't re-compute) if (head->getArity() == 0) { - return mk(translator.translateRelation(head)); + return mk(translator.getConcreteRelationName(head)); } return nullptr; } @@ -425,7 +427,7 @@ void ClauseTranslator::createValueIndex(const ast::Clause& clause) { // index each value in the atom indexValues(atom, atom->getArguments(), nodeLevel, - translator.lookupRelation(translator.translateRelation(atom))); + translator.lookupRelation(translator.getConcreteRelationName(atom))); } // add aggregation functions @@ -460,7 +462,7 @@ void ClauseTranslator::createValueIndex(const ast::Clause& clause) { for (auto* arg : atom->getArguments()) { if (const auto* var = dynamic_cast(arg)) { valueIndex->addVarReference( - *var, *aggLoc, (int)pos, translator.translateRelation(atom)); + *var, *aggLoc, (int)pos, translator.getConcreteRelationName(atom)); } ++pos; }