Initial Codebase Commit

BC100Dev · BC100Dev · commit 9f7cacafceac · 2025-03-14T16:09:27.000+01:00
diff --git a/CM_Config/LibraryHandler.cmake b/CM_Config/LibraryHandler.cmake
@@ -0,0 +1,5 @@
+find_package(PkgConfig REQUIRED)
+
+pkg_check_modules(LIBPCI REQUIRED libpci)
+include_directories(${LIBPCI_INCLUDE_DIRS})
+link_directories(${LIBPCI_LIBRARY_DIRS})
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,5 +1,5 @@
-cmake_minimum_required(VERSION 3.29)
-project(CppTemplate)
+cmake_minimum_required(VERSION 3.25)
+project(RunAsGPU)
 
 set(CMAKE_CXX_STANDARD 20)
 
diff --git a/Include/ProjectName/MainModule/ModuleHead.hpp b/Include/ProjectName/MainModule/ModuleHead.hpp
diff --git a/Include/RunAsGPU/Shared/GraphicalUnit.hpp b/Include/RunAsGPU/Shared/GraphicalUnit.hpp
@@ -0,0 +1,27 @@
+#ifndef RUNASGPU_GRAPHICALUNIT_HPP
+#define RUNASGPU_GRAPHICALUNIT_HPP
+
+#include <string>
+
+enum GraphicalUnitConnector {
+    // The specific GPU is powered by the internal graphical processing unit (iGPU)
+    // through the CPU
+    INTERNAL = 0,
+
+    // The specific GPU is powered by its own dedicated graphical processing unit (dGPU)
+    DEDICATED = 1,
+
+    // The specific GPU is connected via USB-C (most likely Thunderbolt)
+    EXTERNAL = 2
+};
+
+struct GraphicalUnit {
+    int vendor;
+    int product;
+    std::string vendorName;
+    std::string productName;
+    std::string fullName;
+    GraphicalUnitConnector connector;
+};
+
+#endif //RUNASGPU_GRAPHICALUNIT_HPP
diff --git a/Include/RunAsGPU/Shared/HelpPage.hpp b/Include/RunAsGPU/Shared/HelpPage.hpp
@@ -0,0 +1,46 @@
+#ifndef RUNASGPU_HELPPAGE_HPP
+#define RUNASGPU_HELPPAGE_HPP
+
+#ifndef ABOAWT_HELPPAGE_H
+#define ABOAWT_HELPPAGE_H
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+class HelpPage {
+private:
+    struct Item {
+        std::string arg;
+        std::string equalDesc;
+        std::string description;
+
+        Item(std::string& a, std::string& e, std::string& d);
+    };
+
+    int spaceWidth, startSpaceWidth;
+    std::vector<Item> argItemList;
+    std::string descSep = "=";
+
+public:
+    HelpPage();
+
+    void setSpaceWidth(int width);
+    [[nodiscard]] int getSpaceWidth() const;
+
+    void setStartSpaceWidth(int width);
+    [[nodiscard]] int getStartSpaceWidth() const;
+
+    void setDescSeparator(const std::string& sep);
+    [[nodiscard]] std::string getDescSeparator() const;
+
+    void addArg(std::string arg, std::string assignableDesc, std::string description);
+    [[nodiscard]] std::string display() const;
+    void display(std::ostream& os) const;
+
+    void free();
+};
+
+#endif //ABOAWT_HELPPAGE_H
+
+#endif //RUNASGPU_HELPPAGE_HPP
diff --git a/Include/RunAsGPU/Shared/Runner.hpp b/Include/RunAsGPU/Shared/Runner.hpp
@@ -0,0 +1,17 @@
+#ifndef RUNASGPU_RUNNER_HPP
+#define RUNASGPU_RUNNER_HPP
+
+#include <RunAsGPU/Shared/GraphicalUnit.hpp>
+
+#include <vector>
+#include <map>
+
+namespace Runner {
+
+    std::vector<GraphicalUnit> ListGraphicalUnits();
+
+    void RunApplication(const GraphicalUnit& unit, const std::string& bin, const std::vector<std::string>& args, const std::map<std::string, std::string>& env_map);
+
+}
+
+#endif //RUNASGPU_RUNNER_HPP
diff --git a/Include/RunAsGPU/Shared/Shared.hpp b/Include/RunAsGPU/Shared/Shared.hpp
@@ -0,0 +1,8 @@
+#ifndef RUNASGPU_SHARED_HPP
+#define RUNASGPU_SHARED_HPP
+
+#include <filesystem>
+
+std::filesystem::path GetExecutablePath();
+
+#endif //RUNASGPU_SHARED_HPP
diff --git a/Sources/AppCLI/MainCLI.cpp b/Sources/AppCLI/MainCLI.cpp
@@ -0,0 +1,77 @@
+#include <iostream>
+
+#include <RunAsGPU/Shared/Shared.hpp>
+#include <RunAsGPU/Shared/HelpPage.hpp>
+#include <RunAsGPU/Shared/Runner.hpp>
+
+namespace fs = std::filesystem;
+
+void list() {
+    std::vector<GraphicalUnit> gpu_list = Runner::ListGraphicalUnits();
+    for (int i = 0; i < gpu_list.size(); i++) {
+        const GraphicalUnit& unit = gpu_list[i];
+
+        std::cout << "GPU - " << unit.vendorName << " (" << std::hex << unit.vendor << ")\n";
+        std::cout << "\tName = " << unit.productName << " (" << std::hex << unit.product << ")\n";
+        std::cout << "\tID = " << i << "\n";
+        std::cout << "\tConnector = ";
+
+        switch (unit.connector) {
+            case EXTERNAL:
+                std::cout << "External Graphics Card" << std::endl;
+                break;
+            case INTERNAL:
+                std::cout << "Internal GPU" << std::endl;
+                break;
+            case DEDICATED:
+                std::cout << "Dedicated GPU" << std::endl;
+                break;
+        }
+
+        if (i != gpu_list.size() - 1)
+            std::cout << std::endl;
+    }
+}
+
+int main(int argc, char **argv) {
+    if (argc == 1 || (argc == 2 && (std::string(argv[1]) == "--help" || std::string(argv[1]) == "-h"))) {
+        std::string fn = GetExecutablePath().filename().string();
+
+        std::cout << "RunAsGPU v1.0" << std::endl;
+        std::cout << "usage: ./" << fn << " [action] [options] [exec [..args]]" << std::endl << std::endl;
+        std::cout << "actions:" << std::endl;
+
+        HelpPage actions;
+        actions.setStartSpaceWidth(4);
+        actions.setDescSeparator(" ");
+        actions.addArg("run", "", "Run an executable");
+        actions.addArg("list", "", "List all active GPUs");
+        actions.display(std::cout);
+
+        std::cout << std::endl;
+        std::cout << "options:" << std::endl;
+
+        HelpPage options;
+        options.setStartSpaceWidth(4);
+        options.setSpaceWidth(3);
+        options.setDescSeparator("=");
+        options.addArg("-ui  | --unit-id", "ID", "Select a specific GPU by its given ID");
+        options.addArg("-fu  | --find-unit", "[GPU]", "Find a GPU by its identification (Vendor ID, Device / Product ID, Name)");
+        options.addArg("-fnu | --find-unit-name", "[Name]", "Find a GPU by the name");
+        options.addArg("-fvu | --find-unit-vendor", "[Vendor]", "Find a GPU by the name or ID of the Vendor (e.g. NVIDIA)");
+        options.addArg("-fpu | --find-unit-product", "[Product]", "Find a GPU by the name or ID of the Product (e.g. GeForce 6800 XT)");
+        options.addArg("-ni  | --non-interactive", "", "Will not prompt for GPU selection (e.g. running as a script)");
+        options.display(std::cout);
+
+        return 0;
+    }
+
+    std::vector<std::string> args;
+    std::string action = argv[1];
+    if (action == "list") {
+        list();
+        return 0;
+    }
+
+    return 0;
+}
diff --git a/Sources/AppCLI/SourceInfo.cmake b/Sources/AppCLI/SourceInfo.cmake
@@ -0,0 +1,4 @@
+CollectSources(${PROJECT_MODULE_ROOT} ModSources)
+
+add_executable(RunAsGPU-CLI ${ModSources})
+target_link_libraries(RunAsGPU-CLI PRIVATE ${LIBPCI_LIBRARIES} RunAsGPU-shared)
diff --git a/Sources/AppShared/Detect.cpp b/Sources/AppShared/Detect.cpp
@@ -0,0 +1,74 @@
+#include <RunAsGPU/Shared/GraphicalUnit.hpp>
+#include <RunAsGPU/Shared/Runner.hpp>
+
+#include <iostream>
+#include <string>
+#include <cstring>
+#include <fstream>
+
+extern "C" {
+#include <pci/pci.h>
+}
+
+namespace Runner {
+
+    std::vector<GraphicalUnit> ListGraphicalUnits() {
+        std::vector<GraphicalUnit> gpu_units;
+
+        struct pci_access *pacc;
+        struct pci_dev *dev;
+        char vendor_name[1024], device_name[2048];
+
+        pacc = pci_alloc();
+        if (!pacc) {
+            std::cerr << "Failed to allocate pci_alloc" << std::endl;
+            return gpu_units;
+        }
+
+        pci_init(pacc);
+        pci_scan_bus(pacc);
+
+        for (dev = pacc->devices; dev; dev = dev->next) {
+            pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_CLASS);
+
+            // 0x03?? = Display Controllers
+            // 0x0300 = VGA compatible controller
+            // 0x0301 = XGA compatible controller (old, no longer used)
+            // 0x0302 = 3D controller
+            // 0x0380 = Display Controller
+            if (dev->device_class != 0x0300 && dev->device_class != 0x0301 && dev->device_class != 0x0302 && dev->device_class != 0x0380)
+                continue;
+
+            pci_lookup_name(pacc, vendor_name, sizeof(vendor_name), PCI_LOOKUP_VENDOR, dev->vendor_id);
+            pci_lookup_name(pacc, device_name, sizeof(device_name), PCI_LOOKUP_DEVICE, dev->vendor_id, dev->device_id);
+
+            GraphicalUnitConnector connector;
+
+            bool is_igpu = dev->vendor_id == 0x8086 || (dev->vendor_id == 0x1002 && dev->device_id < 0x6800);
+            bool is_dgpu = dev->bus >= 1;
+
+            if (is_igpu)
+                connector = INTERNAL;
+            else if (is_dgpu)
+                connector = DEDICATED;
+            else
+                connector = EXTERNAL;
+
+            GraphicalUnit gpu{
+                    .vendor = dev->vendor_id,
+                    .product = dev->device_id,
+                    .vendorName = std::string(vendor_name),
+                    .productName = std::string(device_name),
+                    .fullName = std::string(vendor_name) + " " + std::string(device_name),
+                    .connector = connector
+            };
+
+            gpu_units.push_back(gpu);
+        }
+
+        pci_cleanup(pacc);
+
+        return gpu_units;
+    }
+
+}
diff --git a/Sources/AppShared/Executor.cpp b/Sources/AppShared/Executor.cpp
@@ -0,0 +1,3 @@
+// TODO: Write the code that parses the "name" flag from main
+// prioritize binaries first, then apps from start menu
+// the user might include something like "IntelliJ", so lowercase everything to closely match the app
diff --git a/Sources/AppShared/HelpPage.cpp b/Sources/AppShared/HelpPage.cpp
@@ -0,0 +1,66 @@
+#include <RunAsGPU/Shared/HelpPage.hpp>
+#include <algorithm>
+#include <sstream>
+
+HelpPage::Item::Item(std::string &a, std::string &e, std::string &d) : arg(a), equalDesc(e), description(d) {}
+
+HelpPage::HelpPage() : spaceWidth(5), startSpaceWidth(0) {}
+
+void HelpPage::setSpaceWidth(int width) {
+    spaceWidth = width;
+}
+
+int HelpPage::getSpaceWidth() const {
+    return spaceWidth;
+}
+
+void HelpPage::setStartSpaceWidth(int width) {
+    startSpaceWidth = width;
+}
+
+int HelpPage::getStartSpaceWidth() const {
+    return startSpaceWidth;
+}
+
+void HelpPage::addArg(std::string arg, std::string assignableDesc, std::string description) {
+    argItemList.emplace_back(arg, assignableDesc, description);
+}
+
+void HelpPage::setDescSeparator(const std::string &sep) {
+    descSep = sep;
+}
+
+std::string HelpPage::getDescSeparator() const {
+    return descSep;
+}
+
+std::string HelpPage::display() const {
+    std::ostringstream oss;
+    int maxItemLength = 0;
+
+    for (const auto &item: argItemList) {
+        std::string argLine = item.arg + (item.equalDesc.empty() ? "" : descSep + item.equalDesc);
+        maxItemLength = std::max(maxItemLength, static_cast<int>(argLine.length()));
+    }
+
+    for (const auto &item: argItemList) {
+        std::string argLine = item.arg + (item.equalDesc.empty() ? "" : descSep + item.equalDesc);
+        if (startSpaceWidth > 0)
+            oss << std::string(startSpaceWidth, ' ');
+
+        oss << argLine
+            << std::string(maxItemLength - argLine.length() + spaceWidth, ' ')
+            << item.description + "\n";
+    }
+
+    return oss.str();
+}
+
+void HelpPage::display(std::ostream &os) const {
+    os << display();
+}
+
+void HelpPage::free() {
+    argItemList.clear();
+    argItemList.shrink_to_fit();
+}
diff --git a/Sources/AppShared/Shared.cpp b/Sources/AppShared/Shared.cpp
@@ -0,0 +1,26 @@
+#include <filesystem>
+#include <climits>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#ifdef __linux__
+#include <unistd.h>
+#endif
+
+namespace fs = std::filesystem;
+
+fs::path GetExecutablePath() {
+#ifdef _WIN32
+    char buffer[MAX_PATH];
+    GetModuleFileName(nullptr, buffer, MAX_PATH);
+    fs::path exePath = std::string(buffer);
+    return exePath;
+#else
+    char result[PATH_MAX];
+    ssize_t count = readlink("/proc/self/exe", result, PATH_MAX);
+    fs::path exePath = std::string(result, (count > 0) ? count : 0);
+    return exePath;
+#endif
+}
diff --git a/Sources/AppShared/SourceInfo.cmake b/Sources/AppShared/SourceInfo.cmake
@@ -0,0 +1,7 @@
+CollectSources(${PROJECT_MODULE_ROOT} MOD_SOURCES)
+
+add_library(RunAsGPU-shared OBJECT ${MOD_SOURCES})
+
+target_link_libraries(RunAsGPU-shared PUBLIC ${LIBPCI_LIBRARIES})
+target_include_directories(RunAsGPU-shared PUBLIC ${LIBPCI_INCLUDE_DIRS})
+target_compile_options(RunAsGPU-shared PUBLIC ${LIBPCI_CFLAGS_OTHER})
diff --git a/Sources/MainModule/Main.cpp b/Sources/MainModule/Main.cpp
diff --git a/Sources/MainModule/SourceInfo.cmake b/Sources/MainModule/SourceInfo.cmake
