macOS support, README.md, plot fixes and -p behaviour

- CPULoadGenerator: macOS compat (_available_cores, _set_cpu_affinity), single-core plot in main process, ignore -p when multiple cores
- README: add README.md (from README.rst), macOS run instructions, plot notes
- ClosedLoopActuator: fix RealTimePlot init (target %), no cpu_affinity for macOS
- Plot: Agg in child processes, real-time window in main process, fix PNG filename (no double *100)

Made-with: Cursor

Author: GaetanoCarlucci

CPULoadGenerator.py

@@ -17,6 +17,24 @@
 from utils.Monitor import MonitorThread
 
 
+def _available_cores():
+    """Return list of available CPU core indices. Works on Linux, macOS, Windows."""
+    try:
+        p = psutil.Process(os.getpid())
+        return list(p.cpu_affinity())
+    except (AttributeError, psutil.AccessDenied):
+        return list(range(psutil.cpu_count()))
+
+
+def _set_cpu_affinity(core_id):
+    """Pin process to a CPU core if the platform supports it (Linux, Windows). No-op on macOS."""
+    try:
+        process = psutil.Process(os.getpid())
+        process.cpu_affinity([core_id])
+    except (AttributeError, psutil.AccessDenied):
+        pass
+
+
 class ShutdownException(Exception):
     pass
 
