torc 0.22.1

Workflow management system
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

#!/usr/bin/env python3
"""
Mixed workload job that combines CPU-intensive computation with memory allocation
for approximately 60 seconds. Uses only Python standard library.
"""

import time
import sys
import random
import hashlib

def fibonacci(n):
    """Compute the nth Fibonacci number recursively (CPU intensive)."""
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

def compute_hashes(data):
    """Compute SHA256 hashes of data (CPU intensive)."""
    result = []
    for item in data:
        hash_obj = hashlib.sha256(str(item).encode())
        result.append(hash_obj.hexdigest())
    return result

def mixed_workload(duration_seconds=60):
    """
    Perform a mix of CPU-intensive computation and memory allocation.
    Alternates between computation phases and memory phases.
    """
    print(f"Starting mixed workload for {duration_seconds} seconds...")
    print(f"Job ID: {sys.argv[0]}")

    start_time = time.time()
    data_store = []
    computation_count = 0
    iteration = 0

    while time.time() - start_time < duration_seconds:
        iteration += 1
        elapsed = time.time() - start_time

        # Phase 1: Memory allocation (even iterations)
        if iteration % 2 == 0:
            # Allocate a chunk of random data
            chunk = [random.random() for _ in range(100_000)]
            data_store.append(chunk)

            # Keep only last 10 chunks to limit memory growth
            if len(data_store) > 10:
                data_store.pop(0)

            memory_mb = (sum(len(c) for c in data_store) * 8) / (1024 * 1024)
            print(f"[{elapsed:.1f}s] Memory phase: {len(data_store)} chunks, "
                  f"~{memory_mb:.1f} MB")

        # Phase 2: CPU computation (odd iterations)
        else:
            # Compute Fibonacci numbers
            fib_results = []
            for n in range(25, 31):  # Fib(25) to Fib(30)
                fib_results.append(fibonacci(n))

            computation_count += len(fib_results)

            # Compute hashes on some stored data
            if data_store:
                chunk_idx = random.randint(0, len(data_store) - 1)
                sample_data = data_store[chunk_idx][:100]
                hashes = compute_hashes(sample_data)

            print(f"[{elapsed:.1f}s] CPU phase: computed {len(fib_results)} Fibonacci numbers, "
                  f"largest: {fib_results[-1]:,}")

        # Small sleep between phases
        time.sleep(0.5)

    elapsed = time.time() - start_time
    total_memory_elements = sum(len(c) for c in data_store)
    memory_mb = (total_memory_elements * 8) / (1024 * 1024)

    print(f"\nCompleted in {elapsed:.2f} seconds")
    print(f"Total iterations: {iteration}")
    print(f"Computation count: {computation_count}")
    print(f"Final data chunks: {len(data_store)}")
    print(f"Final memory usage: ~{memory_mb:.1f} MB")

    return iteration

if __name__ == "__main__":
    try:
        iterations = mixed_workload(60)
        print(f"\n✓ Mixed workload job completed successfully")
        sys.exit(0)
    except Exception as e:
        print(f"\n✗ Error: {e}", file=sys.stderr)
        sys.exit(1)