Support for Breakpoint block (nrn_cur) for code generation (#645)

* Support for Breakpoint block (nrn_cur) for code generation
* similar to DERIVATIVE (nrn_state), handle BREAKPOINT (nrn_cur)
   blocks with AST level transformation
* Move common code from CodegenCVisitor to CodegenInfo
* Add tests

fixes #644

Co-authored-by: George Mitenkov <georgemitenk0v@gmail.com>

Author: pramodk

src/codegen/codegen_acc_visitor.cpp

@@ -200,8 +200,8 @@ void CodegenAccVisitor::print_net_init_acc_serial_annotation_block_end() {
 }
 
 void CodegenAccVisitor::print_nrn_cur_matrix_shadow_update() {
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    const auto& rhs_op = info.operator_for_rhs();
+    const auto& d_op = info.operator_for_d();
     print_atomic_reduction_pragma();
     printer->add_line("vec_rhs[node_id] {} rhs;"_format(rhs_op));
     print_atomic_reduction_pragma();
@@ -213,8 +213,8 @@ void CodegenAccVisitor::print_fast_imem_calculation() {
         return;
     }
 
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    const auto& rhs_op = info.operator_for_rhs();
+    const auto& d_op = info.operator_for_d();
     printer->start_block("if (nt->nrn_fast_imem)");
     print_atomic_reduction_pragma();
     printer->add_line("nt->nrn_fast_imem->nrn_sav_rhs[node_id] {} rhs;"_format(rhs_op));

src/codegen/codegen_c_visitor.cpp

@@ -325,37 +325,6 @@ void CodegenCVisitor::visit_update_dt(const ast::UpdateDt& node) {
 /*                               Common helper routines                                 */
 /****************************************************************************************/
 
-
-/**
- * \details Certain statements like unit, comment, solve can/need to be skipped
- * during code generation. Note that solve block is wrapped in expression
- * statement and hence we have to check inner expression. It's also true
- * for the initial block defined inside net receive block.
- */
-bool CodegenCVisitor::statement_to_skip(const Statement& node) const {
-    // clang-format off
-    if (node.is_unit_state()
-        || node.is_line_comment()
-        || node.is_block_comment()
-        || node.is_solve_block()
-        || node.is_conductance_hint()
-        || node.is_table_statement()) {
-        return true;
-    }
-    // clang-format on
-    if (node.is_expression_statement()) {
-        auto expression = dynamic_cast<const ExpressionStatement*>(&node)->get_expression();
-        if (expression->is_solve_block()) {
-            return true;
-        }
-        if (expression->is_initial_block()) {
-            return true;
-        }
-    }
-    return false;
-}
-
-
 /**
  * \details When floating point data type is not default (i.e. double) then we
  * have to copy old array to new type (for range variables).
@@ -974,8 +943,8 @@ void CodegenCVisitor::print_nrn_cur_matrix_shadow_update() {
             printer->add_line("shadow_rhs[id] = rhs;");
             printer->add_line("shadow_d[id] = g;");
         } else {
-            auto rhs_op = operator_for_rhs();
-            auto d_op = operator_for_d();
+            const auto& rhs_op = info.operator_for_rhs();
+            const auto& d_op = info.operator_for_d();
             print_atomic_reduction_pragma();
             printer->add_line("vec_rhs[node_id] {} rhs;"_format(rhs_op));
             print_atomic_reduction_pragma();
@@ -986,8 +955,8 @@ void CodegenCVisitor::print_nrn_cur_matrix_shadow_update() {
 
 
 void CodegenCVisitor::print_nrn_cur_matrix_shadow_reduction() {
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    const auto& rhs_op = info.operator_for_rhs();
+    const auto& d_op = info.operator_for_d();
     if (channel_task_dependency_enabled()) {
         auto rhs = get_variable_name("ml_rhs");
         auto d = get_variable_name("ml_d");
@@ -1167,7 +1136,7 @@ void CodegenCVisitor::print_statement_block(const ast::StatementBlock& node,
 
     auto statements = node.get_statements();
     for (const auto& statement: statements) {
-        if (statement_to_skip(*statement)) {
+        if (info.statement_to_skip(*statement)) {
             continue;
         }
         /// not necessary to add indent for verbatim block (pretty-printing)
@@ -4337,8 +4306,8 @@ void CodegenCVisitor::print_fast_imem_calculation() {
         return;
     }
     std::string rhs, d;
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    const auto& rhs_op = info.operator_for_rhs();
+    const auto& d_op = info.operator_for_d();
     if (channel_task_dependency_enabled()) {
         rhs = get_variable_name("ml_rhs");
         d = get_variable_name("ml_d");

src/codegen/codegen_c_visitor.hpp

@@ -218,23 +218,6 @@ class CodegenCVisitor: public visitor::ConstAstVisitor {
         return "\"" + text + "\"";
     }
 
-
-    /**
-     * Operator for rhs vector update (matrix update)
-     */
-    std::string operator_for_rhs() const noexcept {
-        return info.electrode_current ? "+=" : "-=";
-    }
-
-
-    /**
-     * Operator for diagonal vector update (matrix update)
-     */
-    std::string operator_for_d() const noexcept {
-        return info.electrode_current ? "-=" : "+=";
-    }
-
-
     /**
      * Data type for the local variables
      */

src/codegen/codegen_cuda_visitor.cpp

@@ -96,8 +96,8 @@ void CodegenCudaVisitor::print_device_method_annotation() {
 
 
 void CodegenCudaVisitor::print_nrn_cur_matrix_shadow_update() {
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    auto rhs_op = info.operator_for_rhs();
+    auto d_op = info.operator_for_d();
     stringutils::remove_character(rhs_op, '=');
     stringutils::remove_character(d_op, '=');
     print_atomic_op("vec_rhs[node_id]", rhs_op, "rhs");
@@ -109,8 +109,8 @@ void CodegenCudaVisitor::print_fast_imem_calculation() {
         return;
     }
 
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    auto rhs_op = info.operator_for_rhs();
+    auto d_op = info.operator_for_d();
     stringutils::remove_character(rhs_op, '=');
     stringutils::remove_character(d_op, '=');
     printer->start_block("if (nt->nrn_fast_imem)");

src/codegen/codegen_driver.cpp

@@ -179,7 +179,7 @@ bool CodegenDriver::prepare_mod(std::shared_ptr<ast::Program> node, const std::s
     /// that old symbols (e.g. prime variables) are not lost
     update_symtab = true;
 
-    if (cfg.nmodl_inline) {
+    if (cfg.nmodl_inline || cfg.llvm_ir) {
         logger->info("Running nmodl inline visitor");
         InlineVisitor().visit_program(*node);
         ast_to_nmodl(*node, filepath("inline", "mod"));

src/codegen/codegen_info.cpp

@@ -404,5 +404,34 @@ void CodegenInfo::get_float_variables() {
     }
 }
 
+/**
+ * \details Certain statements like unit, comment, solve can/need to be skipped
+ * during code generation. Note that solve block is wrapped in expression
+ * statement and hence we have to check inner expression. It's also true
+ * for the initial block defined inside net receive block.
+ */
+bool CodegenInfo::statement_to_skip(const ast::Statement& node) const {
+    // clang-format off
+    if (node.is_unit_state()
+        || node.is_line_comment()
+        || node.is_block_comment()
+        || node.is_solve_block()
+        || node.is_conductance_hint()
+        || node.is_table_statement()) {
+        return true;
+    }
+    // clang-format on
+    if (node.is_expression_statement()) {
+        auto expression = dynamic_cast<const ast::ExpressionStatement*>(&node)->get_expression();
+        if (expression->is_solve_block()) {
+            return true;
+        }
+        if (expression->is_initial_block()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 }  // namespace codegen
 }  // namespace nmodl

src/codegen/codegen_info.hpp

@@ -590,6 +590,29 @@ struct CodegenInfo {
     }
 
 
+    /**
+     * Operator for rhs vector update (matrix update)
+     *
+     * Note that we only rely on following two syntax for
+     * increment and decrement. Code generation backends
+     * are relying on this convention.
+     */
+    std::string operator_for_rhs() const noexcept {
+        return electrode_current ? "+=" : "-=";
+    }
+
+
+    /**
+     * Operator for diagonal vector update (matrix update)
+     *
+     * Note that we only rely on following two syntax for
+     * increment and decrement. Code generation backends
+     * are relying on this convention.
+     */
+    std::string operator_for_d() const noexcept {
+        return electrode_current ? "-=" : "+=";
+    }
+
     /**
      * Check if net_receive function is required
      */
@@ -657,6 +680,13 @@ struct CodegenInfo {
      * \return A \c vector of \c float variables
      */
     void get_float_variables();
+
+    /**
+     * Check if statement should be skipped for code generation
+     * @param node Statement to be checked for code generation
+     * @return True if statement should be skipped otherwise false
+     */
+    bool statement_to_skip(const ast::Statement& node) const;
 };
 
 /** @} */  // end of codegen_backends

src/codegen/codegen_ispc_visitor.cpp

@@ -248,8 +248,8 @@ void CodegenIspcVisitor::print_atomic_op(const std::string& lhs,
 
 
 void CodegenIspcVisitor::print_nrn_cur_matrix_shadow_reduction() {
-    auto rhs_op = operator_for_rhs();
-    auto d_op = operator_for_d();
+    const auto& rhs_op = info.operator_for_rhs();
+    const auto& d_op = info.operator_for_d();
     if (info.point_process) {
         printer->add_line("uniform int node_id = node_index[id];");
         printer->add_line("vec_rhs[node_id] {} shadow_rhs[id];"_format(rhs_op));

src/codegen/codegen_naming.hpp

@@ -92,6 +92,12 @@ static constexpr char NTHREAD_RHS_SHADOW[] = "_shadow_rhs";
 /// shadow d variable in neuron thread structure
 static constexpr char NTHREAD_D_SHADOW[] = "_shadow_d";
 
+/// rhs variable in neuron thread structure
+static constexpr char NTHREAD_RHS[] = "vec_rhs";
+
+/// d variable in neuron thread structure
+static constexpr char NTHREAD_D[] = "vec_d";
+
 /// t variable in neuron thread structure
 static constexpr char NTHREAD_T_VARIABLE[] = "t";