cpu-loader 0.4.8__tar.gz → 0.5.4__tar.gz

{cpu_loader-0.4.8/src/cpu_loader.egg-info → cpu_loader-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpu-loader
-Version: 0.4.8
+Version: 0.5.4
 Summary: A tool to generate CPU load on a system with runtime configuration through a WebUI and REST API
 Author-email: the78mole <the78mole@users.noreply.github.com>
 License-Expression: MIT
@@ -27,7 +27,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi==0.122.0
 Requires-Dist: uvicorn[standard]==0.38.0
-Requires-Dist: pydantic==2.12.4
+Requires-Dist: pydantic==2.12.5
 Requires-Dist: requests==2.32.5
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: websockets>=12.0
@@ -47,11 +47,14 @@ A tool to generate CPU load on a system with runtime configuration through a Web
 
 - **🎯 Precise Per-Thread Control**: Set individual CPU load (0-100%) for each core independently
 - **⚡ High Performance**: Native C implementation with pthreads ensures accurate load generation
-- **📊 Real-Time Monitoring**: Live WebSocket updates showing actual CPU usage via `psutil`
+- **🧮 Configurable Algorithms**: Choose between 5 different computation types (busy-wait, PI, primes, matrix, fibonacci)
+- **⏱️ Time-Controlled Execution**: All algorithms respect precise timing for accurate load percentages
+- **📊 Real-Time Monitoring**: Live WebSocket updates showing actual CPU usage and temperature via `psutil`
 - **🎛️ Interactive WebUI**: Beautiful gradient interface with sliders and visual feedback
 - **🚀 REST API**: Complete programmatic control for automation and testing
 - **📱 Responsive Design**: Works seamlessly on desktop and mobile devices
 - **🔄 Instant Updates**: Changes take effect immediately with sub-second response time
+- **🌡️ Temperature Monitoring**: Optional CPU temperature tracking with sensor auto-detection
 - 📡 **MQTT Integration**: Publish metrics and settings to MQTT broker for IoT/monitoring systems
 
 ## 🖼️ Screenshots
@@ -59,23 +62,23 @@ A tool to generate CPU load on a system with runtime configuration through a Web
 ### Interface Screenshots
 <table>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/01-initial-view.png" alt="Initial view with zero load">
       <p align="center"><em>Clean interface showing all CPU threads at idle</em></p>
     </td>
-    <td width="50%" rowspan="3" valign="top">
+    <td width="60%" rowspan="3" valign="top">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/04-mobile-view.png" alt="Mobile responsive view">
       <p align="center"><em>Fully responsive mobile interface</em></p>
     </td>
   </tr>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/02-with-load.png" alt="Mixed load across threads">
       <p align="center"><em>Different load levels: 50%, 75%, and 25% on individual threads</em></p>
     </td>
   </tr>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/03-live-metrics.png" alt="Live CPU metrics updating">
       <p align="center"><em>Real-time metrics showing actual CPU usage with color-coded bars</em></p>
     </td>
@@ -144,6 +147,8 @@ uv run src/main.py --help
 **Available Options:**
 - `--host HOST`: Host to bind the server to (default: 0.0.0.0)
 - `--port PORT`: Port to bind the server to (default: 8000)
+- `--disable-temperature`: Disable CPU temperature monitoring
+- `--computation-type TYPE`: Set computation algorithm (busy-wait, pi, primes, matrix, fibonacci)
 - `--mqtt-broker-host HOST`: MQTT broker hostname
 - `--mqtt-broker-port PORT`: MQTT broker port (default: 1883)
 - `--mqtt-username USER`: MQTT username
@@ -151,6 +156,30 @@ uv run src/main.py --help
 - `--mqtt-topic-prefix PREFIX`: MQTT topic prefix (default: cpu-loader)
 - `--mqtt-client-id ID`: MQTT client ID (default: cpu-loader)
 
+#### Computation Types
+
+CPU Loader supports different computation algorithms for load generation with **precise time control**:
+
+- **`busy-wait`** (default): Simple busy loop - fastest execution, minimal overhead, most accurate timing
+- **`pi`**: PI calculation using Leibniz formula - moderate computational intensity, mathematical workload
+- **`primes`**: Prime number finding - variable computational load, cryptographic-style operations
+- **`matrix`**: 4x4 matrix multiplication - consistent computational patterns, linear algebra operations
+- **`fibonacci`**: Lightweight mathematical operations - balanced computational load with micro-pauses
+
+All algorithms are **time-controlled** to ensure accurate load percentages. The system uses 10ms cycles with frequent timing checks to maintain precise CPU utilization.
+
+**Examples:**
+```bash
+# Use PI calculation for CPU load
+uv run cpu-loader --computation-type pi
+
+# Use prime number calculation
+uv run cpu-loader --computation-type primes --port 8001
+
+# Use matrix multiplication
+uv run cpu-loader --computation-type matrix
+```
+
 ### WebUI
 
 Open your browser and navigate to `http://localhost:8000`
@@ -202,6 +231,26 @@ curl -X POST http://localhost:8000/api/threads \
   -d '{"num_threads": 8}'
 ```
 
+#### Get Computation Type
+```bash
+curl http://localhost:8000/api/computation-type
+```
+
+Response:
+```json
+{
+  "computation_type": "pi",
+  "available_types": ["busy-wait", "pi", "primes", "matrix", "fibonacci"]
+}
+```
+
+#### Set Computation Type
+```bash
+curl -X PUT http://localhost:8000/api/computation-type \
+  -H "Content-Type: application/json" \
+  -d '{"computation_type": "fibonacci"}'
+```
+
 ## API Documentation
 
 Once the server is running, visit `http://localhost:8000/docs` for interactive API documentation powered by Swagger UI.
@@ -307,6 +356,31 @@ The example demonstrates:
 - Individual thread control
 - Resetting to idle
 
+### Computation Types Demo
+
+A comprehensive demo script is available in `examples/computation_types_demo.py` to test all computation algorithms:
+
+```bash
+# Start the server
+uv run cpu-loader
+
+# In another terminal, run the demo (tests all computation types)
+python examples/computation_types_demo.py
+
+# Test specific computation types only
+python examples/computation_types_demo.py --types pi fibonacci
+
+# Custom load and duration
+python examples/computation_types_demo.py --load 50 --duration 15
+```
+
+The demo script:
+
+- Tests each computation type systematically
+- Monitors actual CPU usage vs. target load
+- Provides performance comparisons between algorithms
+- Shows timing accuracy for each computation method
+
 ## Architecture
 
 - **src/cpu_loader_core.c**: High-performance C implementation using pthreads for CPU load generation
@@ -327,13 +401,22 @@ The example demonstrates:
 
 ## Use Cases
 
-- **Performance Testing**: Test application behavior under various CPU loads
-- **Stress Testing**: Validate system stability under high CPU utilization
-- **Thermal Testing**: Check cooling system effectiveness
-- **Power Consumption Analysis**: Measure power usage at different load levels
-- **Benchmarking**: Create reproducible load scenarios
+- **Performance Testing**: Test application behavior under various CPU loads and computation types
+- **Stress Testing**: Validate system stability under high CPU utilization with different algorithms
+- **Thermal Testing**: Use fibonacci or matrix computations for maximum heat generation
+- **Power Consumption Analysis**: Compare power usage across different computation algorithms
+- **Benchmarking**: Create reproducible load scenarios with specific computation patterns
+- **Algorithm Testing**: Test cache performance (matrix), mathematical units (pi), or crypto operations (primes)
 - **IoT Integration**: Integrate with Home Assistant, Node-RED, or other MQTT-based systems
-- **Monitoring**: Feed CPU metrics into monitoring dashboards via MQTT
+- **Monitoring**: Feed CPU metrics and temperature data into monitoring dashboards via MQTT
+
+### Computation Algorithm Use Cases
+
+- **`busy-wait`**: Baseline testing, pure timing validation, minimal computational overhead
+- **`pi`**: Mathematical processing benchmarks, floating-point unit testing
+- **`primes`**: Cryptographic algorithm simulation, integer arithmetic testing
+- **`matrix`**: Linear algebra workloads, cache hierarchy testing, SIMD instruction testing
+- **`fibonacci`**: Balanced computational load for general stress testing
 
 ## Development
 
@@ -363,10 +446,13 @@ Versions are automatically determined based on commit messages:
 
 - **Patch bump** (0.0.X): Every commit to main
 - **Minor bump** (0.X.0): Commits prefixed with `feat:`
+
   ```bash
   git commit -m "feat: add new CPU monitoring feature"
   ```
+
 - **Major bump** (X.0.0): Commits with `major:`, `breaking:`, or `BREAKING CHANGE:`
+
   ```bash
   git commit -m "major: redesign API interface"
   git commit -m "breaking: remove deprecated endpoints"
@@ -375,6 +461,7 @@ Versions are automatically determined based on commit messages:
 #### Release Process
 
 1. **Commit and push to main**:
+
    ```bash
    git add .
    git commit -m "feat: add WebSocket support"

{cpu_loader-0.4.8 → cpu_loader-0.5.4}/README.md

@@ -11,11 +11,14 @@ A tool to generate CPU load on a system with runtime configuration through a Web
 
 - **🎯 Precise Per-Thread Control**: Set individual CPU load (0-100%) for each core independently
 - **⚡ High Performance**: Native C implementation with pthreads ensures accurate load generation
-- **📊 Real-Time Monitoring**: Live WebSocket updates showing actual CPU usage via `psutil`
+- **🧮 Configurable Algorithms**: Choose between 5 different computation types (busy-wait, PI, primes, matrix, fibonacci)
+- **⏱️ Time-Controlled Execution**: All algorithms respect precise timing for accurate load percentages
+- **📊 Real-Time Monitoring**: Live WebSocket updates showing actual CPU usage and temperature via `psutil`
 - **🎛️ Interactive WebUI**: Beautiful gradient interface with sliders and visual feedback
 - **🚀 REST API**: Complete programmatic control for automation and testing
 - **📱 Responsive Design**: Works seamlessly on desktop and mobile devices
 - **🔄 Instant Updates**: Changes take effect immediately with sub-second response time
+- **🌡️ Temperature Monitoring**: Optional CPU temperature tracking with sensor auto-detection
 - 📡 **MQTT Integration**: Publish metrics and settings to MQTT broker for IoT/monitoring systems
 
 ## 🖼️ Screenshots
@@ -23,23 +26,23 @@ A tool to generate CPU load on a system with runtime configuration through a Web
 ### Interface Screenshots
 <table>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/01-initial-view.png" alt="Initial view with zero load">
       <p align="center"><em>Clean interface showing all CPU threads at idle</em></p>
     </td>
-    <td width="50%" rowspan="3" valign="top">
+    <td width="60%" rowspan="3" valign="top">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/04-mobile-view.png" alt="Mobile responsive view">
       <p align="center"><em>Fully responsive mobile interface</em></p>
     </td>
   </tr>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/02-with-load.png" alt="Mixed load across threads">
       <p align="center"><em>Different load levels: 50%, 75%, and 25% on individual threads</em></p>
     </td>
   </tr>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/03-live-metrics.png" alt="Live CPU metrics updating">
       <p align="center"><em>Real-time metrics showing actual CPU usage with color-coded bars</em></p>
     </td>
@@ -108,6 +111,8 @@ uv run src/main.py --help
 **Available Options:**
 - `--host HOST`: Host to bind the server to (default: 0.0.0.0)
 - `--port PORT`: Port to bind the server to (default: 8000)
+- `--disable-temperature`: Disable CPU temperature monitoring
+- `--computation-type TYPE`: Set computation algorithm (busy-wait, pi, primes, matrix, fibonacci)
 - `--mqtt-broker-host HOST`: MQTT broker hostname
 - `--mqtt-broker-port PORT`: MQTT broker port (default: 1883)
 - `--mqtt-username USER`: MQTT username
@@ -115,6 +120,30 @@ uv run src/main.py --help
 - `--mqtt-topic-prefix PREFIX`: MQTT topic prefix (default: cpu-loader)
 - `--mqtt-client-id ID`: MQTT client ID (default: cpu-loader)
 
+#### Computation Types
+
+CPU Loader supports different computation algorithms for load generation with **precise time control**:
+
+- **`busy-wait`** (default): Simple busy loop - fastest execution, minimal overhead, most accurate timing
+- **`pi`**: PI calculation using Leibniz formula - moderate computational intensity, mathematical workload
+- **`primes`**: Prime number finding - variable computational load, cryptographic-style operations
+- **`matrix`**: 4x4 matrix multiplication - consistent computational patterns, linear algebra operations
+- **`fibonacci`**: Lightweight mathematical operations - balanced computational load with micro-pauses
+
+All algorithms are **time-controlled** to ensure accurate load percentages. The system uses 10ms cycles with frequent timing checks to maintain precise CPU utilization.
+
+**Examples:**
+```bash
+# Use PI calculation for CPU load
+uv run cpu-loader --computation-type pi
+
+# Use prime number calculation
+uv run cpu-loader --computation-type primes --port 8001
+
+# Use matrix multiplication
+uv run cpu-loader --computation-type matrix
+```
+
 ### WebUI
 
 Open your browser and navigate to `http://localhost:8000`
@@ -166,6 +195,26 @@ curl -X POST http://localhost:8000/api/threads \
   -d '{"num_threads": 8}'
 ```
 
+#### Get Computation Type
+```bash
+curl http://localhost:8000/api/computation-type
+```
+
+Response:
+```json
+{
+  "computation_type": "pi",
+  "available_types": ["busy-wait", "pi", "primes", "matrix", "fibonacci"]
+}
+```
+
+#### Set Computation Type
+```bash
+curl -X PUT http://localhost:8000/api/computation-type \
+  -H "Content-Type: application/json" \
+  -d '{"computation_type": "fibonacci"}'
+```
+
 ## API Documentation
 
 Once the server is running, visit `http://localhost:8000/docs` for interactive API documentation powered by Swagger UI.
@@ -271,6 +320,31 @@ The example demonstrates:
 - Individual thread control
 - Resetting to idle
 
+### Computation Types Demo
+
+A comprehensive demo script is available in `examples/computation_types_demo.py` to test all computation algorithms:
+
+```bash
+# Start the server
+uv run cpu-loader
+
+# In another terminal, run the demo (tests all computation types)
+python examples/computation_types_demo.py
+
+# Test specific computation types only
+python examples/computation_types_demo.py --types pi fibonacci
+
+# Custom load and duration
+python examples/computation_types_demo.py --load 50 --duration 15
+```
+
+The demo script:
+
+- Tests each computation type systematically
+- Monitors actual CPU usage vs. target load
+- Provides performance comparisons between algorithms
+- Shows timing accuracy for each computation method
+
 ## Architecture
 
 - **src/cpu_loader_core.c**: High-performance C implementation using pthreads for CPU load generation
@@ -291,13 +365,22 @@ The example demonstrates:
 
 ## Use Cases
 
-- **Performance Testing**: Test application behavior under various CPU loads
-- **Stress Testing**: Validate system stability under high CPU utilization
-- **Thermal Testing**: Check cooling system effectiveness
-- **Power Consumption Analysis**: Measure power usage at different load levels
-- **Benchmarking**: Create reproducible load scenarios
+- **Performance Testing**: Test application behavior under various CPU loads and computation types
+- **Stress Testing**: Validate system stability under high CPU utilization with different algorithms
+- **Thermal Testing**: Use fibonacci or matrix computations for maximum heat generation
+- **Power Consumption Analysis**: Compare power usage across different computation algorithms
+- **Benchmarking**: Create reproducible load scenarios with specific computation patterns
+- **Algorithm Testing**: Test cache performance (matrix), mathematical units (pi), or crypto operations (primes)
 - **IoT Integration**: Integrate with Home Assistant, Node-RED, or other MQTT-based systems
-- **Monitoring**: Feed CPU metrics into monitoring dashboards via MQTT
+- **Monitoring**: Feed CPU metrics and temperature data into monitoring dashboards via MQTT
+
+### Computation Algorithm Use Cases
+
+- **`busy-wait`**: Baseline testing, pure timing validation, minimal computational overhead
+- **`pi`**: Mathematical processing benchmarks, floating-point unit testing
+- **`primes`**: Cryptographic algorithm simulation, integer arithmetic testing
+- **`matrix`**: Linear algebra workloads, cache hierarchy testing, SIMD instruction testing
+- **`fibonacci`**: Balanced computational load for general stress testing
 
 ## Development
 
@@ -327,10 +410,13 @@ Versions are automatically determined based on commit messages:
 
 - **Patch bump** (0.0.X): Every commit to main
 - **Minor bump** (0.X.0): Commits prefixed with `feat:`
+
   ```bash
   git commit -m "feat: add new CPU monitoring feature"
   ```
+
 - **Major bump** (X.0.0): Commits with `major:`, `breaking:`, or `BREAKING CHANGE:`
+
   ```bash
   git commit -m "major: redesign API interface"
   git commit -m "breaking: remove deprecated endpoints"
@@ -339,6 +425,7 @@ Versions are automatically determined based on commit messages:
 #### Release Process
 
 1. **Commit and push to main**:
+
    ```bash
    git add .
    git commit -m "feat: add WebSocket support"

{cpu_loader-0.4.8 → cpu_loader-0.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cpu-loader"
-version = "0.4.8"
+version = "0.5.4"
 description = "A tool to generate CPU load on a system with runtime configuration through a WebUI and REST API"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -27,7 +27,7 @@ classifiers = [
 dependencies = [
     "fastapi==0.122.0",
     "uvicorn[standard]==0.38.0",
-    "pydantic==2.12.4",
+    "pydantic==2.12.5",
     "requests==2.32.5",
     "psutil>=5.9.0",
     "websockets>=12.0",

{cpu_loader-0.4.8 → cpu_loader-0.5.4}/src/cpu_loader/cpu_loader.py

@@ -16,6 +16,52 @@ except ImportError:
     )
 
 
+class ComputationType:
+    """Enumeration for different computation types."""
+
+    BUSY_WAIT = 0
+    PI_CALCULATION = 1
+    PRIME_NUMBERS = 2
+    MATRIX_MULTIPLY = 3
+    FIBONACCI = 4
+
+    @classmethod
+    def from_string(cls, compute_str: str) -> int:
+        """Convert string representation to computation type integer."""
+        compute_map = {
+            "busy-wait": cls.BUSY_WAIT,
+            "pi": cls.PI_CALCULATION,
+            "primes": cls.PRIME_NUMBERS,
+            "matrix": cls.MATRIX_MULTIPLY,
+            "fibonacci": cls.FIBONACCI,
+        }
+
+        compute_str = compute_str.lower().strip()
+        if compute_str not in compute_map:
+            available = ", ".join(compute_map.keys())
+            raise ValueError(
+                f"Invalid computation type '{compute_str}'. Available: {available}"
+            )
+
+        return compute_map[compute_str]
+
+    @classmethod
+    def to_string(cls, compute_type: int) -> str:
+        """Convert computation type integer to string representation."""
+        type_map = {
+            cls.BUSY_WAIT: "busy-wait",
+            cls.PI_CALCULATION: "pi",
+            cls.PRIME_NUMBERS: "primes",
+            cls.MATRIX_MULTIPLY: "matrix",
+            cls.FIBONACCI: "fibonacci",
+        }
+
+        if compute_type not in type_map:
+            raise ValueError(f"Invalid computation type {compute_type}")
+
+        return type_map[compute_type]
+
+
 class CPULoader:
     """Manages CPU load generation across multiple threads using C extension."""
 
@@ -102,6 +148,45 @@ class CPULoader:
         self.num_threads = num_threads
         cpu_loader_core.init_loader(num_threads)
 
+    def set_computation_type(self, compute_type: int):
+        """
+        Set the computation type for CPU load generation.
+
+        Args:
+            compute_type: Computation type (use ComputationType constants)
+        """
+        cpu_loader_core.set_computation_type(compute_type)
+
+    def get_computation_type(self) -> int:
+        """
+        Get the current computation type.
+
+        Returns:
+            Current computation type integer
+        """
+        return cpu_loader_core.get_computation_type()
+
+    def set_computation_type_from_string(self, compute_str: str):
+        """
+        Set the computation type from string representation.
+
+        Args:
+            compute_str: Computation type as string (e.g., 'pi', 'primes',
+                        'matrix', 'fibonacci', 'busy-wait')
+        """
+        compute_type = ComputationType.from_string(compute_str)
+        self.set_computation_type(compute_type)
+
+    def get_computation_type_string(self) -> str:
+        """
+        Get the current computation type as string.
+
+        Returns:
+            Current computation type as string
+        """
+        compute_type = self.get_computation_type()
+        return ComputationType.to_string(compute_type)
+
     def shutdown(self):
         """Shutdown all threads."""
         cpu_loader_core.shutdown()

{cpu_loader-0.4.8 → cpu_loader-0.5.4}/src/cpu_loader/cpu_loader_core.c

@@ -6,7 +6,16 @@
 #include <stdbool.h>
 #include <stdio.h>
 
-#define CYCLE_TIME_NS 100000000L  // 100ms in nanoseconds
+#define CYCLE_TIME_NS 10000000L  // 10ms in nanoseconds for better responsiveness
+
+// Computation types for busy-wait
+typedef enum {
+    COMPUTE_BUSY_WAIT = 0,
+    COMPUTE_PI_CALCULATION = 1,
+    COMPUTE_PRIME_NUMBERS = 2,
+    COMPUTE_MATRIX_MULTIPLY = 3,
+    COMPUTE_FIBONACCI = 4
+} ComputationType;
 
 typedef struct {
     pthread_t thread;
@@ -14,11 +23,13 @@ typedef struct {
     double load;  // 0.0 to 1.0
     bool running;
     bool stop;
+    ComputationType compute_type;
     pthread_mutex_t lock;
 } WorkerThread;
 
 static WorkerThread *workers = NULL;
 static int num_threads = 0;
+static ComputationType global_compute_type = COMPUTE_BUSY_WAIT;
 static pthread_mutex_t global_lock = PTHREAD_MUTEX_INITIALIZER;
 
 // High-resolution timer
@@ -28,12 +39,131 @@ static inline long long get_time_ns(void) {
     return (long long)ts.tv_sec * 1000000000LL + ts.tv_nsec;
 }
 
-// Busy-wait for specified nanoseconds
-static inline void busy_wait_ns(long long ns) {
+// Time-controlled PI calculation using Leibniz formula
+static void calculate_pi_timed(long long duration_ns) {
     long long start = get_time_ns();
-    while ((get_time_ns() - start) < ns) {
-        // Busy loop
+    double pi = 0.0;
+    int i = 0;
+
+    // Check time every 100 iterations for better responsiveness
+    while ((get_time_ns() - start) < duration_ns) {
+        for (int batch = 0; batch < 100 && (get_time_ns() - start) < duration_ns; batch++) {
+            pi += (i % 2 == 0 ? 1.0 : -1.0) / (2 * i + 1);
+            i++;
+        }
+    }
+}
+
+// Prime number checking (time-controlled)
+static bool is_prime_quick(long long n) {
+    if (n < 2) return false;
+    if (n == 2) return true;
+    if (n % 2 == 0) return false;
+
+    for (long long i = 3; i * i <= n; i += 2) {
+        if (n % i == 0) return false;
     }
+    return true;
+}
+
+// Time-controlled prime number finding
+static void find_primes_timed(long long duration_ns) {
+    long long start = get_time_ns();
+    long long n = 1000; // Start from a reasonable number
+
+    while ((get_time_ns() - start) < duration_ns) {
+        // Process numbers one by one with frequent time checks
+        is_prime_quick(n);
+        n++;
+        if (n > 100000) n = 1000; // Reset to avoid overflow
+
+        // Check time more frequently for better control
+        if ((n % 50) == 0 && (get_time_ns() - start) >= duration_ns) {
+            break;
+        }
+    }
+}
+
+// Simple matrix multiplication (4x4 matrices) - time controlled
+static void matrix_multiply_timed(long long duration_ns) {
+    long long start = get_time_ns();
+    double a[4][4] = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};
+    double b[4][4] = {{16,15,14,13},{12,11,10,9},{8,7,6,5},{4,3,2,1}};
+    double result[4][4];
+
+    while ((get_time_ns() - start) < duration_ns) {
+        // Perform matrix multiplication with frequent time checks
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                result[i][j] = 0;
+                for (int k = 0; k < 4; k++) {
+                    result[i][j] += a[i][k] * b[k][j];
+                }
+                // Check time after each element calculation
+                if ((get_time_ns() - start) >= duration_ns) {
+                    return;
+                }
+            }
+        }
+        // Vary matrices slightly to prevent optimization
+        a[0][0] = result[0][0] / 1000000.0;
+    }
+}
+
+// Time-controlled lightweight computational work (simplified approach)
+static void fibonacci_timed(long long duration_ns) {
+    long long start = get_time_ns();
+    volatile double result = 0.0; // Use volatile to prevent optimization
+    int counter = 0;
+
+    while ((get_time_ns() - start) < duration_ns) {
+        // Perform lightweight mathematical operations
+        for (int i = 0; i < 100 && (get_time_ns() - start) < duration_ns; i++) {
+            result += counter * 1.1 + 0.5;
+            counter = (counter + 1) % 1000;
+        }
+
+        // Small computational pause
+        struct timespec tiny_pause = {0, 5000}; // 5 microseconds
+        nanosleep(&tiny_pause, NULL);
+    }
+}
+
+// Perform computation based on type for specified duration
+static void perform_computation(ComputationType type, long long duration_ns) {
+    switch (type) {
+        case COMPUTE_PI_CALCULATION:
+            calculate_pi_timed(duration_ns);
+            break;
+
+        case COMPUTE_PRIME_NUMBERS:
+            find_primes_timed(duration_ns);
+            break;
+
+        case COMPUTE_MATRIX_MULTIPLY:
+            matrix_multiply_timed(duration_ns);
+            break;
+
+        case COMPUTE_FIBONACCI:
+            fibonacci_timed(duration_ns);
+            break;
+
+        case COMPUTE_BUSY_WAIT:
+        default:
+            // Original busy-wait implementation
+            {
+                long long start = get_time_ns();
+                while ((get_time_ns() - start) < duration_ns) {
+                    // Busy loop
+                }
+            }
+            break;
+    }
+}
+
+// Busy-wait for specified nanoseconds (backward compatibility)
+static inline void busy_wait_ns(long long ns) {
+    perform_computation(COMPUTE_BUSY_WAIT, ns);
 }
 
 static void *worker_thread(void *arg) {
@@ -44,6 +174,7 @@ static void *worker_thread(void *arg) {
 
         pthread_mutex_lock(&worker->lock);
         double load = worker->load;
+        ComputationType compute_type = worker->compute_type;
         pthread_mutex_unlock(&worker->lock);
 
         if (load <= 0.0) {
@@ -51,14 +182,14 @@ static void *worker_thread(void *arg) {
             struct timespec sleep_time = {0, CYCLE_TIME_NS};
             nanosleep(&sleep_time, NULL);
         } else if (load >= 1.0) {
-            // 100% load, busy-wait for the entire cycle
-            busy_wait_ns(CYCLE_TIME_NS);
+            // 100% load, perform computation for the entire cycle
+            perform_computation(compute_type, CYCLE_TIME_NS);
         } else {
             // Partial load
             long long work_time_ns = (long long)(load * CYCLE_TIME_NS);
 
-            // Busy-wait for work time
-            busy_wait_ns(work_time_ns);
+            // Perform computation for work time
+            perform_computation(compute_type, work_time_ns);
 
             // Sleep for the rest of the cycle
             long long elapsed = get_time_ns() - cycle_start;
@@ -114,6 +245,7 @@ static PyObject *init_loader(PyObject *self, PyObject *args) {
         workers[i].load = 0.0;
         workers[i].running = false;
         workers[i].stop = false;
+        workers[i].compute_type = global_compute_type;
         pthread_mutex_init(&workers[i].lock, NULL);
 
         if (pthread_create(&workers[i].thread, NULL, worker_thread, &workers[i]) != 0) {
@@ -217,6 +349,43 @@ static PyObject *get_num_threads(PyObject *self, PyObject *args) {
     return PyLong_FromLong(n);
 }
 
+// Set computation type
+static PyObject *set_computation_type(PyObject *self, PyObject *args) {
+    int comp_type;
+
+    if (!PyArg_ParseTuple(args, "i", &comp_type)) {
+        return NULL;
+    }
+
+    if (comp_type < 0 || comp_type > COMPUTE_FIBONACCI) {
+        PyErr_SetString(PyExc_ValueError, "Invalid computation type");
+        return NULL;
+    }
+
+    pthread_mutex_lock(&global_lock);
+    global_compute_type = (ComputationType)comp_type;
+
+    // Update all existing workers
+    for (int i = 0; i < num_threads; i++) {
+        pthread_mutex_lock(&workers[i].lock);
+        workers[i].compute_type = global_compute_type;
+        pthread_mutex_unlock(&workers[i].lock);
+    }
+
+    pthread_mutex_unlock(&global_lock);
+
+    Py_RETURN_NONE;
+}
+
+// Get computation type
+static PyObject *get_computation_type(PyObject *self, PyObject *args) {
+    pthread_mutex_lock(&global_lock);
+    int comp_type = (int)global_compute_type;
+    pthread_mutex_unlock(&global_lock);
+
+    return PyLong_FromLong(comp_type);
+}
+
 // Shutdown all threads
 static PyObject *shutdown_loader(PyObject *self, PyObject *args) {
     pthread_mutex_lock(&global_lock);
@@ -246,6 +415,8 @@ static PyMethodDef CoreMethods[] = {
     {"get_thread_load", get_thread_load, METH_VARARGS, "Get load for a thread"},
     {"get_all_loads", get_all_loads, METH_NOARGS, "Get all thread loads"},
     {"get_num_threads", get_num_threads, METH_NOARGS, "Get number of threads"},
+    {"set_computation_type", set_computation_type, METH_VARARGS, "Set computation type"},
+    {"get_computation_type", get_computation_type, METH_NOARGS, "Get computation type"},
     {"shutdown", shutdown_loader, METH_NOARGS, "Shutdown the CPU loader"},
     {NULL, NULL, 0, NULL}
 };

{cpu_loader-0.4.8 → cpu_loader-0.5.4}/src/cpu_loader/main.py

@@ -57,6 +57,17 @@ class CPUMetricsResponse(BaseModel):
     cpu_temperature: Optional[float] = None
 
 
+class ComputationTypeRequest(BaseModel):
+    computation_type: str = Field(
+        ..., description="Computation type: busy-wait, pi, primes, matrix, fibonacci"
+    )
+
+
+class ComputationTypeResponse(BaseModel):
+    computation_type: str
+    available_types: List[str]
+
+
 # Global CPU loader instance, MQTT publisher, and WebSocket connections
 cpu_loader = None
 mqtt_publisher: Optional[MQTTPublisher] = None
@@ -150,6 +161,11 @@ async def lifespan(app: FastAPI):
     # Startup
     cpu_loader = CPULoader()
 
+    # Set computation type if specified in app state
+    computation_type = getattr(app.state, "computation_type", None)
+    if computation_type:
+        cpu_loader.set_computation_type_from_string(computation_type)
+
     # Initialize MQTT publisher with settings from arguments or environment
     mqtt_args = getattr(app.state, "mqtt_args", {})
     try:
@@ -309,6 +325,30 @@ async def set_all_thread_loads(request: AllThreadsLoadRequest):
         raise HTTPException(status_code=400, detail=str(e))
 
 
+@app.get("/api/computation-type", response_model=ComputationTypeResponse)
+async def get_computation_type():
+    """Get the current computation type."""
+    current_type = cpu_loader.get_computation_type_string()
+    available_types = ["busy-wait", "pi", "primes", "matrix", "fibonacci"]
+    return ComputationTypeResponse(
+        computation_type=current_type, available_types=available_types
+    )
+
+
+@app.put("/api/computation-type")
+async def set_computation_type(request: ComputationTypeRequest):
+    """Set the computation type for CPU load generation."""
+    try:
+        cpu_loader.set_computation_type_from_string(request.computation_type)
+        return {
+            "status": "success",
+            "computation_type": request.computation_type,
+            "message": f"Computation type set to {request.computation_type}",
+        }
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
 def parse_args():
     """Parse command-line arguments."""
     parser = argparse.ArgumentParser(
@@ -330,6 +370,12 @@ def parse_args():
         action="store_true",
         help="Disable CPU temperature monitoring (useful if temperature sensors are unavailable)",
     )
+    parser.add_argument(
+        "--computation-type",
+        choices=["busy-wait", "pi", "primes", "matrix", "fibonacci"],
+        default="busy-wait",
+        help="Type of computation to perform during CPU load generation (default: busy-wait)",
+    )
 
     # MQTT arguments
     mqtt_group = parser.add_argument_group("MQTT settings")
@@ -385,8 +431,9 @@ def run():
     if args.mqtt_client_id:
         mqtt_args["client_id"] = args.mqtt_client_id
 
-    # Store MQTT args in app state for lifespan to access
+    # Store MQTT args and computation type in app state for lifespan to access
     app.state.mqtt_args = mqtt_args
+    app.state.computation_type = args.computation_type
 
     # Run the server
     uvicorn.run(app, host=args.host, port=args.port)

{cpu_loader-0.4.8 → cpu_loader-0.5.4/src/cpu_loader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpu-loader
-Version: 0.4.8
+Version: 0.5.4
 Summary: A tool to generate CPU load on a system with runtime configuration through a WebUI and REST API
 Author-email: the78mole <the78mole@users.noreply.github.com>
 License-Expression: MIT
@@ -27,7 +27,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: fastapi==0.122.0
 Requires-Dist: uvicorn[standard]==0.38.0
-Requires-Dist: pydantic==2.12.4
+Requires-Dist: pydantic==2.12.5
 Requires-Dist: requests==2.32.5
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: websockets>=12.0
@@ -47,11 +47,14 @@ A tool to generate CPU load on a system with runtime configuration through a Web
 
 - **🎯 Precise Per-Thread Control**: Set individual CPU load (0-100%) for each core independently
 - **⚡ High Performance**: Native C implementation with pthreads ensures accurate load generation
-- **📊 Real-Time Monitoring**: Live WebSocket updates showing actual CPU usage via `psutil`
+- **🧮 Configurable Algorithms**: Choose between 5 different computation types (busy-wait, PI, primes, matrix, fibonacci)
+- **⏱️ Time-Controlled Execution**: All algorithms respect precise timing for accurate load percentages
+- **📊 Real-Time Monitoring**: Live WebSocket updates showing actual CPU usage and temperature via `psutil`
 - **🎛️ Interactive WebUI**: Beautiful gradient interface with sliders and visual feedback
 - **🚀 REST API**: Complete programmatic control for automation and testing
 - **📱 Responsive Design**: Works seamlessly on desktop and mobile devices
 - **🔄 Instant Updates**: Changes take effect immediately with sub-second response time
+- **🌡️ Temperature Monitoring**: Optional CPU temperature tracking with sensor auto-detection
 - 📡 **MQTT Integration**: Publish metrics and settings to MQTT broker for IoT/monitoring systems
 
 ## 🖼️ Screenshots
@@ -59,23 +62,23 @@ A tool to generate CPU load on a system with runtime configuration through a Web
 ### Interface Screenshots
 <table>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/01-initial-view.png" alt="Initial view with zero load">
       <p align="center"><em>Clean interface showing all CPU threads at idle</em></p>
     </td>
-    <td width="50%" rowspan="3" valign="top">
+    <td width="60%" rowspan="3" valign="top">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/04-mobile-view.png" alt="Mobile responsive view">
       <p align="center"><em>Fully responsive mobile interface</em></p>
     </td>
   </tr>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/02-with-load.png" alt="Mixed load across threads">
       <p align="center"><em>Different load levels: 50%, 75%, and 25% on individual threads</em></p>
     </td>
   </tr>
   <tr>
-    <td width="50%">
+    <td width="40%">
       <img src="https://raw.githubusercontent.com/the78mole/cpu-loader/main/screenshots/03-live-metrics.png" alt="Live CPU metrics updating">
       <p align="center"><em>Real-time metrics showing actual CPU usage with color-coded bars</em></p>
     </td>
@@ -144,6 +147,8 @@ uv run src/main.py --help
 **Available Options:**
 - `--host HOST`: Host to bind the server to (default: 0.0.0.0)
 - `--port PORT`: Port to bind the server to (default: 8000)
+- `--disable-temperature`: Disable CPU temperature monitoring
+- `--computation-type TYPE`: Set computation algorithm (busy-wait, pi, primes, matrix, fibonacci)
 - `--mqtt-broker-host HOST`: MQTT broker hostname
 - `--mqtt-broker-port PORT`: MQTT broker port (default: 1883)
 - `--mqtt-username USER`: MQTT username
@@ -151,6 +156,30 @@ uv run src/main.py --help
 - `--mqtt-topic-prefix PREFIX`: MQTT topic prefix (default: cpu-loader)
 - `--mqtt-client-id ID`: MQTT client ID (default: cpu-loader)
 
+#### Computation Types
+
+CPU Loader supports different computation algorithms for load generation with **precise time control**:
+
+- **`busy-wait`** (default): Simple busy loop - fastest execution, minimal overhead, most accurate timing
+- **`pi`**: PI calculation using Leibniz formula - moderate computational intensity, mathematical workload
+- **`primes`**: Prime number finding - variable computational load, cryptographic-style operations
+- **`matrix`**: 4x4 matrix multiplication - consistent computational patterns, linear algebra operations
+- **`fibonacci`**: Lightweight mathematical operations - balanced computational load with micro-pauses
+
+All algorithms are **time-controlled** to ensure accurate load percentages. The system uses 10ms cycles with frequent timing checks to maintain precise CPU utilization.
+
+**Examples:**
+```bash
+# Use PI calculation for CPU load
+uv run cpu-loader --computation-type pi
+
+# Use prime number calculation
+uv run cpu-loader --computation-type primes --port 8001
+
+# Use matrix multiplication
+uv run cpu-loader --computation-type matrix
+```
+
 ### WebUI
 
 Open your browser and navigate to `http://localhost:8000`
@@ -202,6 +231,26 @@ curl -X POST http://localhost:8000/api/threads \
   -d '{"num_threads": 8}'
 ```
 
+#### Get Computation Type
+```bash
+curl http://localhost:8000/api/computation-type
+```
+
+Response:
+```json
+{
+  "computation_type": "pi",
+  "available_types": ["busy-wait", "pi", "primes", "matrix", "fibonacci"]
+}
+```
+
+#### Set Computation Type
+```bash
+curl -X PUT http://localhost:8000/api/computation-type \
+  -H "Content-Type: application/json" \
+  -d '{"computation_type": "fibonacci"}'
+```
+
 ## API Documentation
 
 Once the server is running, visit `http://localhost:8000/docs` for interactive API documentation powered by Swagger UI.
@@ -307,6 +356,31 @@ The example demonstrates:
 - Individual thread control
 - Resetting to idle
 
+### Computation Types Demo
+
+A comprehensive demo script is available in `examples/computation_types_demo.py` to test all computation algorithms:
+
+```bash
+# Start the server
+uv run cpu-loader
+
+# In another terminal, run the demo (tests all computation types)
+python examples/computation_types_demo.py
+
+# Test specific computation types only
+python examples/computation_types_demo.py --types pi fibonacci
+
+# Custom load and duration
+python examples/computation_types_demo.py --load 50 --duration 15
+```
+
+The demo script:
+
+- Tests each computation type systematically
+- Monitors actual CPU usage vs. target load
+- Provides performance comparisons between algorithms
+- Shows timing accuracy for each computation method
+
 ## Architecture
 
 - **src/cpu_loader_core.c**: High-performance C implementation using pthreads for CPU load generation
@@ -327,13 +401,22 @@ The example demonstrates:
 
 ## Use Cases
 
-- **Performance Testing**: Test application behavior under various CPU loads
-- **Stress Testing**: Validate system stability under high CPU utilization
-- **Thermal Testing**: Check cooling system effectiveness
-- **Power Consumption Analysis**: Measure power usage at different load levels
-- **Benchmarking**: Create reproducible load scenarios
+- **Performance Testing**: Test application behavior under various CPU loads and computation types
+- **Stress Testing**: Validate system stability under high CPU utilization with different algorithms
+- **Thermal Testing**: Use fibonacci or matrix computations for maximum heat generation
+- **Power Consumption Analysis**: Compare power usage across different computation algorithms
+- **Benchmarking**: Create reproducible load scenarios with specific computation patterns
+- **Algorithm Testing**: Test cache performance (matrix), mathematical units (pi), or crypto operations (primes)
 - **IoT Integration**: Integrate with Home Assistant, Node-RED, or other MQTT-based systems
-- **Monitoring**: Feed CPU metrics into monitoring dashboards via MQTT
+- **Monitoring**: Feed CPU metrics and temperature data into monitoring dashboards via MQTT
+
+### Computation Algorithm Use Cases
+
+- **`busy-wait`**: Baseline testing, pure timing validation, minimal computational overhead
+- **`pi`**: Mathematical processing benchmarks, floating-point unit testing
+- **`primes`**: Cryptographic algorithm simulation, integer arithmetic testing
+- **`matrix`**: Linear algebra workloads, cache hierarchy testing, SIMD instruction testing
+- **`fibonacci`**: Balanced computational load for general stress testing
 
 ## Development
 
@@ -363,10 +446,13 @@ Versions are automatically determined based on commit messages:
 
 - **Patch bump** (0.0.X): Every commit to main
 - **Minor bump** (0.X.0): Commits prefixed with `feat:`
+
   ```bash
   git commit -m "feat: add new CPU monitoring feature"
   ```
+
 - **Major bump** (X.0.0): Commits with `major:`, `breaking:`, or `BREAKING CHANGE:`
+
   ```bash
   git commit -m "major: redesign API interface"
   git commit -m "breaking: remove deprecated endpoints"
@@ -375,6 +461,7 @@ Versions are automatically determined based on commit messages:
 #### Release Process
 
 1. **Commit and push to main**:
+
    ```bash
    git add .
    git commit -m "feat: add WebSocket support"

{cpu_loader-0.4.8 → cpu_loader-0.5.4}/src/cpu_loader.egg-info/requires.txt

@@ -1,6 +1,6 @@
 fastapi==0.122.0
 uvicorn[standard]==0.38.0
-pydantic==2.12.4
+pydantic==2.12.5
 requests==2.32.5
 psutil>=5.9.0
 websockets>=12.0