GUI: Parallelized project compilation using QThread

- Refactored the compilation logic to utilize QThread for parallel execution.
- Added a Compiler class to handle individual project compilation in separate threads.
- Ensured that previous compilation processes are terminated before starting new ones.
- Handled shell script and CMake project compilation with proper error logging.
- Improved performance by running multiple compilation tasks concurrently.

Author: DvoraNovogrotzki

gui/CMakeLists.txt

@@ -22,7 +22,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
 # Find the Qt5 library
-find_package(Qt5 REQUIRED COMPONENTS Widgets Core Gui Test)
+find_package(Qt5 REQUIRED COMPONENTS Concurrent Widgets Core Gui Test)
 
 # Find the BSON library using pkg-config
 find_package(PkgConfig REQUIRED)
@@ -37,6 +37,7 @@ add_library(VehicleComputingSimulatorLib
     src/simulation_state_manager.cpp
     src/log_handler.cpp
     src/frames.cpp
+    src/compiler.cpp
     ../logger/logger.cpp
 )
 
@@ -48,6 +49,7 @@ target_sources(VehicleComputingSimulatorLib PRIVATE
     include/simulation_state_manager.h
     include/log_handler.h
     include/frames.h
+    include/compiler.h
     ../logger/logger.h
 )
 
@@ -59,7 +61,7 @@ target_include_directories(VehicleComputingSimulatorLib PRIVATE
 )
 
 # Link the BSON library and Qt5 components to the library
-target_link_libraries(VehicleComputingSimulatorLib PRIVATE ${BSON_LIBRARIES} Qt5::Core Qt5::Gui Qt5::Widgets)
+target_link_libraries(VehicleComputingSimulatorLib PRIVATE ${BSON_LIBRARIES} Qt5::Core Qt5::Gui Qt5::Widgets Qt5::Concurrent)
 
 # Create the main executable
 add_executable(VehicleComputingSimulator src/main.cpp)

gui/include/compiler.h

@@ -0,0 +1,28 @@
+#ifndef COMPILER_H
+#define COMPILER_H
+
+#include <QThread>
+#include <QFile>
+#include <QProcess>
+#include <QDir>
+#include <QStringList>
+#include <QString>
+
+class Compiler : public QThread {
+    Q_OBJECT
+public:
+    Compiler(QString cmakePath, bool *compileSuccessful,
+             QObject *parent = nullptr);
+
+protected:
+    void run() override;
+
+signals:
+    void logMessage(const QString &message);
+
+private:
+    QString cmakePath;
+    bool *compileSuccessful;
+};
+
+#endif  // COMPILER_H

gui/src/compiler.cpp

@@ -0,0 +1,71 @@
+#include "compiler.h"
+
+Compiler::Compiler(QString cmakePath, bool *compileSuccessful, QObject *parent)
+    : QThread(parent),
+      cmakePath(cmakePath),
+      compileSuccessful(compileSuccessful)
+{
+}
+
+void Compiler::run()
+{
+    if (cmakePath.endsWith(".sh")) {  // Handle shell script compilation
+        QFile scriptFile(cmakePath);
+        if (!scriptFile.exists()) {
+            emit logMessage("Shell script file does not exist: " + cmakePath);
+            *compileSuccessful = false;
+            return;
+        }
+
+        // Make shell script executable if needed
+        if ((scriptFile.permissions() & QFileDevice::ExeUser) == 0) {
+            QProcess makeExecutableProcess;
+            makeExecutableProcess.start("chmod", QStringList()
+                                                     << "+x" << cmakePath);
+            if (!makeExecutableProcess.waitForFinished()) {
+                *compileSuccessful = false;
+                return;
+            }
+        }
+
+        QProcess scriptProcess;
+        scriptProcess.start("bash", QStringList() << cmakePath);
+        scriptProcess.waitForFinished();
+    }
+    else {  // Handle CMake compilation
+        QDir cmakeDir =
+            QFileInfo(cmakePath)
+                .absolutePath();  // Get the directory of CMakeLists.txt
+        QString buildDirPath = cmakeDir.absoluteFilePath("build");
+        QDir buildDir(buildDirPath);
+
+        // Create build directory if it doesn't exist
+        if (!buildDir.exists() && !buildDir.mkpath(".")) {
+            emit logMessage("Failed to create build directory " + buildDirPath);
+            *compileSuccessful = false;
+            return;
+        }
+
+        QProcess cmakeProcess;
+        cmakeProcess.setWorkingDirectory(buildDirPath);
+        cmakeProcess.start(
+            "cmake",
+            QStringList()
+                << cmakeDir.absolutePath());  // Use project dir, not just ".."
+
+        if (!cmakeProcess.waitForFinished()) {
+            emit logMessage("Failed to run cmake in " + buildDirPath);
+            *compileSuccessful = false;
+            return;
+        }
+
+        QProcess makeProcess;
+        makeProcess.setWorkingDirectory(buildDirPath);
+        makeProcess.start("make", QStringList());
+
+        if (!makeProcess.waitForFinished()) {
+            emit logMessage("Failed to compile in " + buildDirPath);
+            *compileSuccessful = false;
+        }
+    }
+}

