From 73a48194fb09d7df98c3cab1dfa47ea30a71ac1f Mon Sep 17 00:00:00 2001 From: Giacomo Serafini Date: Thu, 16 Apr 2020 10:52:41 +0200 Subject: [PATCH 1/5] First implementation and tests --- dawn/src/dawn/Optimizer/CMakeLists.txt | 2 + .../dawn/Optimizer/PassSimplifyStatements.cpp | 69 +++ .../dawn/Optimizer/PassSimplifyStatements.h | 33 ++ .../unit-test/dawn/Optimizer/CMakeLists.txt | 1 + .../Optimizer/TestPassSimplifyStatements.cpp | 77 +++ ...simplify_statements_compound_statement.iir | 397 +++++++++++++++ ...implify_statements_increment_decrement.iir | 464 ++++++++++++++++++ ...simplify_statements_compound_statement.cpp | 32 ++ ...implify_statements_increment_decrement.cpp | 35 ++ 9 files changed, 1110 insertions(+) create mode 100644 dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp create mode 100644 dawn/src/dawn/Optimizer/PassSimplifyStatements.h create mode 100644 dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp create mode 100644 dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_compound_statement.iir create mode 100644 dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_decrement.iir create mode 100644 dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_compound_statement.cpp create mode 100644 dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp diff --git a/dawn/src/dawn/Optimizer/CMakeLists.txt b/dawn/src/dawn/Optimizer/CMakeLists.txt index 48e520084..49f7005c2 100644 --- a/dawn/src/dawn/Optimizer/CMakeLists.txt +++ b/dawn/src/dawn/Optimizer/CMakeLists.txt @@ -59,6 +59,8 @@ add_library(DawnOptimizer PassSetStageName.h PassSetSyncStage.cpp PassSetSyncStage.h + PassSimplifyStatements.h + PassSimplifyStatements.cpp PassStageSplitAllStatements.cpp PassStageSplitAllStatements.h PassSSA.cpp diff --git a/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp b/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp new file mode 100644 index 000000000..1ab4b9e42 --- /dev/null +++ b/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp @@ -0,0 +1,69 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ +// | | +// __| | __ ___ ___ ___ +// / _` |/ _` \ \ /\ / / '_ | +// | (_| | (_| |\ V V /| | | | +// \__,_|\__,_| \_/\_/ |_| |_| - Compiler Toolchain +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +#include "PassSimplifyStatements.h" +#include "dawn/AST/ASTExpr.h" +#include "dawn/IIR/ASTFwd.h" +#include "dawn/IIR/DoMethod.h" +#include "dawn/IIR/StencilInstantiation.h" +#include "dawn/Support/Type.h" +#include + +namespace dawn { + +bool PassSimplifyStatements::run( + const std::shared_ptr& stencilInstantiation) { + for(const auto& doMethod : iterateIIROver(*stencilInstantiation->getIIR())) { + for(auto stmtIt = doMethod->getAST().getStatements().begin(); + stmtIt != doMethod->getAST().getStatements().end(); ++stmtIt) { + if(const auto& exprStmt = std::dynamic_pointer_cast(*stmtIt)) { + auto sourceLoc = exprStmt->getSourceLocation(); + if(const auto& assignmentExpr = + std::dynamic_pointer_cast(exprStmt->getExpr())) { + if(assignmentExpr->getOp() != "=") { // Compound assignment + auto binOp = std::make_shared( + assignmentExpr->getLeft()->clone(), assignmentExpr->getOp().substr(0, 1), + assignmentExpr->getRight(), sourceLoc); + auto newAssignmentExpr = std::make_shared( + assignmentExpr->getLeft(), binOp, "=", sourceLoc); + exprStmt->getExpr() = newAssignmentExpr; + } + // TODO: rewrite: unary op can be nested inside an expression + } else if(const auto& unaryOp = std::dynamic_pointer_cast( + exprStmt->getExpr())) { // Increment / decrement ops + if(unaryOp->getOp() == "++") { + auto binOp = std::make_shared( + unaryOp->getOperand()->clone(), "+", + std::make_shared("1", BuiltinTypeID::Integer, sourceLoc), + sourceLoc); + auto newAssignmentExpr = + std::make_shared(unaryOp->getOperand(), binOp, "=", sourceLoc); + exprStmt->getExpr() = newAssignmentExpr; + } else if(unaryOp->getOp() == "--") { + auto binOp = std::make_shared( + unaryOp->getOperand()->clone(), "-", + std::make_shared("1", BuiltinTypeID::Integer, sourceLoc), + sourceLoc); + auto newAssignmentExpr = + std::make_shared(unaryOp->getOperand(), binOp, "=", sourceLoc); + exprStmt->getExpr() = newAssignmentExpr; + } + } + } + } + } + return true; +} + +} // namespace dawn diff --git a/dawn/src/dawn/Optimizer/PassSimplifyStatements.h b/dawn/src/dawn/Optimizer/PassSimplifyStatements.h new file mode 100644 index 000000000..b00be88f4 --- /dev/null +++ b/dawn/src/dawn/Optimizer/PassSimplifyStatements.h @@ -0,0 +1,33 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ +// | | +// __| | __ ___ ___ ___ +// / _` |/ _` \ \ /\ / / '_ | +// | (_| | (_| |\ V V /| | | | +// \__,_|\__,_| \_/\_/ |_| |_| - Compiler Toolchain +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +#pragma once + +#include "Pass.h" + +namespace dawn { + +/// @brief PassSimplifyStatements... +/// @ingroup optimizer +/// +/// This pass is necessary to generate legal IIR +class PassSimplifyStatements : public Pass { +public: + PassSimplifyStatements(OptimizerContext& context) : Pass(context, "PassSimplifyStatements") {} + + /// @brief Pass implementation + bool run(const std::shared_ptr& stencilInstantiation) override; +}; + +} // namespace dawn diff --git a/dawn/test/unit-test/dawn/Optimizer/CMakeLists.txt b/dawn/test/unit-test/dawn/Optimizer/CMakeLists.txt index 38e707dd0..f50701325 100644 --- a/dawn/test/unit-test/dawn/Optimizer/CMakeLists.txt +++ b/dawn/test/unit-test/dawn/Optimizer/CMakeLists.txt @@ -25,6 +25,7 @@ add_executable(${executable} TestPassSetCaches.cpp TestPassSetNonTempCaches.cpp TestPassSetStageLocationType.cpp + TestPassSimplifyStatements.cpp TestPassStageMerger.cpp TestPassStageSplitAllStatements.cpp TestPassStageReordering.cpp diff --git a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp new file mode 100644 index 000000000..dcc693eb7 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp @@ -0,0 +1,77 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ +// | | +// __| | __ ___ ___ ___ +// / _` |/ _` \ \ /\ / / '_ | +// | (_| | (_| |\ V V /| | | | +// \__,_|\__,_| \_/\_/ |_| |_| - Compiler Toolchain +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +#include "dawn/AST/ASTStringifier.h" +#include "dawn/Compiler/DawnCompiler.h" +#include "dawn/Compiler/Options.h" +#include "dawn/IIR/ASTFwd.h" +#include "dawn/IIR/IIR.h" +#include "dawn/IIR/StencilInstantiation.h" +#include "dawn/Optimizer/PassSimplifyStatements.h" +#include "dawn/Serialization/IIRSerializer.h" +#include "dawn/Unittest/ASTConstructionAliases.h" +#include "dawn/Unittest/CompilerUtil.h" +#include "dawn/Unittest/UnittestUtils.h" +#include "test/unit-test/dawn/Optimizer/TestEnvironment.h" + +#include +#include +#include + +using namespace dawn; +using namespace astgen; + +namespace { +// TODO remove compilerutil +class TestPassSimplifyStatements : public ::testing::Test { +protected: + dawn::OptimizerContext::OptimizerContextOptions options_; + std::unique_ptr context_; + std::shared_ptr instantiation_; + + void runPass(const std::string& filename) { + dawn::UIDGenerator::getInstance()->reset(); + instantiation_ = CompilerUtil::load(filename, options_, context_, TestEnvironment::path_); + + ASSERT_TRUE(CompilerUtil::runPass(context_, instantiation_)); + } +}; + +TEST_F(TestPassSimplifyStatements, CompoundStatement) { + // b += a; + // d -= c; + runPass("input/test_simplify_statements_compound_statement.iir"); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 0); + ASSERT_TRUE(firstStmt->equals(expr(assign(field("b"), binop(field("b"), "+", field("a")))).get(), + /*compareData = */ false)); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 1); + ASSERT_TRUE(secondStmt->equals(expr(assign(field("d"), binop(field("d"), "-", field("c")))).get(), + /*compareData = */ false)); +} + +TEST_F(TestPassSimplifyStatements, IncrementDecrement) { + // int b = 0; + // int c = 0; + // --b; + // ++c; + runPass("input/test_simplify_statements_increment_decrement.iir"); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); + ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "-", lit(1)))).get(), + /*compareData = */ false)); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 3); + ASSERT_TRUE(secondStmt->equals(expr(assign(var("c"), binop(var("c"), "+", lit(1)))).get(), + /*compareData = */ false)); +} + +} // namespace diff --git a/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_compound_statement.iir b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_compound_statement.iir new file mode 100644 index 000000000..fbb816f90 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_compound_statement.iir @@ -0,0 +1,397 @@ +{ + "metadata": { + "accessIDToName": { + "15": "c", + "16": "d", + "13": "a", + "14": "b" + }, + "accessIDToType": { + "13": 6, + "14": 6, + "15": 6, + "16": 6 + }, + "literalIDToName": {}, + "fieldAccessIDs": [ + 13, + 14, + 15, + 16 + ], + "APIFieldIDs": [ + 13, + 14, + 15, + 16 + ], + "temporaryFieldIDs": [], + "globalVariableIDs": [], + "versionedFields": { + "variableVersionMap": {} + }, + "fieldnameToBoundaryCondition": {}, + "fieldIDtoDimensions": { + "15": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + }, + "16": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + }, + "13": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + }, + "14": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + } + }, + "idToStencilCall": { + "17": { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_17", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 18 + } + } + }, + "boundaryCallToExtent": {}, + "allocatedFieldIDs": [], + "stencilLocation": { + "Line": 21, + "Column": 8 + }, + "stencilName": "stencil" + }, + "internalIR": { + "gridType": "Cartesian", + "globalVariableToValue": {}, + "stencils": [ + { + "multiStages": [ + { + "stages": [ + { + "doMethods": [ + { + "ast": { + "block_stmt": { + "statements": [ + { + "expr_stmt": { + "expr": { + "assignment_expr": { + "left": { + "field_access_expr": { + "name": "b", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 26, + "Column": 7 + }, + "data": { + "accessID": 14 + }, + "ID": 57 + } + }, + "op": "+=", + "right": { + "field_access_expr": { + "name": "a", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 26, + "Column": 12 + }, + "data": { + "accessID": 13 + }, + "ID": 56 + } + }, + "loc": { + "Line": 26, + "Column": 7 + }, + "ID": 58 + } + }, + "loc": { + "Line": 26, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "14": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "13": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "14": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 55 + } + }, + { + "expr_stmt": { + "expr": { + "assignment_expr": { + "left": { + "field_access_expr": { + "name": "d", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 27, + "Column": 7 + }, + "data": { + "accessID": 16 + }, + "ID": 61 + } + }, + "op": "-=", + "right": { + "field_access_expr": { + "name": "c", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 27, + "Column": 12 + }, + "data": { + "accessID": 15 + }, + "ID": 60 + } + }, + "loc": { + "Line": 27, + "Column": 7 + }, + "ID": 62 + } + }, + "loc": { + "Line": 27, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "16": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "15": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "16": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 59 + } + } + ], + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 54 + } + }, + "doMethodID": 0, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + } + ], + "stageID": 31, + "locationType": "LocationTypeUnknown" + } + ], + "loopOrder": "Parallel", + "multiStageID": 33, + "Caches": { + "14": { + "type": "CT_K", + "policy": "CP_FillFlush", + "accessID": 14, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + }, + "enclosingAccessInterval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + }, + "16": { + "type": "CT_K", + "policy": "CP_FillFlush", + "accessID": 16, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + }, + "enclosingAccessInterval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + } + } + } + ], + "stencilID": 17, + "attr": { + "attributes": [] + } + } + ], + "controlFlowStatements": [ + { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_17", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 18 + } + } + ], + "boundaryConditions": [] + }, + "filename": "samples/test_simplify_statements_compound_statement.cpp" +} diff --git a/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_decrement.iir b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_decrement.iir new file mode 100644 index 000000000..e60448a72 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_decrement.iir @@ -0,0 +1,464 @@ +{ + "metadata": { + "accessIDToName": { + "21": "a", + "46": "b", + "48": "c" + }, + "accessIDToType": { + "21": 6 + }, + "literalIDToName": { + "-49": "0", + "-47": "0" + }, + "fieldAccessIDs": [ + 21 + ], + "APIFieldIDs": [ + 21 + ], + "temporaryFieldIDs": [], + "globalVariableIDs": [], + "versionedFields": { + "variableVersionMap": {} + }, + "fieldnameToBoundaryCondition": {}, + "fieldIDtoDimensions": { + "21": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + } + }, + "idToStencilCall": { + "22": { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_22", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 23 + } + } + }, + "boundaryCallToExtent": {}, + "allocatedFieldIDs": [], + "stencilLocation": { + "Line": 21, + "Column": 8 + }, + "stencilName": "stencil" + }, + "internalIR": { + "gridType": "Cartesian", + "globalVariableToValue": {}, + "stencils": [ + { + "multiStages": [ + { + "stages": [ + { + "doMethods": [ + { + "ast": { + "block_stmt": { + "statements": [ + { + "var_decl_stmt": { + "type": { + "builtin_type": { + "type_id": "Integer" + }, + "is_const": false, + "is_volatile": false + }, + "name": "b", + "dimension": 0, + "op": "=", + "init_list": [ + { + "literal_access_expr": { + "value": "0", + "type": { + "type_id": "Integer" + }, + "loc": { + "Line": 26, + "Column": 15 + }, + "data": { + "accessID": -47 + }, + "ID": 53 + } + } + ], + "loc": { + "Line": 26, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "46": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "-47": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "var_decl_stmt_data": { + "accessID": 46 + }, + "ID": 52 + } + }, + { + "var_decl_stmt": { + "type": { + "builtin_type": { + "type_id": "Integer" + }, + "is_const": false, + "is_volatile": false + }, + "name": "c", + "dimension": 0, + "op": "=", + "init_list": [ + { + "literal_access_expr": { + "value": "0", + "type": { + "type_id": "Integer" + }, + "loc": { + "Line": 27, + "Column": 15 + }, + "data": { + "accessID": -49 + }, + "ID": 55 + } + } + ], + "loc": { + "Line": 27, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "48": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "-49": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "var_decl_stmt_data": { + "accessID": 48 + }, + "ID": 54 + } + }, + { + "expr_stmt": { + "expr": { + "unary_operator": { + "op": "--", + "operand": { + "var_access_expr": { + "name": "b", + "is_external": false, + "loc": { + "Line": 28, + "Column": 9 + }, + "data": { + "accessID": 46 + }, + "ID": 58 + } + }, + "loc": { + "Line": 28, + "Column": 7 + }, + "ID": 57 + } + }, + "loc": { + "Line": 28, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": {}, + "readAccess": { + "46": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 56 + } + }, + { + "expr_stmt": { + "expr": { + "unary_operator": { + "op": "++", + "operand": { + "var_access_expr": { + "name": "c", + "is_external": false, + "loc": { + "Line": 29, + "Column": 9 + }, + "data": { + "accessID": 48 + }, + "ID": 61 + } + }, + "loc": { + "Line": 29, + "Column": 7 + }, + "ID": 60 + } + }, + "loc": { + "Line": 29, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": {}, + "readAccess": { + "48": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 59 + } + }, + { + "expr_stmt": { + "expr": { + "assignment_expr": { + "left": { + "field_access_expr": { + "name": "a", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 30, + "Column": 7 + }, + "data": { + "accessID": 21 + }, + "ID": 66 + } + }, + "op": "=", + "right": { + "binary_operator": { + "left": { + "var_access_expr": { + "name": "c", + "is_external": false, + "loc": { + "Line": 30, + "Column": 11 + }, + "data": { + "accessID": 48 + }, + "ID": 64 + } + }, + "op": "+", + "right": { + "var_access_expr": { + "name": "b", + "is_external": false, + "loc": { + "Line": 30, + "Column": 15 + }, + "data": { + "accessID": 46 + }, + "ID": 65 + } + }, + "loc": { + "Line": 30, + "Column": 11 + }, + "ID": 63 + } + }, + "loc": { + "Line": 30, + "Column": 7 + }, + "ID": 67 + } + }, + "loc": { + "Line": 30, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "21": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "48": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "46": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 62 + } + } + ], + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 51 + } + }, + "doMethodID": 0, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + } + ], + "stageID": 44, + "locationType": "LocationTypeUnknown" + } + ], + "loopOrder": "Parallel", + "multiStageID": 50, + "Caches": {} + } + ], + "stencilID": 22, + "attr": { + "attributes": [] + } + } + ], + "controlFlowStatements": [ + { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_22", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 23 + } + } + ], + "boundaryConditions": [] + }, + "filename": "samples/test_simplify_statements_increment_decrement.cpp" +} diff --git a/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_compound_statement.cpp b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_compound_statement.cpp new file mode 100644 index 000000000..4272aa280 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_compound_statement.cpp @@ -0,0 +1,32 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ _ +// | | | | +// __ _| |_ ___| | __ _ _ __ __ _ +// / _` | __/ __| |/ _` | '_ \ / _` | +// | (_| | || (__| | (_| | | | | (_| | +// \__, |\__\___|_|\__,_|_| |_|\__, | - GridTools Clang DSL +// __/ | __/ | +// |___/ |___/ +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +// gtclang test_simplify_statements_compound_statement.cpp -fno-codegen -fwrite-iir + +#include "gtclang_dsl_defs/gtclang_dsl.hpp" + +using namespace gtclang::dsl; + +stencil stencil { + storage a, b, c, d; + + Do { + vertical_region(k_start, k_end) { + b += a; + d -= c; + } + } +}; diff --git a/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp new file mode 100644 index 000000000..1c32a8c09 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp @@ -0,0 +1,35 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ _ +// | | | | +// __ _| |_ ___| | __ _ _ __ __ _ +// / _` | __/ __| |/ _` | '_ \ / _` | +// | (_| | || (__| | (_| | | | | (_| | +// \__, |\__\___|_|\__,_|_| |_|\__, | - GridTools Clang DSL +// __/ | __/ | +// |___/ |___/ +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +// gtclang test_simplify_statements_increment_decrement.cpp -fno-codegen -fwrite-iir -fkeep-varnames + +#include "gtclang_dsl_defs/gtclang_dsl.hpp" + +using namespace gtclang::dsl; + +stencil stencil { + storage a; + + Do { + vertical_region(k_start, k_end) { + int b = 0; + int c = 0; + --b; + ++c; + a = c + b; + } + } +}; From 12c400c9ae580d97f4abbb364c6236a5eac86d1b Mon Sep 17 00:00:00 2001 From: Giacomo Serafini Date: Fri, 17 Apr 2020 09:20:07 +0200 Subject: [PATCH 2/5] Consider nested increments/decrements + more tests --- .../dawn/Optimizer/PassSimplifyStatements.cpp | 77 ++- .../Optimizer/TestPassSimplifyStatements.cpp | 50 +- ...t_simplify_statements_increment_nested.iir | 339 ++++++++++ ...implify_statements_mix_multiple_nested.iir | 617 ++++++++++++++++++ ...implify_statements_increment_decrement.cpp | 6 +- ...t_simplify_statements_increment_nested.cpp | 32 + ...implify_statements_mix_multiple_nested.cpp | 34 + 7 files changed, 1128 insertions(+), 27 deletions(-) create mode 100644 dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_nested.iir create mode 100644 dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_mix_multiple_nested.iir create mode 100644 dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_nested.cpp create mode 100644 dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_mix_multiple_nested.cpp diff --git a/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp b/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp index 1ab4b9e42..b801148ab 100644 --- a/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp +++ b/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp @@ -22,16 +22,52 @@ namespace dawn { +namespace { +class IncrementDecrementReplacer : public ast::ASTVisitorPostOrder { + std::vector> statements_; + +public: + std::shared_ptr + postVisitNode(std::shared_ptr const& unaryOp) override { + auto sourceLoc = unaryOp->getSourceLocation(); + std::shared_ptr binOp; + if(unaryOp->getOp() == "++") { + binOp = std::make_shared( + unaryOp->getOperand()->clone(), "+", + std::make_shared("1", BuiltinTypeID::Integer, sourceLoc), + sourceLoc); + } else if(unaryOp->getOp() == "--") { + binOp = std::make_shared( + unaryOp->getOperand()->clone(), "-", + std::make_shared("1", BuiltinTypeID::Integer, sourceLoc), + sourceLoc); + } else { + return unaryOp; + } + DAWN_ASSERT(unaryOp->getOperand()->getKind() == ast::Expr::Kind::FieldAccessExpr || + unaryOp->getOperand()->getKind() == ast::Expr::Kind::VarAccessExpr); + auto newAssignmentExpr = std::make_shared(unaryOp->getOperand()->clone(), + binOp, "=", sourceLoc); + + statements_.push_back(iir::makeExprStmt(newAssignmentExpr, sourceLoc)); + + return unaryOp->getOperand(); + } + const std::vector>& getReplacements() { return statements_; } +}; +} // namespace + bool PassSimplifyStatements::run( const std::shared_ptr& stencilInstantiation) { for(const auto& doMethod : iterateIIROver(*stencilInstantiation->getIIR())) { for(auto stmtIt = doMethod->getAST().getStatements().begin(); - stmtIt != doMethod->getAST().getStatements().end(); ++stmtIt) { + stmtIt != doMethod->getAST().getStatements().end();) { + // Compound assignment if(const auto& exprStmt = std::dynamic_pointer_cast(*stmtIt)) { auto sourceLoc = exprStmt->getSourceLocation(); if(const auto& assignmentExpr = std::dynamic_pointer_cast(exprStmt->getExpr())) { - if(assignmentExpr->getOp() != "=") { // Compound assignment + if(assignmentExpr->getOp() != "=") { auto binOp = std::make_shared( assignmentExpr->getLeft()->clone(), assignmentExpr->getOp().substr(0, 1), assignmentExpr->getRight(), sourceLoc); @@ -39,28 +75,25 @@ bool PassSimplifyStatements::run( assignmentExpr->getLeft(), binOp, "=", sourceLoc); exprStmt->getExpr() = newAssignmentExpr; } - // TODO: rewrite: unary op can be nested inside an expression - } else if(const auto& unaryOp = std::dynamic_pointer_cast( - exprStmt->getExpr())) { // Increment / decrement ops - if(unaryOp->getOp() == "++") { - auto binOp = std::make_shared( - unaryOp->getOperand()->clone(), "+", - std::make_shared("1", BuiltinTypeID::Integer, sourceLoc), - sourceLoc); - auto newAssignmentExpr = - std::make_shared(unaryOp->getOperand(), binOp, "=", sourceLoc); - exprStmt->getExpr() = newAssignmentExpr; - } else if(unaryOp->getOp() == "--") { - auto binOp = std::make_shared( - unaryOp->getOperand()->clone(), "-", - std::make_shared("1", BuiltinTypeID::Integer, sourceLoc), - sourceLoc); - auto newAssignmentExpr = - std::make_shared(unaryOp->getOperand(), binOp, "=", sourceLoc); - exprStmt->getExpr() = newAssignmentExpr; - } } } + + // Increment/decrement ops (can be nested inside expression tree) + IncrementDecrementReplacer replacer; + doMethod->getAST().substitute(stmtIt, (*stmtIt)->acceptAndReplace(replacer)); + stmtIt = doMethod->getAST().insert(stmtIt, replacer.getReplacements().begin(), + replacer.getReplacements().end()); + std::advance(stmtIt, replacer.getReplacements().size()); + // Substitution might have left an useless statement accessing a field/variable. + if(const auto& exprStmt = std::dynamic_pointer_cast(*stmtIt)) { + if(exprStmt->getExpr()->getKind() == ast::Expr::Kind::FieldAccessExpr || + exprStmt->getExpr()->getKind() == ast::Expr::Kind::VarAccessExpr) { + stmtIt = doMethod->getAST().erase(stmtIt); + continue; + } + } + + ++stmtIt; } } return true; diff --git a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp index dcc693eb7..5976fa75a 100644 --- a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp +++ b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp @@ -61,11 +61,13 @@ TEST_F(TestPassSimplifyStatements, CompoundStatement) { } TEST_F(TestPassSimplifyStatements, IncrementDecrement) { - // int b = 0; - // int c = 0; + // int b = d; + // int c = d; // --b; // ++c; + // a = c + b; runPass("input/test_simplify_statements_increment_decrement.iir"); + ASSERT_EQ(5, getFirstDoMethod(instantiation_).getAST().getStatements().size()); auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "-", lit(1)))).get(), /*compareData = */ false)); @@ -74,4 +76,48 @@ TEST_F(TestPassSimplifyStatements, IncrementDecrement) { /*compareData = */ false)); } +TEST_F(TestPassSimplifyStatements, IncrementNested) { + // int b = c; + // a = (++b) + 1; + runPass("input/test_simplify_statements_increment_nested.iir"); + ASSERT_EQ(3, getFirstDoMethod(instantiation_).getAST().getStatements().size()); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 1); + ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "+", lit(1)))).get(), + /*compareData = */ false)); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); + ASSERT_TRUE(secondStmt->equals(expr(assign(field("a"), binop(var("b"), "+", lit(1)))).get(), + /*compareData = */ false)); +} + +TEST_F(TestPassSimplifyStatements, MixMultipleNested) { + // int b = d; + // int c = d; + // a += ++b + (1 + --c); + // a *= ++c * --b; + runPass("input/test_simplify_statements_mix_multiple_nested.iir"); + ASSERT_EQ(8, getFirstDoMethod(instantiation_).getAST().getStatements().size()); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); + ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "+", lit(1)))).get(), + /*compareData = */ false)); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 3); + ASSERT_TRUE(secondStmt->equals(expr(assign(var("c"), binop(var("c"), "-", lit(1)))).get(), + /*compareData = */ false)); + auto const& thirdStmt = getNthStmt(getFirstDoMethod(instantiation_), 4); + ASSERT_TRUE(thirdStmt->equals( + expr(assign(field("a"), + binop(field("a"), "+", binop(var("b"), "+", binop(lit(1), "+", var("c")))))) + .get(), + /*compareData = */ false)); + auto const& fourthStmt = getNthStmt(getFirstDoMethod(instantiation_), 5); + ASSERT_TRUE(fourthStmt->equals(expr(assign(var("c"), binop(var("c"), "+", lit(1)))).get(), + /*compareData = */ false)); + auto const& fifthStmt = getNthStmt(getFirstDoMethod(instantiation_), 6); + ASSERT_TRUE(fifthStmt->equals(expr(assign(var("b"), binop(var("b"), "-", lit(1)))).get(), + /*compareData = */ false)); + auto const& sixthStmt = getNthStmt(getFirstDoMethod(instantiation_), 7); + ASSERT_TRUE(sixthStmt->equals( + expr(assign(field("a"), binop(field("a"), "*", binop(var("c"), "*", var("b"))))).get(), + /*compareData = */ false)); +} + } // namespace diff --git a/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_nested.iir b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_nested.iir new file mode 100644 index 000000000..ad8acb18c --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_increment_nested.iir @@ -0,0 +1,339 @@ +{ + "metadata": { + "accessIDToName": { + "14": "a", + "15": "c", + "33": "b" + }, + "accessIDToType": { + "15": 6, + "14": 6 + }, + "literalIDToName": { + "-34": "1" + }, + "fieldAccessIDs": [ + 14, + 15 + ], + "APIFieldIDs": [ + 14, + 15 + ], + "temporaryFieldIDs": [], + "globalVariableIDs": [], + "versionedFields": { + "variableVersionMap": {} + }, + "fieldnameToBoundaryCondition": {}, + "fieldIDtoDimensions": { + "14": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + }, + "15": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + } + }, + "idToStencilCall": { + "16": { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_16", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 17 + } + } + }, + "boundaryCallToExtent": {}, + "allocatedFieldIDs": [], + "stencilLocation": { + "Line": 23, + "Column": 8 + }, + "stencilName": "stencil" + }, + "internalIR": { + "gridType": "Cartesian", + "globalVariableToValue": {}, + "stencils": [ + { + "multiStages": [ + { + "stages": [ + { + "doMethods": [ + { + "ast": { + "block_stmt": { + "statements": [ + { + "var_decl_stmt": { + "type": { + "builtin_type": { + "type_id": "Integer" + }, + "is_const": false, + "is_volatile": false + }, + "name": "b", + "dimension": 0, + "op": "=", + "init_list": [ + { + "field_access_expr": { + "name": "c", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 28, + "Column": 15 + }, + "data": { + "accessID": 15 + }, + "ID": 38 + } + } + ], + "loc": { + "Line": 28, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "33": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "15": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "var_decl_stmt_data": { + "accessID": 33 + }, + "ID": 37 + } + }, + { + "expr_stmt": { + "expr": { + "assignment_expr": { + "left": { + "field_access_expr": { + "name": "a", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 29, + "Column": 7 + }, + "data": { + "accessID": 14 + }, + "ID": 44 + } + }, + "op": "=", + "right": { + "binary_operator": { + "left": { + "unary_operator": { + "op": "++", + "operand": { + "var_access_expr": { + "name": "b", + "is_external": false, + "loc": { + "Line": 29, + "Column": 14 + }, + "data": { + "accessID": 33 + }, + "ID": 42 + } + }, + "loc": { + "Line": 29, + "Column": 12 + }, + "ID": 41 + } + }, + "op": "+", + "right": { + "literal_access_expr": { + "value": "1", + "type": { + "type_id": "Integer" + }, + "loc": { + "Line": 29, + "Column": 19 + }, + "data": { + "accessID": -34 + }, + "ID": 43 + } + }, + "loc": { + "Line": 29, + "Column": 11 + }, + "ID": 40 + } + }, + "loc": { + "Line": 29, + "Column": 7 + }, + "ID": 45 + } + }, + "loc": { + "Line": 29, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "14": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "33": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "-34": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 39 + } + } + ], + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 36 + } + }, + "doMethodID": 0, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + } + ], + "stageID": 31, + "locationType": "LocationTypeUnknown" + } + ], + "loopOrder": "Parallel", + "multiStageID": 35, + "Caches": {} + } + ], + "stencilID": 16, + "attr": { + "attributes": [] + } + } + ], + "controlFlowStatements": [ + { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_16", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 17 + } + } + ], + "boundaryConditions": [] + }, + "filename": "samples/test_simplify_statements_increment_nested.cpp" +} diff --git a/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_mix_multiple_nested.iir b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_mix_multiple_nested.iir new file mode 100644 index 000000000..519398eb4 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/input/test_simplify_statements_mix_multiple_nested.iir @@ -0,0 +1,617 @@ +{ + "metadata": { + "accessIDToName": { + "28": "d", + "60": "c", + "27": "a", + "59": "b" + }, + "accessIDToType": { + "27": 6, + "28": 6 + }, + "literalIDToName": { + "-61": "1" + }, + "fieldAccessIDs": [ + 27, + 28 + ], + "APIFieldIDs": [ + 27, + 28 + ], + "temporaryFieldIDs": [], + "globalVariableIDs": [], + "versionedFields": { + "variableVersionMap": {} + }, + "fieldnameToBoundaryCondition": {}, + "fieldIDtoDimensions": { + "27": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + }, + "28": { + "cartesian_horizontal_dimension": { + "mask_cart_i": 1, + "mask_cart_j": 1 + }, + "mask_k": 1 + } + }, + "idToStencilCall": { + "29": { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_29", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 30 + } + } + }, + "boundaryCallToExtent": {}, + "allocatedFieldIDs": [], + "stencilLocation": { + "Line": 23, + "Column": 8 + }, + "stencilName": "stencil" + }, + "internalIR": { + "gridType": "Cartesian", + "globalVariableToValue": {}, + "stencils": [ + { + "multiStages": [ + { + "stages": [ + { + "doMethods": [ + { + "ast": { + "block_stmt": { + "statements": [ + { + "var_decl_stmt": { + "type": { + "builtin_type": { + "type_id": "Integer" + }, + "is_const": false, + "is_volatile": false + }, + "name": "b", + "dimension": 0, + "op": "=", + "init_list": [ + { + "field_access_expr": { + "name": "d", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 28, + "Column": 15 + }, + "data": { + "accessID": 28 + }, + "ID": 89 + } + } + ], + "loc": { + "Line": 28, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "59": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "28": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "var_decl_stmt_data": { + "accessID": 59 + }, + "ID": 88 + } + }, + { + "var_decl_stmt": { + "type": { + "builtin_type": { + "type_id": "Integer" + }, + "is_const": false, + "is_volatile": false + }, + "name": "c", + "dimension": 0, + "op": "=", + "init_list": [ + { + "field_access_expr": { + "name": "d", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 29, + "Column": 15 + }, + "data": { + "accessID": 28 + }, + "ID": 91 + } + } + ], + "loc": { + "Line": 29, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "60": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "28": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "var_decl_stmt_data": { + "accessID": 60 + }, + "ID": 90 + } + }, + { + "expr_stmt": { + "expr": { + "assignment_expr": { + "left": { + "field_access_expr": { + "name": "a", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 30, + "Column": 7 + }, + "data": { + "accessID": 27 + }, + "ID": 100 + } + }, + "op": "+=", + "right": { + "binary_operator": { + "left": { + "unary_operator": { + "op": "++", + "operand": { + "var_access_expr": { + "name": "b", + "is_external": false, + "loc": { + "Line": 30, + "Column": 14 + }, + "data": { + "accessID": 59 + }, + "ID": 95 + } + }, + "loc": { + "Line": 30, + "Column": 12 + }, + "ID": 94 + } + }, + "op": "+", + "right": { + "binary_operator": { + "left": { + "literal_access_expr": { + "value": "1", + "type": { + "type_id": "Integer" + }, + "loc": { + "Line": 30, + "Column": 19 + }, + "data": { + "accessID": -61 + }, + "ID": 97 + } + }, + "op": "+", + "right": { + "unary_operator": { + "op": "--", + "operand": { + "var_access_expr": { + "name": "c", + "is_external": false, + "loc": { + "Line": 30, + "Column": 25 + }, + "data": { + "accessID": 60 + }, + "ID": 99 + } + }, + "loc": { + "Line": 30, + "Column": 23 + }, + "ID": 98 + } + }, + "loc": { + "Line": 30, + "Column": 19 + }, + "ID": 96 + } + }, + "loc": { + "Line": 30, + "Column": 12 + }, + "ID": 93 + } + }, + "loc": { + "Line": 30, + "Column": 7 + }, + "ID": 101 + } + }, + "loc": { + "Line": 30, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "27": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "60": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "59": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "27": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "-61": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 92 + } + }, + { + "expr_stmt": { + "expr": { + "assignment_expr": { + "left": { + "field_access_expr": { + "name": "a", + "vertical_offset": 0, + "zero_offset": {}, + "argument_map": [ + -1, + -1, + -1 + ], + "argument_offset": [ + 0, + 0, + 0 + ], + "negate_offset": false, + "loc": { + "Line": 31, + "Column": 7 + }, + "data": { + "accessID": 27 + }, + "ID": 108 + } + }, + "op": "*=", + "right": { + "binary_operator": { + "left": { + "unary_operator": { + "op": "++", + "operand": { + "var_access_expr": { + "name": "c", + "is_external": false, + "loc": { + "Line": 31, + "Column": 14 + }, + "data": { + "accessID": 60 + }, + "ID": 105 + } + }, + "loc": { + "Line": 31, + "Column": 12 + }, + "ID": 104 + } + }, + "op": "*", + "right": { + "unary_operator": { + "op": "--", + "operand": { + "var_access_expr": { + "name": "b", + "is_external": false, + "loc": { + "Line": 31, + "Column": 20 + }, + "data": { + "accessID": 59 + }, + "ID": 107 + } + }, + "loc": { + "Line": 31, + "Column": 18 + }, + "ID": 106 + } + }, + "loc": { + "Line": 31, + "Column": 12 + }, + "ID": 103 + } + }, + "loc": { + "Line": 31, + "Column": 7 + }, + "ID": 109 + } + }, + "loc": { + "Line": 31, + "Column": 7 + }, + "data": { + "accesses": { + "writeAccess": { + "27": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + }, + "readAccess": { + "27": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "59": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + }, + "60": { + "zero_extent": {}, + "vertical_extent": { + "minus": 0, + "plus": 0 + } + } + } + } + }, + "ID": 102 + } + } + ], + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 87 + } + }, + "doMethodID": 0, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + } + ], + "stageID": 57, + "locationType": "LocationTypeUnknown" + } + ], + "loopOrder": "Parallel", + "multiStageID": 62, + "Caches": { + "27": { + "type": "CT_K", + "policy": "CP_FillFlush", + "accessID": 27, + "interval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + }, + "enclosingAccessInterval": { + "lower_offset": 0, + "upper_offset": 0, + "special_lower_level": "Start", + "special_upper_level": "End" + } + } + } + } + ], + "stencilID": 29, + "attr": { + "attributes": [] + } + } + ], + "controlFlowStatements": [ + { + "stencil_call_decl_stmt": { + "stencil_call": { + "loc": { + "Line": -1, + "Column": -1 + }, + "callee": "__code_gen_29", + "arguments": [] + }, + "loc": { + "Line": -1, + "Column": -1 + }, + "data": {}, + "ID": 30 + } + } + ], + "boundaryConditions": [] + }, + "filename": "samples/test_simplify_statements_mix_multiple_nested.cpp" +} diff --git a/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp index 1c32a8c09..668c9bb59 100644 --- a/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp +++ b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_decrement.cpp @@ -21,12 +21,12 @@ using namespace gtclang::dsl; stencil stencil { - storage a; + storage a, d; Do { vertical_region(k_start, k_end) { - int b = 0; - int c = 0; + int b = d; + int c = d; --b; ++c; a = c + b; diff --git a/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_nested.cpp b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_nested.cpp new file mode 100644 index 000000000..93038d60d --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_increment_nested.cpp @@ -0,0 +1,32 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ _ +// | | | | +// __ _| |_ ___| | __ _ _ __ __ _ +// / _` | __/ __| |/ _` | '_ \ / _` | +// | (_| | || (__| | (_| | | | | (_| | +// \__, |\__\___|_|\__,_|_| |_|\__, | - GridTools Clang DSL +// __/ | __/ | +// |___/ |___/ +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +// gtclang test_simplify_statements_increment_nested.cpp -fno-codegen -fwrite-iir -fkeep-varnames + +#include "gtclang_dsl_defs/gtclang_dsl.hpp" + +using namespace gtclang::dsl; + +stencil stencil { + storage a, c; + + Do { + vertical_region(k_start, k_end) { + int b = c; + a = (++b) + 1; + } + } +}; diff --git a/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_mix_multiple_nested.cpp b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_mix_multiple_nested.cpp new file mode 100644 index 000000000..7dd39ecb6 --- /dev/null +++ b/dawn/test/unit-test/dawn/Optimizer/samples/test_simplify_statements_mix_multiple_nested.cpp @@ -0,0 +1,34 @@ +//===--------------------------------------------------------------------------------*- C++ -*-===// +// _ _ +// | | | | +// __ _| |_ ___| | __ _ _ __ __ _ +// / _` | __/ __| |/ _` | '_ \ / _` | +// | (_| | || (__| | (_| | | | | (_| | +// \__, |\__\___|_|\__,_|_| |_|\__, | - GridTools Clang DSL +// __/ | __/ | +// |___/ |___/ +// +// +// This file is distributed under the MIT License (MIT). +// See LICENSE.txt for details. +// +//===------------------------------------------------------------------------------------------===// + +// gtclang test_simplify_statements_mix_multiple_nested.cpp -fno-codegen -fwrite-iir -fkeep-varnames + +#include "gtclang_dsl_defs/gtclang_dsl.hpp" + +using namespace gtclang::dsl; + +stencil stencil { + storage a, d; + + Do { + vertical_region(k_start, k_end) { + int b = d; + int c = d; + a += ++b + (1 + --c); + a *= ++c * --b; + } + } +}; From 318a5c7975c961617a95efc3ad6d96b300532f9f Mon Sep 17 00:00:00 2001 From: Giacomo Serafini Date: Fri, 17 Apr 2020 09:40:15 +0200 Subject: [PATCH 3/5] Add to lowering, fix bug, update one ref --- dawn/src/dawn/Compiler/DawnCompiler.cpp | 2 ++ dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp | 4 ++++ dawn/src/dawn/Optimizer/PassSimplifyStatements.h | 4 +++- .../data/tridiagonal_solve_stencil_ref.cpp | 10 +++++----- 4 files changed, 14 insertions(+), 6 deletions(-) diff --git a/dawn/src/dawn/Compiler/DawnCompiler.cpp b/dawn/src/dawn/Compiler/DawnCompiler.cpp index ab65ef762..f9dddf42a 100644 --- a/dawn/src/dawn/Compiler/DawnCompiler.cpp +++ b/dawn/src/dawn/Compiler/DawnCompiler.cpp @@ -40,6 +40,7 @@ #include "dawn/Optimizer/PassSetStageLocationType.h" #include "dawn/Optimizer/PassSetStageName.h" #include "dawn/Optimizer/PassSetSyncStage.h" +#include "dawn/Optimizer/PassSimplifyStatements.h" #include "dawn/Optimizer/PassStageMerger.h" #include "dawn/Optimizer/PassStageReordering.h" #include "dawn/Optimizer/PassStageSplitAllStatements.h" @@ -143,6 +144,7 @@ DawnCompiler::lowerToIIR(const std::shared_ptr& stencilIR) { using MultistageSplitStrategy = PassMultiStageSplitter::MultiStageSplittingStrategy; // required passes to have proper, parallelized IR + optimizer.pushBackPass(); optimizer.pushBackPass(PassInlining::InlineStrategy::InlineProcedures); optimizer.pushBackPass(); optimizer.pushBackPass( diff --git a/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp b/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp index b801148ab..25f850373 100644 --- a/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp +++ b/dawn/src/dawn/Optimizer/PassSimplifyStatements.cpp @@ -15,6 +15,7 @@ #include "PassSimplifyStatements.h" #include "dawn/AST/ASTExpr.h" #include "dawn/IIR/ASTFwd.h" +#include "dawn/IIR/AccessComputation.h" #include "dawn/IIR/DoMethod.h" #include "dawn/IIR/StencilInstantiation.h" #include "dawn/Support/Type.h" @@ -95,6 +96,9 @@ bool PassSimplifyStatements::run( ++stmtIt; } + // Recompute the accesses metadata of all statements (new statements and changed statements + // require this) + computeAccesses(stencilInstantiation->getMetaData(), doMethod->getAST().getStatements()); } return true; } diff --git a/dawn/src/dawn/Optimizer/PassSimplifyStatements.h b/dawn/src/dawn/Optimizer/PassSimplifyStatements.h index b00be88f4..d18c9a60b 100644 --- a/dawn/src/dawn/Optimizer/PassSimplifyStatements.h +++ b/dawn/src/dawn/Optimizer/PassSimplifyStatements.h @@ -18,7 +18,9 @@ namespace dawn { -/// @brief PassSimplifyStatements... +/// @brief PassSimplifyStatements converts "advanced" statements (compound assignments and +/// increment, decrement ops) into their extended equivalent forms, to have a syntax which is +/// simpler to anaylise. /// @ingroup optimizer /// /// This pass is necessary to generate legal IIR diff --git a/dawn/test/integration-test/dawn4py-tests/data/tridiagonal_solve_stencil_ref.cpp b/dawn/test/integration-test/dawn4py-tests/data/tridiagonal_solve_stencil_ref.cpp index 92ecd9e8e..8478f465f 100644 --- a/dawn/test/integration-test/dawn4py-tests/data/tridiagonal_solve_stencil_ref.cpp +++ b/dawn/test/integration-test/dawn4py-tests/data/tridiagonal_solve_stencil_ref.cpp @@ -47,7 +47,7 @@ using namespace gridtools::dawn; //---- Stencils ---- namespace dawn_generated{ namespace cuda{ -__global__ void __launch_bounds__(32) tridiagonal_solve_stencil_stencil49_ms105_kernel(const int isize, const int jsize, const int ksize, const int stride_111_1, const int stride_111_2, ::dawn::float_type * const a, ::dawn::float_type * const b, ::dawn::float_type * const c, ::dawn::float_type * const d) { +__global__ void __launch_bounds__(32) tridiagonal_solve_stencil_stencil49_ms108_kernel(const int isize, const int jsize, const int ksize, const int stride_111_1, const int stride_111_2, ::dawn::float_type * const a, ::dawn::float_type * const b, ::dawn::float_type * const c, ::dawn::float_type * const d) { // Start kernel ::dawn::float_type c_kcache[2]; @@ -162,7 +162,7 @@ if(iblock >= 0 && iblock <= block_size_i -1 + 0 && jblock >= 0 && jblock <= bloc // Final flush of kcaches } -__global__ void __launch_bounds__(32) tridiagonal_solve_stencil_stencil49_ms106_kernel(const int isize, const int jsize, const int ksize, const int stride_111_1, const int stride_111_2, ::dawn::float_type * const c, ::dawn::float_type * const d) { +__global__ void __launch_bounds__(32) tridiagonal_solve_stencil_stencil49_ms109_kernel(const int isize, const int jsize, const int ksize, const int stride_111_1, const int stride_111_2, ::dawn::float_type * const c, ::dawn::float_type * const d) { // Start kernel ::dawn::float_type d_kcache[2]; @@ -219,7 +219,7 @@ if(iblock >= 0 && iblock <= block_size_i -1 + 0 && jblock >= 0 && jblock <= bloc if(iblock >= 0 && iblock <= block_size_i -1 + 0 && jblock >= 0 && jblock <= block_size_j -1 + 0) { d_kcache[0] =d[idx111]; } if(iblock >= 0 && iblock <= block_size_i -1 + 0 && jblock >= 0 && jblock <= block_size_j -1 + 0) { -d_kcache[0] -= (__ldg(&(c[idx111])) * d_kcache[1]); +d_kcache[0] = (d_kcache[0] - (__ldg(&(c[idx111])) * d_kcache[1])); } // Flush of kcaches @@ -290,7 +290,7 @@ class tridiagonal_solve_stencil { const unsigned int nby = (ny + 1 - 1) / 1; const unsigned int nbz = 1; dim3 blocks(nbx, nby, nbz); - tridiagonal_solve_stencil_stencil49_ms105_kernel<<>>(nx,ny,nz,a_ds.strides()[1],a_ds.strides()[2],(a.data()+a_ds.get_storage_info_ptr()->index(a.begin<0>(), a.begin<1>(),0 )),(b.data()+b_ds.get_storage_info_ptr()->index(b.begin<0>(), b.begin<1>(),0 )),(c.data()+c_ds.get_storage_info_ptr()->index(c.begin<0>(), c.begin<1>(),0 )),(d.data()+d_ds.get_storage_info_ptr()->index(d.begin<0>(), d.begin<1>(),0 ))); + tridiagonal_solve_stencil_stencil49_ms108_kernel<<>>(nx,ny,nz,a_ds.strides()[1],a_ds.strides()[2],(a.data()+a_ds.get_storage_info_ptr()->index(a.begin<0>(), a.begin<1>(),0 )),(b.data()+b_ds.get_storage_info_ptr()->index(b.begin<0>(), b.begin<1>(),0 )),(c.data()+c_ds.get_storage_info_ptr()->index(c.begin<0>(), c.begin<1>(),0 )),(d.data()+d_ds.get_storage_info_ptr()->index(d.begin<0>(), d.begin<1>(),0 ))); }; {; gridtools::data_view c= gridtools::make_device_view(c_ds); @@ -303,7 +303,7 @@ class tridiagonal_solve_stencil { const unsigned int nby = (ny + 1 - 1) / 1; const unsigned int nbz = 1; dim3 blocks(nbx, nby, nbz); - tridiagonal_solve_stencil_stencil49_ms106_kernel<<>>(nx,ny,nz,c_ds.strides()[1],c_ds.strides()[2],(c.data()+c_ds.get_storage_info_ptr()->index(c.begin<0>(), c.begin<1>(),0 )),(d.data()+d_ds.get_storage_info_ptr()->index(d.begin<0>(), d.begin<1>(),0 ))); + tridiagonal_solve_stencil_stencil49_ms109_kernel<<>>(nx,ny,nz,c_ds.strides()[1],c_ds.strides()[2],(c.data()+c_ds.get_storage_info_ptr()->index(c.begin<0>(), c.begin<1>(),0 )),(d.data()+d_ds.get_storage_info_ptr()->index(d.begin<0>(), d.begin<1>(),0 ))); }; // stopping timers From bcd330c4824d6ad4bbccff7d5f9c0f950be73fde Mon Sep 17 00:00:00 2001 From: Giacomo Serafini Date: Fri, 17 Apr 2020 09:54:45 +0200 Subject: [PATCH 4/5] Remove usage of CompilerUtils --- .../dawn/Optimizer/TestPassSimplifyStatements.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp index 5976fa75a..5895fe5ed 100644 --- a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp +++ b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp @@ -33,18 +33,17 @@ using namespace dawn; using namespace astgen; namespace { -// TODO remove compilerutil class TestPassSimplifyStatements : public ::testing::Test { protected: - dawn::OptimizerContext::OptimizerContextOptions options_; std::unique_ptr context_; std::shared_ptr instantiation_; void runPass(const std::string& filename) { dawn::UIDGenerator::getInstance()->reset(); - instantiation_ = CompilerUtil::load(filename, options_, context_, TestEnvironment::path_); + instantiation_ = IIRSerializer::deserialize(filename); - ASSERT_TRUE(CompilerUtil::runPass(context_, instantiation_)); + PassSimplifyStatements pass(*context_); + ASSERT_TRUE(pass.run(instantiation_)); } }; From 5ea58e9b84829051d01906530101bc861f5d3c1e Mon Sep 17 00:00:00 2001 From: Giacomo Serafini Date: Wed, 22 Apr 2020 11:01:30 +0200 Subject: [PATCH 5/5] Use new pattern for tests --- .../Optimizer/TestPassSimplifyStatements.cpp | 73 +++++++++---------- 1 file changed, 35 insertions(+), 38 deletions(-) diff --git a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp index 5895fe5ed..6ed448d7b 100644 --- a/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp +++ b/dawn/test/unit-test/dawn/Optimizer/TestPassSimplifyStatements.cpp @@ -13,17 +13,14 @@ //===------------------------------------------------------------------------------------------===// #include "dawn/AST/ASTStringifier.h" -#include "dawn/Compiler/DawnCompiler.h" -#include "dawn/Compiler/Options.h" #include "dawn/IIR/ASTFwd.h" #include "dawn/IIR/IIR.h" #include "dawn/IIR/StencilInstantiation.h" +#include "dawn/Optimizer/OptimizerContext.h" #include "dawn/Optimizer/PassSimplifyStatements.h" #include "dawn/Serialization/IIRSerializer.h" #include "dawn/Unittest/ASTConstructionAliases.h" -#include "dawn/Unittest/CompilerUtil.h" #include "dawn/Unittest/UnittestUtils.h" -#include "test/unit-test/dawn/Optimizer/TestEnvironment.h" #include #include @@ -33,87 +30,87 @@ using namespace dawn; using namespace astgen; namespace { -class TestPassSimplifyStatements : public ::testing::Test { -protected: - std::unique_ptr context_; - std::shared_ptr instantiation_; - void runPass(const std::string& filename) { - dawn::UIDGenerator::getInstance()->reset(); - instantiation_ = IIRSerializer::deserialize(filename); +std::shared_ptr initializeInstantiation(const std::string& filename) { + UIDGenerator::getInstance()->reset(); + auto instantiation = IIRSerializer::deserialize(filename); + DiagnosticsEngine diag; + OptimizerContext context(diag, {}, {{instantiation->getName(), instantiation}}); - PassSimplifyStatements pass(*context_); - ASSERT_TRUE(pass.run(instantiation_)); - } -}; + PassSimplifyStatements pass(context); + pass.run(instantiation); + EXPECT_TRUE(!diag.hasErrors()); -TEST_F(TestPassSimplifyStatements, CompoundStatement) { + return instantiation; +} + +TEST(TestPassSimplifyStatements, CompoundStatement) { // b += a; // d -= c; - runPass("input/test_simplify_statements_compound_statement.iir"); - auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 0); + auto instantiation = initializeInstantiation("input/test_simplify_statements_compound_statement.iir"); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation), 0); ASSERT_TRUE(firstStmt->equals(expr(assign(field("b"), binop(field("b"), "+", field("a")))).get(), /*compareData = */ false)); - auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 1); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation), 1); ASSERT_TRUE(secondStmt->equals(expr(assign(field("d"), binop(field("d"), "-", field("c")))).get(), /*compareData = */ false)); } -TEST_F(TestPassSimplifyStatements, IncrementDecrement) { +TEST(TestPassSimplifyStatements, IncrementDecrement) { // int b = d; // int c = d; // --b; // ++c; // a = c + b; - runPass("input/test_simplify_statements_increment_decrement.iir"); - ASSERT_EQ(5, getFirstDoMethod(instantiation_).getAST().getStatements().size()); - auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); + auto instantiation = initializeInstantiation("input/test_simplify_statements_increment_decrement.iir"); + ASSERT_EQ(5, getFirstDoMethod(instantiation).getAST().getStatements().size()); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation), 2); ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "-", lit(1)))).get(), /*compareData = */ false)); - auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 3); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation), 3); ASSERT_TRUE(secondStmt->equals(expr(assign(var("c"), binop(var("c"), "+", lit(1)))).get(), /*compareData = */ false)); } -TEST_F(TestPassSimplifyStatements, IncrementNested) { +TEST(TestPassSimplifyStatements, IncrementNested) { // int b = c; // a = (++b) + 1; - runPass("input/test_simplify_statements_increment_nested.iir"); - ASSERT_EQ(3, getFirstDoMethod(instantiation_).getAST().getStatements().size()); - auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 1); + auto instantiation = initializeInstantiation("input/test_simplify_statements_increment_nested.iir"); + ASSERT_EQ(3, getFirstDoMethod(instantiation).getAST().getStatements().size()); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation), 1); ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "+", lit(1)))).get(), /*compareData = */ false)); - auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation), 2); ASSERT_TRUE(secondStmt->equals(expr(assign(field("a"), binop(var("b"), "+", lit(1)))).get(), /*compareData = */ false)); } -TEST_F(TestPassSimplifyStatements, MixMultipleNested) { +TEST(TestPassSimplifyStatements, MixMultipleNested) { // int b = d; // int c = d; // a += ++b + (1 + --c); // a *= ++c * --b; - runPass("input/test_simplify_statements_mix_multiple_nested.iir"); - ASSERT_EQ(8, getFirstDoMethod(instantiation_).getAST().getStatements().size()); - auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation_), 2); + auto instantiation = initializeInstantiation("input/test_simplify_statements_mix_multiple_nested.iir"); + ASSERT_EQ(8, getFirstDoMethod(instantiation).getAST().getStatements().size()); + auto const& firstStmt = getNthStmt(getFirstDoMethod(instantiation), 2); ASSERT_TRUE(firstStmt->equals(expr(assign(var("b"), binop(var("b"), "+", lit(1)))).get(), /*compareData = */ false)); - auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation_), 3); + auto const& secondStmt = getNthStmt(getFirstDoMethod(instantiation), 3); ASSERT_TRUE(secondStmt->equals(expr(assign(var("c"), binop(var("c"), "-", lit(1)))).get(), /*compareData = */ false)); - auto const& thirdStmt = getNthStmt(getFirstDoMethod(instantiation_), 4); + auto const& thirdStmt = getNthStmt(getFirstDoMethod(instantiation), 4); ASSERT_TRUE(thirdStmt->equals( expr(assign(field("a"), binop(field("a"), "+", binop(var("b"), "+", binop(lit(1), "+", var("c")))))) .get(), /*compareData = */ false)); - auto const& fourthStmt = getNthStmt(getFirstDoMethod(instantiation_), 5); + auto const& fourthStmt = getNthStmt(getFirstDoMethod(instantiation), 5); ASSERT_TRUE(fourthStmt->equals(expr(assign(var("c"), binop(var("c"), "+", lit(1)))).get(), /*compareData = */ false)); - auto const& fifthStmt = getNthStmt(getFirstDoMethod(instantiation_), 6); + auto const& fifthStmt = getNthStmt(getFirstDoMethod(instantiation), 6); ASSERT_TRUE(fifthStmt->equals(expr(assign(var("b"), binop(var("b"), "-", lit(1)))).get(), /*compareData = */ false)); - auto const& sixthStmt = getNthStmt(getFirstDoMethod(instantiation_), 7); + auto const& sixthStmt = getNthStmt(getFirstDoMethod(instantiation), 7); ASSERT_TRUE(sixthStmt->equals( expr(assign(field("a"), binop(field("a"), "*", binop(var("c"), "*", var("b"))))).get(), /*compareData = */ false));