Add winstress_vm, linstress_vm workloads and WORKLOAD_CONFIG override

benchmark_runner/common/template_operations/template_operations.py

@@ -162,6 +162,15 @@ def __generate_yamls_internal(self, scale: str = None, scale_num: str = None, sc
             logger.info(f'HAMMERDB_CONFIG override: {hammerdb_config}')
             render_data.update(hammerdb_config)
 
+        workload_config = self.__environment_variables_dict.get('workload_config', {})
+        if workload_config:
+            workload_config = {k: v for k, v in workload_config.items() if v != ''}
+            unknown_keys = set(workload_config.keys()) - set(render_data.keys())
+            if unknown_keys:
+                logger.warning(f'WORKLOAD_CONFIG unknown keys (will be ignored): {unknown_keys}')
+            logger.info(f'WORKLOAD_CONFIG override: {workload_config}')
+            render_data.update(workload_config)
+
         out_files = []
         standard_template_path = os.path.join(workload_dir_path, 'internal_data', self.__standard_template_file)
         if os.path.isfile(standard_template_path):

benchmark_runner/common/template_operations/templates/linstress/internal_data/linstress_vm_template.yaml

@@ -0,0 +1,196 @@
+apiVersion: v1
+kind: Secret
+metadata:
+  name: linstress-cloudinit-{{ trunc_uuid }}
+  namespace: {{ namespace }}
+stringData:
+  userdata: |
+    #cloud-config
+    user: fedora
+    password: fedora
+    chpasswd: { expire: False }
+    ssh_pwauth: true
+    {%- if ssh_public_key is defined and ssh_public_key %}
+    ssh_authorized_keys:
+      - "{{ ssh_public_key }}"
+    {%- endif %}
+    packages:
+      - python3-psutil
+    write_files:
+      - path: /tmp/stress.py
+        permissions: '0755'
+        content: |
+          import multiprocessing, time, psutil, json
+
+          def burn_cpu(d, result_dict, idx):
+              ops = 0
+              start = time.time()
+              end = start + d
+              while time.time() < end:
+                  _ = 2**32
+                  ops += 1
+              elapsed = time.time() - start
+              result_dict[idx] = {'ops': ops, 'elapsed': elapsed, 'ops_per_sec': ops / elapsed}
+
+          def burn_memory(target_percent, duration):
+              total = psutil.virtual_memory().total
+              target_bytes = int(total * target_percent / 100)
+              current_used = psutil.virtual_memory().used
+              alloc_bytes = target_bytes - current_used
+              if alloc_bytes <= 0:
+                  print(f'Memory already at {psutil.virtual_memory().percent}%, skipping')
+                  return
+              chunk_size = 100 * 1024 * 1024
+              blocks = []
+              allocated = 0
+              while allocated < alloc_bytes:
+                  size = min(chunk_size, alloc_bytes - allocated)
+                  blocks.append(bytearray(size))
+                  allocated += size
+                  print(f'Allocated {allocated // (1024*1024)}MB / {alloc_bytes // (1024*1024)}MB ({psutil.virtual_memory().percent}%)')
+              print(f'Memory at {psutil.virtual_memory().percent}%, holding for {duration}s...')
+              time.sleep(duration)
+
+          if __name__ == '__main__':
+              cpu_total = multiprocessing.cpu_count()
+              cpu_count = max(1, int(cpu_total * {{ stress_cpu }} / 100))
+              duration = {{ stress_duration }}
+              mem_target = {{ stress_memory }}
+
+              print(f'CPU count: {cpu_total}')
+              print(f'Stressing {cpu_count} CPUs ({{ stress_cpu }}%) and {mem_target}% memory for {duration}s')
+              print(f'Total memory: {psutil.virtual_memory().total // (1024**3)}GB')
+              print(f'Memory before: {psutil.virtual_memory().percent}%')
+              print(f'CPU before: {psutil.cpu_percent(interval=1)}%')
+
+              mem_proc = None
+              if mem_target > 0:
+                  mem_proc = multiprocessing.Process(target=burn_memory, args=(mem_target, duration))
+                  mem_proc.start()
+                  time.sleep(5)
+
+              manager = multiprocessing.Manager()
+              result_dict = manager.dict()
+
+              cpu_procs = [multiprocessing.Process(target=burn_cpu, args=(duration, result_dict, i)) for i in range(cpu_count)]
+              [p.start() for p in cpu_procs]
+
+              intervals = max(1, duration // 30)
+              samples = []
+              for i in range(intervals):
+                  time.sleep(30)
+                  mem = psutil.virtual_memory()
+                  cpu_pct = psutil.cpu_percent(interval=1)
+                  sample = {
+                      'time_sec': (i+1)*30,
+                      'cpu_percent': cpu_pct,
+                      'mem_percent': mem.percent,
+                      'mem_used_gb': round(mem.used / (1024**3), 1),
+                      'mem_total_gb': round(mem.total / (1024**3), 1)
+                  }
+                  samples.append(sample)
+                  print(f"At {sample['time_sec']}s: CPU={cpu_pct}% MEM={mem.percent}% ({sample['mem_used_gb']}GB/{sample['mem_total_gb']}GB)")
+
+              [p.join() for p in cpu_procs]
+              if mem_proc:
+                  mem_proc.join()
+
+              total_ops = sum(r['ops'] for r in result_dict.values())
+              total_ops_per_sec = sum(r['ops_per_sec'] for r in result_dict.values())
+              avg_ops_per_sec = total_ops_per_sec / cpu_count if cpu_count > 0 else 0
+
+              print(f'CPU after: {psutil.cpu_percent(interval=1)}%')
+              print(f'Memory after: {psutil.virtual_memory().percent}%')
+              print(f'Total operations: {total_ops:,}')
+              print(f'Total throughput: {total_ops_per_sec:,.0f} ops/sec')
+              print(f'Avg per CPU: {avg_ops_per_sec:,.0f} ops/sec')
+
+              report = {
+                  'config': {
+                      'cpu_total': cpu_total,
+                      'cpu_stressed': cpu_count,
+                      'stress_cpu_percent': {{ stress_cpu }},
+                      'stress_memory_percent': mem_target,
+                      'duration_sec': duration,
+                      'total_memory_gb': round(psutil.virtual_memory().total / (1024**3), 1)
+                  },
+                  'throughput': {
+                      'total_ops': total_ops,
+                      'total_ops_per_sec': round(total_ops_per_sec, 2),
+                      'avg_ops_per_cpu': round(avg_ops_per_sec, 2),
+                      'per_cpu': [{'cpu': i, 'ops': r['ops'], 'ops_per_sec': round(r['ops_per_sec'], 2)} for i, r in sorted(result_dict.items())]
+                  },
+                  'samples': samples
+              }
+
+              with open('/tmp/stress_report.json', 'w') as f:
+                  json.dump(report, f, indent=2)
+              print('Report saved to /tmp/stress_report.json')
+              print('Done')
+    runcmd:
+      - export HOME=/root
+      - dnf install -y python3-psutil || true
+      - python3 /tmp/stress.py
+---
+apiVersion: kubevirt.io/v1
+kind: VirtualMachine
+metadata:
+  {% if scale -%}
+  name: linstress-{{ kind }}-{{ trunc_uuid }}-{{ scale }}
+  labels:
+    kubevirt.io/vm: linstress-{{ kind }}-{{ trunc_uuid }}-{{ scale }}
+  {%- else -%}
+  name: linstress-{{ kind }}-{{ trunc_uuid }}
+  labels:
+    kubevirt.io/vm: linstress-{{ kind }}-{{ trunc_uuid }}
+  {%- endif %}
+  namespace: {{ namespace }}
+spec:
+  running: true
+  template:
+    metadata:
+      labels:
+        {% if scale -%}
+        kubevirt.io/vm: linstress-{{ kind }}-{{ trunc_uuid }}-{{ scale }}
+        {%- else -%}
+        kubevirt.io/vm: linstress-{{ kind }}-{{ trunc_uuid }}
+        {%- endif %}
+    spec:
+      {%- if pin == 'true' or pin == true %}
+      nodeSelector:
+        kubernetes.io/hostname: '{{ pin_node }}'
+      {%- endif %}
+      domain:
+        cpu:
+          sockets: {{ sockets }}
+          cores: {{ cores }}
+          threads: {{ threads }}
+        devices:
+          disks:
+            - disk:
+                bus: virtio
+              name: containerdisk
+            - disk:
+                bus: virtio
+              name: cloudinitdisk
+          interfaces:
+            - name: default
+              masquerade: {}
+          networkInterfaceMultiqueue: true
+        machine:
+          type: ""
+        resources:
+          requests:
+            memory: {{ requests_memory }}
+      terminationGracePeriodSeconds: 180
+      networks:
+        - name: default
+          pod: {}
+      volumes:
+        - name: containerdisk
+          containerDisk:
+            image: {{ fedora_container_disk }}
+        - name: cloudinitdisk
+          cloudInitNoCloud:
+            secretRef:
+              name: linstress-cloudinit-{{ trunc_uuid }}

benchmark_runner/common/template_operations/templates/linstress/linstress_data_template.yaml

@@ -0,0 +1,24 @@
+metadata:
+  name: linstress
+template_data:
+  shared:
+    pin_node: {{ pin_node0 }}
+    odf_pvc: {{ odf_pvc }}
+    uuid: {{ uuid }}
+    fedora_container_disk: {{ fedora_container_disk }}
+    stress_cpu: 100
+    stress_memory: 50
+    stress_duration: 600
+  run_type:
+    perf_ci:
+      requests_memory: 8Gi
+      requests_cpu: 8
+      cores: 1
+      sockets: 8
+      threads: 1
+    default:
+      requests_memory: 1Gi
+      requests_cpu: 1
+      cores: 1
+      sockets: 2
+      threads: 1

benchmark_runner/common/template_operations/templates/winstress/internal_data/01_run_stress_template.ps1

@@ -0,0 +1,123 @@
+$ErrorActionPreference = 'Stop'
+
+$stressDir = 'C:\tools\stress'
+$pythonExe = 'C:\Program Files\Python312\python.exe'
+$stressScript = "$stressDir\stress.py"
+$reportFile = "$stressDir\stress_report.json"
+
+New-Item -ItemType Directory -Force -Path $stressDir | Out-Null
+
+$scriptContent = @"
+import multiprocessing, time, psutil, json
+
+def burn_cpu(d, result_dict, idx):
+    ops = 0
+    start = time.time()
+    end = start + d
+    while time.time() < end:
+        _ = 2**32
+        ops += 1
+    elapsed = time.time() - start
+    result_dict[idx] = {'ops': ops, 'elapsed': elapsed, 'ops_per_sec': ops / elapsed}
+
+def burn_memory(target_percent, duration):
+    total = psutil.virtual_memory().total
+    target_bytes = int(total * target_percent / 100)
+    current_used = psutil.virtual_memory().used
+    alloc_bytes = target_bytes - current_used
+    if alloc_bytes <= 0:
+        print(f'Memory already at {psutil.virtual_memory().percent}%, skipping')
+        return
+    chunk_size = 100 * 1024 * 1024
+    blocks = []
+    allocated = 0
+    while allocated < alloc_bytes:
+        size = min(chunk_size, alloc_bytes - allocated)
+        blocks.append(bytearray(size))
+        allocated += size
+        print(f'Allocated {allocated // (1024*1024)}MB / {alloc_bytes // (1024*1024)}MB ({psutil.virtual_memory().percent}%)')
+    print(f'Memory at {psutil.virtual_memory().percent}%, holding for {duration}s...')
+    time.sleep(duration)
+
+if __name__ == '__main__':
+    cpu_total = multiprocessing.cpu_count()
+    cpu_count = max(1, int(cpu_total * {{ stress_cpu }} / 100))
+    duration = {{ stress_duration }}
+    mem_target = {{ stress_memory }}
+
+    print(f'CPU count: {cpu_total}')
+    print(f'Stressing {cpu_count} CPUs ({{"{{ stress_cpu }}"}}%) and {mem_target}% memory for {duration}s')
+    print(f'Total memory: {psutil.virtual_memory().total // (1024**3)}GB')
+    print(f'Memory before: {psutil.virtual_memory().percent}%')
+    print(f'CPU before: {psutil.cpu_percent(interval=1)}%')
+
+    mem_proc = None
+    if mem_target > 0:
+        mem_proc = multiprocessing.Process(target=burn_memory, args=(mem_target, duration))
+        mem_proc.start()
+        time.sleep(5)
+
+    manager = multiprocessing.Manager()
+    result_dict = manager.dict()
+
+    cpu_procs = [multiprocessing.Process(target=burn_cpu, args=(duration, result_dict, i)) for i in range(cpu_count)]
+    [p.start() for p in cpu_procs]
+
+    intervals = max(1, duration // 30)
+    samples = []
+    for i in range(intervals):
+        time.sleep(30)
+        mem = psutil.virtual_memory()
+        cpu_pct = psutil.cpu_percent(interval=1)
+        sample = {
+            'time_sec': (i+1)*30,
+            'cpu_percent': cpu_pct,
+            'mem_percent': mem.percent,
+            'mem_used_gb': round(mem.used / (1024**3), 1),
+            'mem_total_gb': round(mem.total / (1024**3), 1)
+        }
+        samples.append(sample)
+        print(f"At {sample['time_sec']}s: CPU={cpu_pct}% MEM={mem.percent}% ({sample['mem_used_gb']}GB/{sample['mem_total_gb']}GB)")
+
+    [p.join() for p in cpu_procs]
+    if mem_proc:
+        mem_proc.join()
+
+    total_ops = sum(r['ops'] for r in result_dict.values())
+    total_ops_per_sec = sum(r['ops_per_sec'] for r in result_dict.values())
+    avg_ops_per_sec = total_ops_per_sec / cpu_count if cpu_count > 0 else 0
+
+    print(f'CPU after: {psutil.cpu_percent(interval=1)}%')
+    print(f'Memory after: {psutil.virtual_memory().percent}%')
+    print(f'Total operations: {total_ops:,}')
+    print(f'Total throughput: {total_ops_per_sec:,.0f} ops/sec')
+    print(f'Avg per CPU: {avg_ops_per_sec:,.0f} ops/sec')
+
+    report = {
+        'config': {
+            'cpu_total': cpu_total,
+            'cpu_stressed': cpu_count,
+            'stress_cpu_percent': {{ stress_cpu }},
+            'stress_memory_percent': mem_target,
+            'duration_sec': duration,
+            'total_memory_gb': round(psutil.virtual_memory().total / (1024**3), 1)
+        },
+        'throughput': {
+            'total_ops': total_ops,
+            'total_ops_per_sec': round(total_ops_per_sec, 2),
+            'avg_ops_per_cpu': round(avg_ops_per_sec, 2),
+            'per_cpu': [{'cpu': i, 'ops': r['ops'], 'ops_per_sec': round(r['ops_per_sec'], 2)} for i, r in sorted(result_dict.items())]
+        },
+        'samples': samples
+    }
+
+    with open(r'C:\tools\stress\stress_report.json', 'w') as f:
+        json.dump(report, f, indent=2)
+    print('Report saved to C:\\tools\\stress\\stress_report.json')
+    print('Done')
+"@
+
+Set-Content -Path $stressScript -Value $scriptContent -Force
+Write-Host "Running stress test..."
+& $pythonExe $stressScript
+Write-Host "Stress test complete"

benchmark_runner/common/template_operations/templates/winstress/internal_data/windows_dv_template.yaml

@@ -0,0 +1,19 @@
+apiVersion: cdi.kubevirt.io/v1beta1
+kind: DataVolume
+metadata:
+  annotations:
+    cdi.kubevirt.io/storage.deleteAfterCompletion: "false"
+  name: windows-clone-dv
+  namespace: {{ namespace }}
+spec:
+  source:
+      http:
+         url: {{ url }}
+  pvc:
+    accessModes:
+      - ReadWriteMany
+    resources:
+      requests:
+        storage: {{ storage }}
+    volumeMode: Block
+    storageClassName: ocs-storagecluster-ceph-rbd-virtualization