gui/src/main_window.cpp

@@ -11,6 +11,7 @@
 #include "process_dialog.h"
 #include "frames.h"
 #include "log_handler.h"
+#include "compiler.h"
 
 int sizeSquare = 120;
 int rotationTimerIntervals = 100;
@@ -562,167 +563,32 @@ void MainWindow::compileProjects()
     runningProcesses.clear();
     bool compileSuccessful = true;  // Track if all compilations succeed
 
+    QList<QThread *> threads;
+
+    QSet<QString> uniquePaths;  // Set to hold unique paths
     for (DraggableSquare *square : squares) {
         QString executionFilePath = square->getProcess()->getExecutionFile();
-        QFileInfo fileInfo(executionFilePath);
-        QString directoryPath = fileInfo.absolutePath();
-
-        if (executionFilePath.endsWith(".sh")) {
-            // Shell script processing
-            QFile scriptFile(executionFilePath);
-            if (!scriptFile.exists()) {
-                guiLogger.logMessage(logger::LogLevel::ERROR,
-                                     "Shell script file does not exist: " +
-                                         executionFilePath.toStdString());
-
-                logOutput->append("Shell script file does not exist: " +
-                                  executionFilePath);
-                compileSuccessful = false;
-                continue;
-            }
-
-            if ((scriptFile.permissions() & QFileDevice::ExeUser) == 0) {
-                // Make the script executable
-                QProcess makeExecutableProcess;
-                makeExecutableProcess.start("chmod", QStringList()
-                                                         << "+x" << executionFilePath);
-                if (!makeExecutableProcess.waitForFinished()) {
-                    logOutput->append("Failed to make the script executable: " +
-                                      executionFilePath);
-                    compileSuccessful = false;
-                    continue;
-                }
-                guiLogger.logMessage(
-                    logger::LogLevel::INFO,
-                    "Script is now executable: " + executionFilePath.toStdString());
-                logOutput->append("Script is now executable: " + executionFilePath);
-            }
-
-            // Run the shell script
-            QProcess *scriptProcess = new QProcess(this);
-            scriptProcess->start("bash", QStringList() << executionFilePath);
-            connect(
-                scriptProcess,
-                QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
-                this, &MainWindow::processFinished);
-            connect(
-                scriptProcess, &QProcess::readyReadStandardOutput,
-                [this, scriptProcess]() {
-                    logOutput->append(scriptProcess->readAllStandardOutput());
-                });
-            connect(
-                scriptProcess, &QProcess::readyReadStandardError,
-                [this, scriptProcess]() {
-                    logOutput->append(scriptProcess->readAllStandardError());
-                });
-        }
-        else {
-            guiLogger.logMessage(logger::LogLevel::INFO,
-                                 "Compiling " + executionFilePath.toStdString());
-
-            // CMake project processing
-            logOutput->append("Compiling " + executionFilePath);
-            QString buildDirPath = QDir(directoryPath).absoluteFilePath("build");
-            QDir buildDir(buildDirPath);
+        uniquePaths.insert(executionFilePath);
+    }
 
-            if (buildDir.exists()) {
-                QFileInfoList fileList = buildDir.entryInfoList(
-                    QDir::NoDotAndDotDot | QDir::AllEntries);
-                foreach (const QFileInfo &fileInfo, fileList) {
-                    if (fileInfo.isDir()) {
-                        QDir dir(fileInfo.absoluteFilePath());
-                        if (!dir.removeRecursively()) {
-                            guiLogger.logMessage(
-                                logger::LogLevel::ERROR,
-                                "Failed to remove directory: " +
-                                    fileInfo.absoluteFilePath().toStdString());
-
-                            logOutput->append("Failed to remove directory: " +
-                                              fileInfo.absoluteFilePath());
-                            compileSuccessful = false;
-                            continue;
-                        }
-                    }
-                    else {
-                        if (!QFile::remove(fileInfo.absoluteFilePath())) {
-                            guiLogger.logMessage(
-                                logger::LogLevel::ERROR,
-                                "Failed to remove file: " +
-                                    fileInfo.absoluteFilePath().toStdString());
-                            logOutput->append("Failed to remove file: " +
-                                              fileInfo.absoluteFilePath());
-                            compileSuccessful = false;
-                            continue;
-                        }
-                    }
-                }
-            }
-            else {
-                // Create the build directory
-                if (!buildDir.mkpath(".")) {
+    for (QString executionFilePath : uniquePaths) {
+        Compiler *compiler =
+            new Compiler(executionFilePath, &compileSuccessful, this);
+        connect(compiler, &Compiler::logMessage, this,
+                [this](const QString &message) {
                     guiLogger.logMessage(logger::LogLevel::ERROR,
-                                         "Failed to create build directory " +
-                                             buildDirPath.toStdString());
-                    logOutput->append("Failed to create build directory " +
-                                      buildDirPath);
-                    compileSuccessful = false;
-                    continue;
-                }
-            }
-
-            // Run CMake
-            QProcess *cmakeProcess = new QProcess(this);
-            cmakeProcess->setWorkingDirectory(buildDirPath);
-            cmakeProcess->start("cmake", QStringList() << "..");
-            connect(
-                cmakeProcess,
-                QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
-                this, &MainWindow::processFinished);
-
-            if (!cmakeProcess->waitForFinished()) {
-                guiLogger.logMessage(
-                    logger::LogLevel::ERROR,
-                    "Failed to run cmake in " + buildDirPath.toStdString());
-                logOutput->append("Failed to run cmake in " + buildDirPath);
-                logOutput->append(cmakeProcess->readAllStandardError());
-                delete cmakeProcess;
-                compileSuccessful = false;
-                continue;
-            }
-            logOutput->append(cmakeProcess->readAllStandardOutput());
-            logOutput->append(cmakeProcess->readAllStandardError());
-            delete cmakeProcess;
-
-            // Run make
-            QProcess *makeProcess = new QProcess(this);
-            makeProcess->setWorkingDirectory(buildDirPath);
-            makeProcess->start("make", QStringList());
-            connect(
-                makeProcess,
-                QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished),
-                this, &MainWindow::processFinished);
+                                         message.toStdString());
+                });
+        compiler->start();
+        threads.append(compiler);
+    }
 
