Skip to content

README.md

Latest commit

 

History

History
82 lines (57 loc) · 7.97 KB

README.md

File metadata and controls

82 lines (57 loc) · 7.97 KB
Raw

📊 Benchmarking app

PC benchmarking app for testing the system's performance and showing detailed info about the hardware specs

This benchmarking application features a modern Python graphical interface (using CustomTkinter library) and a C++ backend. It extracts detailed hardware information, such as CPU, RAM, and cache memory specifications, and runs precise benchmarks to evaluate data transfer speeds, as well as the execution speed of arithmetic and logical operations. For a comprehensive analysis, users can run all tests sequentially to automatically generate a detailed performance report that is saved as a text file.

🛠️ Tools and Technologies

  • C++ (MSVC) – Employed for the high-performance backend modules, including hardware-specific instructions (CPUID) and intensive benchmarking algorithms compiled as DLLs for maximum efficiency.
  • Windows API & WMI (Windows Management Instrumentation) – Used to interact with the operating system to query hardware details, such as CPU architecture, RAM configurations, and system paging parameters.
  • Python 3 – Used for the main application logic, handling the graphical user interface and managing thread execution for the benchmark processes.
  • CustomTkinter – A modern Python framework used to develop the GUI, providing a clean, responsive layout.
  • ctypes – A Python library that facilitates communication between the GUI and the compiled C++ DLLs, enabling the application to execute performance-critical code directly from the Python environment.

⚙️ C++ modules

  • System_info.cpp - This module extracts detailed hardware information, including CPU specifications (vendor, model, frequency, cache hierarchy) and memory details (RAM capacity, channel configuration). It uses the CPUID instruction for CPU details and Windows API/WMI calls for memory-related information.
  • Data_transfer_speed.cpp - The module provides benchmarks to evaluate data transfer speeds by performing sequential, strided, and random memory access tests. It uses dynamic allocation, cache-flushing techniques to ensure accuracy, and a PrecisionTimer class for high-resolution measurement.
  • Integer_operations.cpp – Designed to evaluate the performance of integer arithmetic and logical operations, this module applies a sequence of 13 distinct operations to randomized data buffers. It employs synchronization barriers and "warm-up" runs to ensure stable, repeatable results measured in Giga Operations per Second (GOps).
  • Floating_point_operations.cpp – This module assesses the processor's floating-point performance (FPU) by computing the Mandelbrot fractal. It executes complex arithmetic operations on double precision numbers and reports performance in Giga Floating Point Operations per Second (GFLOPS).

To ensure efficient integration between the C++ modules and the GUI, the source code was compiled into Dynamic-Link Libraries (DLLs).

🖼️ GUI

The app features a modern and intuitive graphical user interface developed using the customtkinter framework, which provides a clean design and support for system themes. The interface is structured to ensure a pleasant user experience while providing efficient access to system analysis and benchmarking tools. Key features of the interface include:

  • Structured Layout: The main dashboard is organized into three distinct areas:
    • Hardware Information (Left Panel): Provides quick access to detailed system reports (CPU specs, cache memory, RAM configuration).
    • Performance Benchmarks (Right Panel): Allows the user to select and initiate specific tests for data transfer speeds, integer or floating-point arithmetic operations.
    • Footer: A dedicated button enables the execution of all performance benchmarks sequentially, automatically generating a comprehensive report saved to a timestamped text file.
image


  • Advanced Interaction Logic:
    • Asynchronous Execution (Multithreading): All benchmark tests are executed in separate threads. This ensures the GUI remains responsive, preventing the application from freezing during intensive computational tasks.
    • User Feedback: The application provides real-time status updates through animated progress bars and label changes (e.g., displaying "RUNNING..." during active benchmarks).
    • Test Customization: Within the benchmark frames, users can select specific memory block sizes (e.g., 64 KB to 1 GB) using intuitive checkboxes before starting a test.
    • Guided Navigation: The interface uses a hierarchical structure where individual test frames include safety warnings to close background applications, notes on estimated duration, and "Back" buttons for seamless navigation to the main menu.
    • Input Protection: To prevent system instability or conflicting processes, menu buttons are programmatically disabled while tests are in progress.
image

image

image

image


Comparative Performance Analysis

The app is designed to enable the objective evaluation and comparison of performance across different hardware configurations. By executing the same suite of benchmarks on various systems, users can identify specific hardware limitations and gain a clear understanding of how different components impact overall system speed.

📥 Installation and Usage Guide

The app is available as a standalone executable file that operates independently, requiring no Python installation or additional components. ⚠️ WARNING! The app is designed for Windows operating systems, as it relies on specific system calls and native libraries (WMI, Win32 API).

To run the application:

  1. Navigate to the Releases section of this repository.
  2. Download the latest version of the application (the .exe file).
  3. Run the PC-Benchmark-App.exe file.
  4. Upon the first launch, Windows Defender or your antivirus software may display a security warning because the application is not digitally signed. Confirm execution by selecting the "Run anyway" option.
  5. The graphical interface will open, allowing the user to select the desired hardware information or initiate performance tests.

Note: For optimal benchmark results, the following is recommended:

  • Close other applications during testing.
  • Connect the laptop to a power source (to avoid thermal throttling).
  • Run the application with the system in an idle state (without other intensive background processes).

🚀 Future Development

  • Intel Cache Support: Implement support for Intel processors in the "Cache Memory Info" module by using the CPUID function 0x04. The current implementation relies on the extended cache enumeration function (0x8000001D), which is specific to AMD Ryzen architectures.
  • Automated Hardware Detection: Develop an automated detection mechanism for the CPU manufacturer. This would allow the application to dynamically switch between different data-gathering methods (e.g., Intel vs. AMD) without requiring manual configuration.
  • Enhanced Data Visualization: Integrate data visualization tools, such as charts and graphs, within the GUI. This would provide a more intuitive comparison of benchmark results when analyzing performance across different hardware runs or configurations.
  • Expanded Benchmark Suite: Extend the current benchmarking capabilities to include stress testing for other components, such as the GPU.