Merge pull request #38 from MATF-Software-Verification/feature/massif-analysis-enhancements

Feature/massif analysis enhancements

Author: sntntn

QT_Massif_App/CMakeLists.txt

@@ -42,6 +42,7 @@ if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
         massifanalyzerthresholds.h massifanalyzerthresholds.cpp
         massifanalyzerthresholdswindow.h massifanalyzerthresholdswindow.cpp massifanalyzerthresholdswindow.ui
 
+
     )
 # Define target properties for Android with Qt 6 as:
 #    set_property(TARGET QT_Massif_App APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR

QT_Massif_App/MassifAnalyzerThresholds.h

@@ -16,7 +16,7 @@ class MassifAnalyzerThresholds : public QObject
     int highAllocationCount = 10;
     qint64 smallTotalAllocation = 5 * 1024 * 1024;         // 5 MB
     double memoryJumpThreshold = 0.5;                      // 50%
-    qint64 largeMemoryThreshold = 1000000000;              // 1 GB
+    qint64 largeMemoryThreshold = 1000 * 1024 * 1024;              // 1 GB
     qint64 memoryFreeThreshold = 4 * 1024;                 // 4 KB
     double fragmentationThreshold = 0.10;                  // 10%
     int stabilizationWindowSize = 3;

QT_Massif_App/Parser.cpp