-            if (!makeProcess->waitForFinished()) {
-                guiLogger.logMessage(
-                    logger::LogLevel::ERROR,
-                    "Failed to compile in " + buildDirPath.toStdString());
-                logOutput->append("Failed to compile in " + buildDirPath);
-                logOutput->append(makeProcess->readAllStandardError());
-                delete makeProcess;
-                compileSuccessful = false;
-                continue;
-            }
-            logOutput->append(makeProcess->readAllStandardOutput());
-            logOutput->append(makeProcess->readAllStandardError());
-            guiLogger.logMessage(
-                logger::LogLevel::INFO,
-                "Successfully compiled " + buildDirPath.toStdString());
-            logOutput->append("Successfully compiled " + buildDirPath);
-            delete makeProcess;
-        }
+    // Wait for all threads to finish
+    for (QThread *thread : threads) {
+        thread->wait();
+        delete thread;  // Clean up threads after completion
     }
 
-    // Enable the run button only if the compilation was successful
     if (compileSuccessful) {
         runButton->setEnabled(true);
         logOutput->append(
@@ -743,7 +609,6 @@ void MainWindow::runProjects()
         QString executionFilePath = square->getProcess()->getExecutionFile();
 
         if (executionFilePath.endsWith(".sh")) {
-            // Run the shell script
             QProcess *scriptProcess = new QProcess(this);
             scriptProcess->start("bash", QStringList() << executionFilePath);
             connect(
@@ -758,13 +623,15 @@ void MainWindow::runProjects()
                 });
         }
         else {
-            // Run the compiled program
-            QDir cmakeDir = QFileInfo(executionFilePath).absoluteDir();
-            QString buildDirPath = cmakeDir.absoluteFilePath("build");
+            QDir cmakeDir(
+                QFileInfo(executionFilePath)
+                    .absolutePath());  // Get the directory containing CMakeLists.txt
+            QString buildDirPath = cmakeDir.absoluteFilePath(
+                "build");  // Updated build directory outside the source
+            QDir buildDir(buildDirPath);
 
-            if (!QDir(buildDirPath).exists()) {
-                // Create the build directory if it does not exist
-                if (!cmakeDir.mkpath(buildDirPath)) {
+            if (!buildDir.exists()) {
+                if (!buildDir.mkpath(buildDirPath)) {
                     guiLogger.logMessage(logger::LogLevel::ERROR,
                                          "Failed to create build directory: " +
                                              buildDirPath.toStdString());
@@ -774,12 +641,10 @@ void MainWindow::runProjects()
                 }
             }
 
-            QDir buildDir(buildDirPath);
             QString exeFile = getExecutableName(buildDirPath);
             QString executablePath = buildDir.absoluteFilePath(exeFile);
             QProcess *runProcess = new QProcess(this);
             runProcess->setWorkingDirectory(buildDirPath);
-
             connect(runProcess, &QProcess::readyReadStandardOutput,
                     [this, runProcess]() {
                         logOutput->append(runProcess->readAllStandardOutput());