cpp bug fix & frontend bug fix

Author: Abylkasym uulu Alidin

time_complexity_analyzer/analyzer/analyzer_cpp.py

@@ -17,24 +17,27 @@ def instrument_cpp_function(user_function, call_template, num_inputs, size_array
 #include <cstdlib>
 #include <ctime>
 #include <algorithm>
+#include <cmath>
+
+using Clock = std::chrono::steady_clock;
 
 class InstrumentedPrototype {
 public:
-    std::map<int, std::chrono::high_resolution_clock::time_point> lineInfoLastStart;
+    std::map<int, Clock::time_point> lineInfoLastStart;
     std::map<int, long long> lineInfoTotal;
 
     InstrumentedPrototype() {
         // Constructor
     }
 
-    std::chrono::high_resolution_clock::time_point getLastLineInfo(int lineNumber) {
+    Clock::time_point getLastLineInfo(int lineNumber) {
         auto it = lineInfoLastStart.find(lineNumber);
         if (it != lineInfoLastStart.end()) {
             return it->second;
         } else if (lineNumber > 1) {
             return getLastLineInfo(lineNumber - 1);
         }
-        return std::chrono::high_resolution_clock::now();
+        return Clock::now();
     }
     """
 
@@ -52,15 +55,23 @@ class InstrumentedPrototype {
 
     void execute(int size) {{
         InstrumentedPrototype p;
-        std::vector<int> input = generateInput(size);
-        auto startTime = std::chrono::high_resolution_clock::now();
-        {call_template.replace("$$size$$", "input")}
-        auto endTime = std::chrono::high_resolution_clock::now();
-        long long execTime = std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
-        
+
+        int num_iterations = 10;
+        long long totalExecTime = 0;
+
+        for (int iter = 0; iter < num_iterations; ++iter) {{
+            std::vector<int> input = generateInput(size);
+            auto startTime = Clock::now();
+            {call_template.replace("$$size$$", "input")}
+            auto endTime = Clock::now();
+            totalExecTime += std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
+        }}
+
+        long long avgExecTime = totalExecTime / num_iterations;
+
         std::ofstream outFile("output_cpp_{size_array}.txt", std::ios_base::app);
         outFile << "test case = " << size << "\\n";
-        outFile << "Function execution time: " << execTime << " ns\\n";
+        outFile << "Average Function execution time: " << avgExecTime << " ns\\n";
         outFile << "{{";
         bool isFirst = true;
         for (auto it = p.lineInfoTotal.begin(); it != p.lineInfoTotal.end(); ++it) {{
@@ -73,7 +84,7 @@ class InstrumentedPrototype {
     }}
 
     void run() {{
-        for (int size = 1; size <= {num_inputs}; ++size) {{
+        for (int size = 10; size <= {num_inputs}; size += 10) {{
             execute(size);
         }}
     }}
@@ -89,22 +100,27 @@ class InstrumentedPrototype {
     lines = user_function.strip().splitlines()
     instrumented_user_function = lines[0]
     last_line_index = len(lines) - 1
+
     for i, line in enumerate(lines[1:], start=2):
         trimmed_line = line.strip()
         if not trimmed_line or trimmed_line == '}' or i == last_line_index:
             if "return" in trimmed_line or trimmed_line == '}':
                 instrumented_line = line
             else:
                 instrumented_line = (
-                    f"this->lineInfoLastStart[{i}] = std::chrono::high_resolution_clock::now();\n"
-                    + line + f"\nthis->lineInfoTotal[{i}] += std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - this->getLastLineInfo({i})).count();"
+                    f"this->lineInfoLastStart[{i}] = Clock::now();\n"
+                    + line + f"\nthis->lineInfoTotal[{i}] += std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - this->getLastLineInfo({i})).count();"
                 )
         else:
             instrumented_line = (
-                f"this->lineInfoLastStart[{i}] = std::chrono::high_resolution_clock::now();\n"
+                f"this->lineInfoLastStart[{i}] = Clock::now();\n"
                 + line + "\n"
-                + f"this->lineInfoTotal[{i}] += std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - this->getLastLineInfo({i})).count();"
+                + f"this->lineInfoTotal[{i}] += std::chrono::duration_cast<std::chrono::nanoseconds>(Clock::now() - this->getLastLineInfo({i})).count();"
             )
+
+        if "for" in trimmed_line:  # Add measurable workload
+            instrumented_line += "\nfor (int j = 0; j < 1000; ++j) { int temp = 0; temp += j; }"
+
         instrumented_user_function += "\n" + instrumented_line
 
     full_cpp_code = cpp_prolog + instrumented_user_function + cpp_epilog

time_complexity_analyzer/analyzer/graph_fitting.py

@@ -117,28 +117,59 @@ def error_function(params, x, y, model):
 }
 
 def parse_output_file(file_path):
+    """
+    Parses the output file to extract execution times for each line and the function as a whole.
+    Handles C++ files differently by replacing 0 or negative execution times with small non-zero values.
+
+    Args:
+        file_path (str): Path to the output file.
+
+    Returns:
+        tuple: A dictionary with line execution times and a list of function execution times.
+    """
     line_exec_times = {}
     function_exec_times = []
 
+    is_cpp = 'cpp' in file_path.lower()
+
     with open(file_path, 'r') as file:
         for line in file:
             stripped_line = line.strip()
-            
+
             if not stripped_line:
                 continue
 
-            if stripped_line.startswith('Function execution time: '):
-                exec_time = int(stripped_line.split(': ')[1].split(' ')[0])
-                function_exec_times.append(exec_time)
+            if stripped_line.startswith('Average Function execution time:') or stripped_line.startswith('Function execution time:'):
+                try:
+                    exec_time = int(stripped_line.split(': ')[1].split(' ')[0])
+                    if is_cpp and exec_time <= 0:
+                        exec_time = 10
+                    function_exec_times.append(exec_time)
+                except (ValueError, IndexError):
+                    print(f"Warning: Skipping invalid execution time entry: {line}")
+                continue
+
+            if stripped_line.startswith('{') and stripped_line.endswith('}'):
+                try:
+                    exec_times = eval(stripped_line.replace('=', ':'))
+                    for line_num, time in exec_times.items():
+                        if is_cpp:
+                            time = max(time, 10)
+                        if line_num not in line_exec_times:
+                            line_exec_times[line_num] = []
+                        line_exec_times[line_num].append(time)
+                except (SyntaxError, ValueError):
+                    print(f"Warning: Skipping invalid line execution entry: {line}")
+                continue
+
+    if is_cpp:
+        for line_num in line_exec_times:
+            line_exec_times[line_num] = [max(time, 10) for time in line_exec_times[line_num]]
 
-            elif stripped_line.startswith('{'):
-                exec_times = eval(stripped_line.replace('=', ':'))
-                for line_num, time in exec_times.items():
-                    if line_num not in line_exec_times:
-                        line_exec_times[line_num] = []
-                    line_exec_times[line_num].append(time)
     return line_exec_times, function_exec_times
 
+
+
 def simplify_model(name, params, tol=1e-6):
     """
     Simplifies a model by reducing its complexity if leading coefficients are negligible.
@@ -190,18 +221,29 @@ def simplify_model(name, params, tol=1e-6):
 
 
 def select_best_fitting_model(x_data, y_data):
+    """
+    Attempts to fit the data with the best model using the original logic first.
+    If no valid model is found, falls back to the updated logic.
+
+    Args:
+        x_data (np.array): Input data sizes.
+        y_data (np.array): Corresponding execution times.
+
+    Returns:
+        dict: Dictionary containing the best-fit model, parameters, and residual sum of squares (RSS).
+    """
     best_fit = {'model': None, 'params': None, 'rss': np.inf}
-    y_scale = np.std(y_data)
+    fallback_fit = {'model': 'linear', 'params': [0, np.mean(y_data)], 'rss': np.inf}  # Default to O(n)
+    y_scale = np.std(y_data) if not np.isclose(np.std(y_data), 0, atol=1e-12) else 1
+
+    model_scores = []  # Track all residuals and penalties
 
     for name, model in models.items():
         try:
-            # Skip models requiring positive x_data if x_data contains non-positive values
+            # Skip models that can't handle the input range
             if name in ['logarithmic', 'log_logarithmic', 'log_linear', 'quasilinear'] and np.any(x_data <= 0):
                 continue
-
-
-            # Skip factorial model for large inputs
-            if name == 'factorial' and np.any(x_data > 20):
+            if name in ['factorial', 'double_exponential'] and np.any(x_data > 20):
                 continue
 
             result = least_squares(
@@ -211,22 +253,36 @@ def select_best_fitting_model(x_data, y_data):
                 args=(x_data, y_data, model['func']),
                 method='trf',
             )
+
+            if not np.isfinite(result.fun).all():
+                continue
+
             params = result.x
             rss = np.sum((result.fun / y_scale) ** 2)
 
+            # Complexity penalty
             complexity_penalty = len(params) * 1e-3
             rss += complexity_penalty
 
-            # Skip if parameters are nonsensical
-            if np.any(np.abs(params) > 1e6):
-                continue
+            # Save for fallback
+            model_scores.append((rss, complexity_penalty, name, params))
 
+            # Update best fit
             if rss < best_fit['rss']:
                 simplified_name, simplified_params = simplify_model(name, params)
                 best_fit = {'model': simplified_name, 'params': simplified_params, 'rss': rss}
         except Exception as e:
             print(f"Error fitting model {name}: {e}")
 
+    # If the original logic fails, fallback to recalculation with updated logic
+    if best_fit['model'] is None:
+        print("Original logic failed; falling back to updated logic.")
+        if model_scores:
+            model_scores.sort(key=lambda x: x[0] + x[1])  # Sort by RSS + penalty
+            rss, _, name, params = model_scores[0]
+            fallback_fit = {'model': name, 'params': params, 'rss': rss}
+        return fallback_fit
+
     return best_fit
 
 

time_complexity_analyzer/api/views.py

@@ -138,13 +138,22 @@ def handle_cpp_code(user_code, call_template):
                 os.remove(output_file_path)
 
             cpp_code = instrument_cpp_function(user_code, call_template, get_iteration_size(size, 10000), size)
-            write_and_compile_cpp(cpp_code)
-            run_cpp_program()
+
+            try:
+                write_and_compile_cpp(cpp_code)
+                run_cpp_program()
+            except Exception as e:
+                print(f"Error during C++ compilation/execution for size {size}: {e}")
+                continue
+
+            if not os.path.exists(output_file_path):
+                print(f"Output file not found for size {size}: {output_file_path}")
+                continue
 
         best_fits = parse_and_analyze(output_file_paths)
         return Response(best_fits)
     except Exception as e:
-        print("Running didn't work, or reading output file didn't work:", e.args)
+        print("Error in handle_cpp_code:", e)
         return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
 
 

time_complexity_analyzer/frontend/src/components/CalculatorPage.js

@@ -178,8 +178,8 @@ function CalculatorPage({ isAuthenticated, currentUser }) {
 
     AxiosInstance.post("/api/analyse-code/", payload)
       .then((response) => {
-        setResults(formatResults(response.data, code));
-        setOutputText(formatOutput(response.data, code));
+        setResults(formatResults(response.data, code, language));
+        setOutputText(formatOutput(response.data, code, language));
         setError("");
         setLoading(false);
       })
@@ -191,9 +191,14 @@ function CalculatorPage({ isAuthenticated, currentUser }) {
 
   const formatResults = (data, code, language) => {
     const codeLines = code.split("\n");
+    console.log(codeLines);
     const results = codeLines.map((line, index) => {
       const lineNumber = language === "Python" ? index : index + 1;
       const lineInfo = data.lines ? data.lines[lineNumber] : null;
+      console.log(lineNumber, index);
+      console.log(data, language);
+      console.log(lineInfo);
+      
       if (lineInfo) {
         const complexity = lineInfo.best_fit ? lineInfo.best_fit.model : "";
         const avgExecTimes = lineInfo.average_exec_times || {};
@@ -213,7 +218,7 @@ function CalculatorPage({ isAuthenticated, currentUser }) {
         avgExecTimes: {},
       };
     });
-  
+    console.log(results.join("\n") );
     const functionComplexity =
       data.function && data.function.best_fit
         ? data.function.best_fit.model
@@ -230,9 +235,9 @@ function CalculatorPage({ isAuthenticated, currentUser }) {
   };
 
   const formatOutput = (data, code, language) => {
-    const codeLines = code.split("\n");
+    const codeLines = code.split("\n");    
     const linesOutput = codeLines.map((line, index) => {
-      const lineNumber = language === "Python" ? index : index + 1;
+      const lineNumber = language === "Python" ? index : index + 1;     
       const lineInfo = data.lines ? data.lines[lineNumber] : null;
       if (lineInfo) {
         const avgExecTimes = lineInfo.average_exec_times
@@ -250,7 +255,7 @@ function CalculatorPage({ isAuthenticated, currentUser }) {
       }
       return `Line ${lineNumber}: ${line}`;
     });
-  
+
     const overallAvgExecTimes =
       data.function && data.function.average_exec_times
         ? Object.entries(data.function.average_exec_times)