@@ -32,7 +32,7 @@ std::pair<QMap<QString, QString>, QVector<Snapshot>> Parser::parseMassifFile(con
 
         if (line.trimmed().startsWith("n")) {
             QRegularExpression detailedAllocRegex(R"(n\d+:\s+(\d+)\s+0x[0-9A-Fa-f]+:\s+(.+)\s+\((.+):(\d+)\))");
-            // (npr. "n1: 4000 (heap allocation functions) malloc/new/new[], --alloc-fns, etc.")
+            // (example "n1: 4000 (heap allocation functions) malloc/new/new[], --alloc-fns, etc.")
             QRegularExpression summaryAllocRegex(R"(n\d+:\s+(\d+)\s+\(.+\))");
             static QRegularExpression stdlibFunctionRegex(R"(^(std::|__gnu_cxx::|boost::|__|_Z|_IO_|_dl_|call_init|construct<|operator new|operator delete))");
 
@@ -45,9 +45,6 @@ std::pair<QMap<QString, QString>, QVector<Snapshot>> Parser::parseMassifFile(con
                 entry.sourceFile = match.captured(3);
                 entry.line = match.captured(4).toInt();
 
-                //std::cout << entry.bytes << " bytes, " << entry.function.toStdString()
-                //          << " " << entry.sourceFile.toStdString() << ":" << entry.line << std::endl;
-
                 bool isFromStdLib = stdlibFunctionRegex.match(entry.function).hasMatch();
                 bool hasValidSourceFile = !entry.sourceFile.isEmpty()
                                           && (entry.sourceFile.endsWith(".cpp") || entry.sourceFile.endsWith(".cc")
@@ -67,13 +64,8 @@ std::pair<QMap<QString, QString>, QVector<Snapshot>> Parser::parseMassifFile(con
                 entry.sourceFile = "";
                 entry.line = 0;
 
-                //std::cout << entry.bytes << " bytes, summary allocation line" << std::endl;
-
                 snapshot.allocations.append(entry);
             }
-            else {
-                qDebug() << "Failed to match allocation line:" << line;
-            }
         }
         else if (line.contains(headerRegex, &match)) {
             header[match.captured(1)] = match.captured(2);
@@ -106,8 +98,6 @@ std::pair<QMap<QString, QString>, QVector<Snapshot>> Parser::parseMassifFile(con
 }
 
 
-// this function groups allocations with functions summing the amount of memory allocated in those functions
-// the problem is right now we have every function mentioned, and in more complex programs that will include STL etc..
 QMap<QString, FunctionAllocSummary> Parser::summarizeAllocationsByFunction(const QVector<Snapshot>& snapshots) {
     QMap<QString, FunctionAllocSummary> functionTotals;
 

QT_Massif_App/mainwindow.cpp

@@ -3,6 +3,7 @@
 #include "./ui_mainwindow.h"
 #include <QDir>
 #include <QStyle>
+#include <QSystemTrayIcon>
 
 MainWindow::MainWindow(QWidget *parent)
     : QMainWindow(parent)
@@ -13,6 +14,15 @@ MainWindow::MainWindow(QWidget *parent)
 {
     ui->setupUi(this);
     ui->btMassifOptions->setToolTip("Configure Massif settings");
+    ui->btMassifAnalyzerParameters->setToolTip("Configure thresholds for report analysis");
+    setWindowIcon(QApplication::style()->standardIcon(QStyle::SP_DriveNetIcon));
+    QSystemTrayIcon *trayIcon = new QSystemTrayIcon(this);
+    QIcon icon = QApplication::style()->standardIcon(QStyle::SP_DriveNetIcon);
+    trayIcon->setIcon(icon);
+    trayIcon->show();
+
+    this->setWindowFlags(windowFlags() & ~Qt::WindowMaximizeButtonHint);
+    this->setFixedSize(this->size());
 }
 
 MainWindow::~MainWindow()
@@ -24,15 +34,6 @@ void MainWindow::on_btLoadFile_clicked()
 {
     fileSelector->selectFile(this, mode);
 
-    // Just for debugging
-    //QMessageBox msgBox;
-    // msgBox.setText(massifRunner->getFileName() +
-    //                "\n with path \n" + massifRunner->getFilePath() +
-    //                "\n " + massifRunner->getProgram() +
-    //                "\n " + massifRunner->convertWindowsPathToWsl(massifRunner->getFilePath()) +
-    //                "\n " + massifRunner->convertWindowsPathToWsl(massifRunner->getMassifFilesDir()));
-    // msgBox.exec();
-
     this->ui->leFileName->setText(fileSelector->getFileName());
 }
 
@@ -71,6 +72,7 @@ void MainWindow::on_btExecute_clicked()
 void MainWindow::on_btMassifOptions_clicked()
 {
     MassifOptionsWindow massifOptionsWindow;
+    massifOptionsWindow.setOptionsFields(massifRunner->getOptions());
 
     QObject::connect(&massifOptionsWindow, &MassifOptionsWindow::optionsChanged, this, &MainWindow::setMassifOptions);
 

QT_Massif_App/mainwindow.ui

@@ -11,7 +11,7 @@
    </rect>
   </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>2024_Research_Massif_Check</string>
   </property>
   <widget class="QWidget" name="centralwidget">
    <widget class="QPushButton" name="btLoadFile">

QT_Massif_App/massifanalyzer.cpp

@@ -60,16 +60,16 @@ QString MassifAnalyzer::detectMemoryLeaks(const QVector<Snapshot>& snapshots, Ma
             }
 
             if (heapJump >= MEMORY_JUMP_THRESHOLD) {
-                result += QString("Info: Heap memory jump between snapshot %1 and snapshot %2 is %3%\n")
+                result += QString("ℹ️ [Info] Heap memory jump between snapshot %1 and snapshot %2 is %3%\n")
                     .arg(previousSnapshot.snapshot)
                     .arg(snap.snapshot)
                     .arg(heapJump * 100, 0, 'f', 2);
 
                 if (isMemoryStabilized(snapshots, i, WINDOWS_SIZE_TRESHOLD)) {
-                    result += QString("Note: Memory stabilized after snapshot %1\n")
+                    result += QString("📝 [Note] Memory stabilized after snapshot %1\n")
                         .arg(snap.snapshot);
                 } else {
-                    result += QString("Warning: Memory continues to grow after snapshot %1\n")
+                    result += QString("⚠️ [Warning] Memory continues to grow after snapshot %1\n")
                         .arg(snap.snapshot);
                 }
             }
@@ -86,21 +86,21 @@ QString MassifAnalyzer::detectMemoryLeaks(const QVector<Snapshot>& snapshots, Ma
             }
 
             if (stackJump > MEMORY_JUMP_THRESHOLD) {
-                result += QString("Info: Stack memory jump between snapshot %1 and snapshot %2 is %3%\n")
+                result += QString("ℹ️ [Info] Stack memory jump between snapshot %1 and snapshot %2 is %3%\n")
                     .arg(previousSnapshot.snapshot)
                     .arg(snap.snapshot)
                     .arg(stackJump * 100, 0, 'f', 2);
             }
         }
 
         if (snap.mem_heap_B > LARGE_MEMORY_THRESHOLD) {
-            result += QString("Warning: Large heap memory detected in snapshot %1: %2 MB\n")
+            result += QString("⚠️ [Warning] Large heap memory detected in snapshot %1: %2 MB\n")
                 .arg(snap.snapshot)
                 .arg(snap.mem_heap_B / BYTES_TO_MB);
         }
 
         if (snap.mem_stacks_B > LARGE_MEMORY_THRESHOLD) {
-            result += QString("Warning: Large stack memory detected in snapshot %1: %2 MB\n")
+            result += QString("⚠️ [Warning] Large stack memory detected in snapshot %1: %2 MB\n")
                 .arg(snap.snapshot)
                 .arg(snap.mem_stacks_B / BYTES_TO_MB);
         }
@@ -111,35 +111,24 @@ QString MassifAnalyzer::detectMemoryLeaks(const QVector<Snapshot>& snapshots, Ma
             hasPreviousSnapshot = true;
         }
 
-        if (snap.mem_heap_B > 0) { // da ne deliš sa nulom
+        if (snap.mem_heap_B > 0) { // not to divide with 0
             double fragmentationRatio = static_cast<double>(snap.mem_heap_extra_B) / snap.mem_heap_B;
 
             if (fragmentationRatio > FRAGMENTATION_THRESHOLD) {
-                result += QString("Warning: Possible heap fragmentation in snapshot %1: extra memory is %2% of heap\n")
+                result += QString("⚠️ [Warning] Possible heap fragmentation in snapshot %1: extra memory is %2% of heap\n")
                     .arg(snap.snapshot)
                     .arg(fragmentationRatio * 100, 0, 'f', 2);
             }
         }
 
         if (i == snapshots.size() - 1){
             if (snap.mem_heap_B > MEMORY_FREE_THRESHOLD) {
-                result += QString("Warning: Memory not fully freed at the end! Heap usage: %1 bytes\n")
+                result += QString("⚠️ [Warning] Memory not fully freed at the end! Heap usage: %1 bytes\n")
                     .arg(snap.mem_heap_B);
             } else {
-                result += QString("Info: Memory fully freed at the end.\n");
+                result += QString("ℹ️ [Info] Memory fully freed at the end.\n");
             }
         }
-
-        // if (!snap.allocations.isEmpty()) {
-        //     result += QString("Top allocations in snapshot %1\n").arg(snap.snapshot);
-        //     for (const AllocationEntry& alloc : snap.allocations) {
-        //         result += QString("%1 bytes in %2 at %3 : %4\n")
-        //                       .arg(alloc.bytes)
-        //                       .arg(alloc.function)
-        //                       .arg(alloc.sourceFile)
-        //                       .arg(alloc.line);
-        //     }
-        // }
     }
 
     return result;
@@ -155,24 +144,24 @@ QString MassifAnalyzer::generateFunctionAllocationReport(const QMap<QString, Fun
     for (auto it = functionSummary.constBegin(); it != functionSummary.constEnd(); ++it) {
         const FunctionAllocSummary& summary = it.value();
 
-        result += QString("Function '%1' allocated total %2 bytes in %3 allocations.\n")
+        result += QString("📌 [Function] \n  ℹ️ [Info] Function '%1' allocated total %2 bytes in %3 allocations.\n")
                       .arg(summary.function)
                       .arg(summary.totalBytes)
                       .arg(summary.count);
 
         // Warn if a function allocates a lot of memory
         if (summary.totalBytes > HIGH_MEMORY_THRESHOLD) {
-            result += QString("Warning: Function '%1' is responsible for a large memory allocation (over 100MB).\n")
+            result += QString("  ⚠️ [Warning] Function '%1' is responsible for a large memory allocation (over 100MB).\n")
                 .arg(summary.function);
         }
 
         if (summary.count > HIGH_ALLOCATION_COUNT) {
             if (summary.totalBytes < SMALL_TOTAL_ALLOCATION) {
-                result += QString("Note: Function '%1' performs many small allocations (%2); consider optimizing with preallocation or pooling.\n")
+                result += QString("  📝 [Note] Function '%1' performs many small allocations (%2); consider optimizing with preallocation or pooling.\n")
                     .arg(summary.function)
                     .arg(summary.count);
             } else {
-                result += QString("Note: Function '%1' performs many allocations (%2); consider checking for inefficiencies.\n")
+                result += QString("  📝 [Note] Function '%1' performs many allocations (%2); consider checking for inefficiencies.\n")
                     .arg(summary.function)
                     .arg(summary.count);
             }
@@ -181,5 +170,11 @@ QString MassifAnalyzer::generateFunctionAllocationReport(const QMap<QString, Fun
         result += "\n";
     }
 
+    result += "📝 [Note] Lines are ignored if:\n"
+              "  - They refer to unnamed or unknown functions.\n"
+              "  - Their memory allocation is below a configured threshold (default: 1.00% of total memory).\n"
+              "  - They are structurally malformed or unsupported by the current parser.\n"
+              "  - They match known standard library or internal functions (e.g., `std::`, `__gnu_cxx::`, `boost::`, `operator new`, etc.).";
+
     return result;
 }

QT_Massif_App/massifanalyzerthresholdswindow.cpp

@@ -6,6 +6,37 @@ MassifAnalyzerThresholdsWindow::MassifAnalyzerThresholdsWindow(QWidget *parent)
     , ui(new Ui::MassifAnalyzerThresholdsWindow)
 {
     ui->setupUi(this);
+    QPixmap pixmap = QApplication::style()->standardIcon(QStyle::SP_MessageBoxInformation).pixmap(16, 16);
+    ui->lbHighMemoryThresholdHelp->setPixmap(pixmap);
+    ui->lbHighMemoryThresholdHelp->setToolTip("The minimum size (in MB) of a single allocation that is considered 'large'."
+                                              " Used to detect unusually big memory blocks.");
+
+    ui->lbHighAllocationCountHelp->setPixmap(pixmap);
+    ui->lbHighAllocationCountHelp->setToolTip("The number of individual allocations above which a function or test is flagged as 'frequently allocating'."
+                                              " Helps spot allocation-heavy code.");
+
+    ui->lbSmallTotalAllocationHelp->setPixmap(pixmap);
+    ui->lbSmallTotalAllocationHelp->setToolTip("Total allocated memory (in MB) below which a test is considered memory-light. Useful for skipping trivial tests.");
+
+    ui->lbMemoryJumpThresholdHelp->setPixmap(pixmap);
+    ui->lbMemoryJumpThresholdHelp->setToolTip("The minimum percentage increase between two snapshots required to flag a sudden memory usage spike."
+                                              " Expressed as a percentage.");
+
+    ui->lbLargeMemoryThresholdHelp->setPixmap(pixmap);
+    ui->lbLargeMemoryThresholdHelp->setToolTip("Defines what is considered extremely large memory usage overall (in MB)."
+                                               " Helps filter out heavy tests or data-heavy functions.");
+
+    ui->lbMemoryFreeThresholdHelp->setPixmap(pixmap);
+    ui->lbMemoryFreeThresholdHelp->setToolTip("The minimum drop in memory (in KB) between snapshots that indicates a significant deallocation event.");
+
+    ui->lbFragmentationThresholdHelp->setPixmap(pixmap);
+    ui->lbFragmentationThresholdHelp->setToolTip("The ratio of extra heap memory (unused but reserved) to actual used heap memory,"
+                                                 " above which fragmentation is suspected. Expressed as a percentage.");
+
+    ui->lbStabilizationSensitivityHelp->setPixmap(pixmap);
+    ui->lbStabilizationSensitivityHelp->setToolTip("Number of consecutive snapshots to check after a detected memory jump to confirm if heap memory usage has stabilized.");
+
+    this->setFixedSize(this->size());
 }
 
 void MassifAnalyzerThresholdsWindow::setThresholdsFields(MassifAnalyzerThresholds *thresholds)

QT_Massif_App/massifanalyzerthresholdswindow.h

@@ -2,6 +2,7 @@
 #define MASSIFANALYZERTHRESHOLDSWINDOW_H
 
 #include <QDialog>
+#include <QStyle>
 #include "massifanalyzerthresholds.h"
 
 namespace Ui {