@@ -38,9 +56,8 @@ def load_core(target_core, target_load,
     if sampling_interval <= 0:
         raise Exception('Negative sampling interval!')
 
-    # lock this process to the target core
-    process = psutil.Process(os.getpid())
-    process.cpu_affinity([target_core])
+    # Lock this process to the target core (no-op on macOS; load still applied)
+    _set_cpu_affinity(target_core)
 
     monitor = MonitorThread(target_core, sampling_interval)
     control = ControllerThread(sampling_interval)
@@ -88,8 +105,7 @@ def __validate_cpu_load(ctx, param, value):
 
 
 def __validate_cpu_core(ctx, param, value):
-    p = psutil.Process(os.getpid())
-    available_cores = p.cpu_affinity()
+    available_cores = _available_cores()
 
     for v in value:
         if v not in available_cores:
@@ -113,7 +129,7 @@ def __validate_sampling_interval(ctx, param, value):
               help='CPU core to artificially load. '
                    'Can be specified multiple times to load multiple cores, '
                    'default is all cores.',
-              default=psutil.Process(os.getpid()).cpu_affinity(),
+              default=_available_cores(),
               show_default=True)
 @click.option('--cpu_load', '-l',
               type=float, multiple=True,
@@ -148,6 +164,16 @@ def __main(core, cpu_load, duration, plot, sampling_interval):
     # filter out repeated core indexes
     core = list(set(core))
 
+    # Plot only makes sense for a single core; ignore -p when running on multiple/all cores
+    if plot and len(core) > 1:
+        print('Plot disabled when using multiple cores (use -c 0 for single-core plot).')
+        plot = False
+
+    # Single core + plot: run in main process so the live plot window works (e.g. on macOS)
+    if len(core) == 1 and plot:
+        load_core(core[0], next(cpu_load), duration, plot, sampling_interval)
+        return
+
     # disable signal handlers before spawning processes
     signal.signal(signal.SIGINT, signal.SIG_IGN)
     signal.signal(signal.SIGTERM, signal.SIG_IGN)

README.md

@@ -0,0 +1,88 @@
+# CPU Load Generator
+
+[![CI](https://img.shields.io/github/actions/workflow/status/GaetanoCarlucci/CPULoadGenerator/ci.yml)](https://github.com/GaetanoCarlucci/CPULoadGenerator/actions)
+[![License: MIT](https://img.shields.io/:license-mit-green.svg?style=flat)](http://opensource.org/licenses/MIT)
+[![Made with Python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
+
+This script generates a fixed CPU load for a finite or indefinite time period, on one or more CPU cores. A **PI controller** is used for this purpose.
+
+You provide the desired CPU load and the CPU core(s) to load. The controller and the CPU monitor run in separate threads.
+
+## Theoretical insight
+
+- **Project homepage:** [https://gaetanocarlucci.github.io/CPULoadGenerator/](https://gaetanocarlucci.github.io/CPULoadGenerator/) — more details on the tool.
+- **Blog:** [Theoretical explanation of this tool](https://gaetanocarlucci.altervista.org/cpu-load-generator-project/).
+
+## Dependencies
+
+- **Python 3.6+**
+- **Libraries:** `matplotlib`, `psutil`, `click`
+
+### Setup with virtualenv
+
+```bash
+cd CPULoadGenerator/
+sudo apt install virtualenv
+virtualenv --python=python3.6 ./venv
+. venv/bin/activate
+(venv) $ pip install -r requirements.txt
+```
+
+### System-wide install (Debian/Ubuntu)
+
+```bash
+sudo apt install python3-matplotlib python3-psutil python3-click
+```
+
+### Run on macOS
+
+1. Create and activate a virtual environment (recommended):
+
+   ```bash
+   cd CPULoadGenerator/
+   python3 -m venv venv
+   source venv/bin/activate
+   pip install -r requirements.txt
+   ```
+
+2. Run the script (e.g. 20% load on core 0 for 10 seconds):
+
+   ```bash
+   python CPULoadGenerator.py -l 0.2 -d 10 -c 0
+   ```
+
+   Or make it executable and run: `chmod +x CPULoadGenerator.py` then `./CPULoadGenerator.py -l 0.2 -d 10 -c 0`.
+
+**Note for macOS:** CPU affinity (pinning a process to a specific core) is not supported by the OS, so the process is not bound to the chosen core. The script still generates the requested load; it may just be distributed across cores by the scheduler. All other behaviour (PI control, duration) is unchanged.
+
+With `--plot`: use **exactly one core** to see the **live plot window** on macOS (e.g. `-c 0 -l 0.5 -d 20 --plot`). With multiple cores, the plot is saved to a PNG file at the end. If the window does not appear or stays blank, try `export MPLBACKEND=TkAgg` before running, or install a GUI backend: `pip install pyobjc-framework-Cocoa` (for the default macOS backend).
+
+## Examples
+
+1. **20% load on core 0 for 20 seconds:**
+
+   ```bash
+   ./CPULoadGenerator.py -l 0.2 -d 20 -c 0
+   ```
+
+2. **65% load on cores 0, 1 and 5, until interrupted (Ctrl-C):**
+
+   ```bash
+   ./CPULoadGenerator.py -l 0.65 -c 0 -c 1 -c 5
+   ```
+
+3. **55% load on core 0, 12% on core 3, until interrupted:**
+
+   ```bash
+   ./CPULoadGenerator.py -c 0 -c 3 -l 0.55 -l 0.12
+   ```
+
+4. **12% load on cores 0 and 1 for 20.5 seconds, then plot the load:**
+
+   ```bash
+   ./CPULoadGenerator.py -l 0.12 -c 0 -c 1 -d 20.5 --plot
+   ```
+
+5. **Example graph of CPU load (50% target on core 0):**
+
+   ![Example - 50% load on CPU core 0](https://raw.githubusercontent.com/molguin92/CPULoadGenerator/python3_port_stable/50%25-Target-Load.png)

utils/ClosedLoopActuator.py

@@ -74,8 +74,8 @@ def __init__(self, controller, monitor, duration, target):
         super(PlottingClosedLoopActuator,
               self).__init__(controller, monitor, duration, target)
 
-        cpu_core = psutil.Process(os.getpid()).cpu_affinity()[0]
-        self.graph = RealTimePlot(self.duration, cpu_core, target)
+        # target = core index; target load % from controller (no cpu_affinity: not supported on macOS)
+        self.graph = RealTimePlot(self.duration, target, self.controller.get_cpu_target() * 100)
 
     def send_plot_sample(self):
         if (time.time() - self.last_plot_time) > 0.2:

utils/Plot.py

@@ -1,7 +1,16 @@
 # Authors: Gaetano Carlucci
 #         Giuseppe Cofano
 
+import multiprocessing
 import time
+
+# In child processes (e.g. multiprocessing on macOS) GUI backends often fail:
+# window opens as icon but plot does not show. Use non-interactive backend and
+# save to file at the end.
+if multiprocessing.current_process().name != 'MainProcess':
+    import matplotlib
+    matplotlib.use('Agg')
+
 import matplotlib.pyplot as plt
 
 
@@ -13,8 +22,10 @@ class RealTimePlot:
     def __init__(self, duration, cpu, target):
         plt.figure()
         plt.axis([0, duration, 0, 100])
-        plt.ion()
-        plt.show()
+        # Only show window in main process; in workers (macOS/multiprocessing) use Agg, no window
+        if multiprocessing.current_process().name == 'MainProcess':
+            plt.ion()
+            plt.show()
         plt.xlabel('Time(sec)')
         plt.ylabel('%')
         self.y_load = [0]
@@ -45,11 +56,19 @@ def plot_sample(self, sample, target):
         self.line_load.set_xdata(self.xdata)
         self.line_load.set_ydata(self.y_load)
         plt.draw()
+        # Run GUI event loop so the window updates in real time (main process only)
+        if multiprocessing.current_process().name == 'MainProcess':
+            plt.pause(0.01)
 
     def close(self):
         if self.cpuT != 0:
-            name = f'{int(self.cpuT * 100.0):d}%-Target-Load' \
+            # self.cpuT is already in 0-100 (passed as get_cpu_target() * 100)
+            name = f'{int(round(self.cpuT))}%-Target-Load' \
                    f'-CPU{self.cpu_idx}.png'
             # TODO: add option to change format
             plt.savefig(name, dpi=100)
+            # When using Agg (no window), inform user where the plot was saved
+            if multiprocessing.current_process().name != 'MainProcess':
+                import os
+                print(f'Plot saved to: {os.path.abspath(name)}')
         plt.close()