Testy wydajnościowe

engine/CMakeLists.txt

@@ -72,7 +72,9 @@ add_library(
   ${PARSER_DIR}/Scanner.cu
   ${PARSER_DIR}/Parser.cu)
 
-add_executable(cusymint ${SRC_DIR}/main.cu)
+add_executable(cusymint 
+  ${SRC_DIR}/Performance.cu
+  ${SRC_DIR}/main.cu)
 
 add_executable(
   testcusymint

engine/src/Evaluation/ComputationHistory.cu

@@ -234,6 +234,22 @@ namespace Sym {
         fmt::print("}}\n");
     }
 
+    size_t ComputationStep::get_memory_occupance_in_bytes() const {
+        size_t size = 0;
+        for (const auto& expr : expression_tree) {
+            size += expr.size();
+        }
+        return sizeof(ComputationStep) + size * sizeof(Symbol);
+    }
+
+    size_t ComputationHistory::get_memory_occupance_in_bytes() const {
+        size_t size = 0;
+        for (const auto& step : computation_steps) {
+            size += step.get_memory_occupance_in_bytes();
+        }
+        return sizeof(ComputationHistory) + size;
+    }
+
     void ComputationHistory::complete() {
         if (!is_solution_at_end_of_steps()) {
             Util::crash("ComputationHistory must have solution at the end to complete");
@@ -290,19 +306,24 @@ namespace Sym {
                 else {
                     size_t trans_idx = 1;
                     for (const auto& trans : step.get_operations(*prev_step)) {
-                        result.push_back(fmt::format(
-                            R"(\quad \text{{{}{} {}:}}\:{}:)", trans_idx, get_ordinal_suffix(trans_idx),
-                            Globalization::INTEGRAL, trans->get_description()));
+                        result.push_back(fmt::format(R"(\quad \text{{{}{} {}:}}\:{}:)", trans_idx,
+                                                     get_ordinal_suffix(trans_idx),
+                                                     Globalization::INTEGRAL,
+                                                     trans->get_description()));
                         ++trans_idx;
                     }
                 }
-                result.push_back(fmt::format(R"(=\qquad {})", expression.data()->to_tex()));
+                result.push_back(fmt::format(R"(=\qquad {})", expression_str));
             }
 
             prev_str = expression_str;
             prev_step = &step;
         }
 
+        if (!result.empty()) {
+            result[result.size() - 1] += " + C";
+        }
+
         return result;
     }
 

engine/src/Evaluation/ComputationHistory.cuh

@@ -33,6 +33,7 @@ namespace Sym {
         std::vector<Symbol> get_expression() const;
         TransformationList get_operations(const ComputationStep& previous_step) const;
         void print_step() const;
+        size_t get_memory_occupance_in_bytes() const;
     };
 
     using ComputationStepCollection = std::list<ComputationStep>;
@@ -58,6 +59,8 @@ namespace Sym {
         void print_history() const;
 
         const ComputationStepCollection& get_steps() const { return computation_steps; } 
+
+        size_t get_memory_occupance_in_bytes() const;
     };
 }
 

engine/src/Evaluation/Integrator.cu

@@ -4,9 +4,9 @@
 #include <thrust/execution_policy.h>
 #include <thrust/scan.h>
 
+#include "ComputationHistory.cuh"
 #include "IntegratorKernels.cuh"
 #include "StaticFunctions.cuh"
-#include "ComputationHistory.cuh"
 
 #include "Evaluation/Heuristic/Heuristic.cuh"
 #include "Symbol/SubexpressionCandidate.cuh"
@@ -188,7 +188,8 @@ namespace Sym {
         scan_array_2.zero_mem();
         cudaDeviceSynchronize();
 
-        help_space.reoffset_like<SubexpressionCandidate>(integrals.iterator(), HELP_SPACE_MULTIPLIER, Heuristic::COUNT);
+        help_space.reoffset_like<SubexpressionCandidate>(integrals.iterator(),
+                                                         HELP_SPACE_MULTIPLIER, Heuristic::COUNT);
 
         Kernel::check_heuristics_applicability<<<BLOCK_COUNT, BLOCK_SIZE>>>(
             integrals, expressions, help_space, scan_array_1, scan_array_2);

engine/src/Evaluation/Integrator.cuh

@@ -238,6 +238,131 @@ namespace Sym {
 
             return std::nullopt;
         }
+
+        size_t memory_usage_for_integral(const std::vector<Symbol>& integral,
+                                         size_t& total_memory) {
+            size_t initial_usage;
+            size_t max_usage;
+            size_t usage;
+
+            size_t initial_size =
+                sizeof(Symbol) *
+                    (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                     expressions_swap.symbols_capacity() + integrals_swap.symbols_capacity() +
+                     help_space.symbols_capacity()) +
+                sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                sizeof(EvaluationStatus) *
+                    (evaluation_statuses_1.size() + evaluation_statuses_2.size());
+            size_t max_shown_size = initial_size;
+
+            cudaMemGetInfo(&initial_usage, &total_memory);
+            max_usage = initial_usage;
+
+            expressions.load_from_vector({single_integral_vacancy()});
+            integrals.load_from_vector({first_expression_candidate(integral)});
+
+            max_shown_size = std::max(
+                max_shown_size,
+                sizeof(Symbol) *
+                        (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                         expressions_swap.symbols_capacity() + integrals_swap.symbols_capacity() +
+                         help_space.symbols_capacity()) +
+                    sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                    sizeof(EvaluationStatus) *
+                        (evaluation_statuses_1.size() + evaluation_statuses_2.size()));
+
+            cudaMemGetInfo(&usage, nullptr);
+            max_usage = std::min(usage, max_usage);
+
+            for (size_t i = 0;; ++i) {
+                simplify_integrals();
+
+                cudaMemGetInfo(&usage, nullptr);
+                max_usage = std::min(usage, max_usage);
+
+                max_shown_size = std::max(
+                    max_shown_size,
+                    sizeof(Symbol) *
+                            (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                             expressions_swap.symbols_capacity() +
+                             integrals_swap.symbols_capacity() + help_space.symbols_capacity()) +
+                        sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                        sizeof(EvaluationStatus) *
+                            (evaluation_statuses_1.size() + evaluation_statuses_2.size()));
+
+                check_for_known_integrals();
+                apply_known_integrals();
+
+                cudaMemGetInfo(&usage, nullptr);
+                max_usage = std::min(usage, max_usage);
+
+                max_shown_size = std::max(
+                    max_shown_size,
+                    sizeof(Symbol) *
+                            (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                             expressions_swap.symbols_capacity() +
+                             integrals_swap.symbols_capacity() + help_space.symbols_capacity()) +
+                        sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                        sizeof(EvaluationStatus) *
+                            (evaluation_statuses_1.size() + evaluation_statuses_2.size()));
+
+                if (is_original_expression_solved()) {
+                    break;
+                }
+
+                remove_unnecessary_candidates();
+
+                cudaMemGetInfo(&usage, nullptr);
+                max_usage = std::min(usage, max_usage);
+
+                max_shown_size = std::max(
+                    max_shown_size,
+                    sizeof(Symbol) *
+                            (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                             expressions_swap.symbols_capacity() +
+                             integrals_swap.symbols_capacity() + help_space.symbols_capacity()) +
+                        sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                        sizeof(EvaluationStatus) *
+                            (evaluation_statuses_1.size() + evaluation_statuses_2.size()));
+
+                check_heuristics_applicability();
+                apply_heuristics();
+
+                cudaMemGetInfo(&usage, nullptr);
+                max_usage = std::min(usage, max_usage);
+
+                max_shown_size = std::max(
+                    max_shown_size,
+                    sizeof(Symbol) *
+                            (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                             expressions_swap.symbols_capacity() +
+                             integrals_swap.symbols_capacity() + help_space.symbols_capacity()) +
+                        sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                        sizeof(EvaluationStatus) *
+                            (evaluation_statuses_1.size() + evaluation_statuses_2.size()));
+
+                if (has_original_expression_failed()) {
+                    break;
+                }
+
+                remove_failed_candidates();
+
+                cudaMemGetInfo(&usage, nullptr);
+                max_usage = std::min(usage, max_usage);
+
+                max_shown_size = std::max(
+                    max_shown_size,
+                    sizeof(Symbol) *
+                            (expressions.symbols_capacity() + integrals.symbols_capacity() +
+                             expressions_swap.symbols_capacity() +
+                             integrals_swap.symbols_capacity() + help_space.symbols_capacity()) +
+                        sizeof(size_t) * (scan_array_1.size() + scan_array_2.size()) +
+                        sizeof(EvaluationStatus) *
+                            (evaluation_statuses_1.size() + evaluation_statuses_2.size()));
+            }
+            printf("Declared bytes:%lu\n", max_shown_size);
+            return initial_usage - max_usage;
+        }
     };
 }