Create cpu_pinned_Core_0.py

Author: Rohanberiwal

cpu_pinned_Core_0.py

@@ -0,0 +1,143 @@
+import os
+import time
+import random
+import pandas as pd
+from statistics import mean, stdev
+
+# Pin the process to CPU core 0
+os.system("taskset -p 0x1 %d" % os.getpid())
+
+def split_matrix(matrix):
+    # Split the matrix into 4 submatrices
+    rows, cols = len(matrix), len(matrix[0])
+    split_row, split_col = rows // 2, cols // 2
+
+    A11 = [row[:split_col] for row in matrix[:split_row]]
+    A12 = [row[split_col:] for row in matrix[:split_row]]
+    A21 = [row[:split_col] for row in matrix[split_row:]]
+    A22 = [row[split_col:] for row in matrix[split_row:]]
+
+    return A11, A12, A21, A22
+
+def add_matrices(matrix1, matrix2):
+    # Add two matrices element-wise
+    return [
+        [matrix1[i][j] + matrix2[i][j] for j in range(len(matrix1[0]))]
+        for i in range(len(matrix1))
+    ]
+
+def subtract_matrices(matrix1, matrix2):
+    # Subtract matrix2 from matrix1 element-wise
+    return [
+        [matrix1[i][j] - matrix2[i][j] for j in range(len(matrix1[0]))]
+        for i in range(len(matrix1))
+    ]
+
+def strassen(matrix1, matrix2):
+    # Recursive implementation of Strassen's algorithm
+    if len(matrix1) == 1:
+        return [[matrix1[0][0] * matrix2[0][0]]]
+
+    A11, A12, A21, A22 = split_matrix(matrix1)
+    B11, B12, B21, B22 = split_matrix(matrix2)
+
+    P1 = strassen(A11, subtract_matrices(B12, B22))
+    P2 = strassen(add_matrices(A11, A12), B22)
+    P3 = strassen(add_matrices(A21, A22), B11)
+    P4 = strassen(A22, subtract_matrices(B21, B11))
+    P5 = strassen(add_matrices(A11, A22), add_matrices(B11, B22))
+    P6 = strassen(subtract_matrices(A12, A22), add_matrices(B21, B22))
+    P7 = strassen(subtract_matrices(A11, A21), add_matrices(B11, B12))
+
+    C11 = subtract_matrices(add_matrices(P5, P4), subtract_matrices(P2, P6))
+    C12 = add_matrices(P1, P2)
+    C21 = add_matrices(P3, P4)
+    C22 = subtract_matrices(subtract_matrices(P5, P3), subtract_matrices(P1, P7))
+
+    result = [
+        C11[i] + C12[i]
+        for i in range(len(C11))
+    ] + [
+        C21[i] + C22[i]
+        for i in range(len(C21))
+    ]
+
+    return result
+
+def generate_random_matrix(rows, cols, seed=None):
+    # Generate a random matrix with specified dimensions
+    if seed is not None:
+        random.seed(seed)
+    return [[random.randint(1, 100) for _ in range(cols)] for _ in range(rows)]
+
+def benchmark(matrix_size, repetitions=5, warm_up_runs=3, stress_runs=100, seed=None):
+    data = {'Matrix Size': [], 'Run Number': [], 'Runtime (seconds)': []}
+
+    # Warm-up phase
+    for _ in range(warm_up_runs):
+        matrix1 = generate_random_matrix(matrix_size, matrix_size, seed=seed)
+        matrix2 = generate_random_matrix(matrix_size, matrix_size, seed=seed)
+        strassen(matrix1, matrix2)
+
+    # Actual benchmarking
+    for run_number in range(1, repetitions + 1):
+        matrix1 = generate_random_matrix(matrix_size, matrix_size, seed=seed)
+        matrix2 = generate_random_matrix(matrix_size, matrix_size, seed=seed)
+
+        start_time = time.perf_counter()
+        strassen(matrix1, matrix2)
+        end_time = time.perf_counter()
+
+        runtime = end_time - start_time
+
+        data['Matrix Size'].append(matrix_size)
+        data['Run Number'].append(run_number)
+        data['Runtime (seconds)'].append(runtime)
+
+    df = pd.DataFrame(data)
+    average_runtimes = df.groupby('Matrix Size')['Runtime (seconds)'].agg([mean, stdev]).reset_index()
+    print("\nAverage Runtimes:\n", average_runtimes)
+
+    # Stress testing
+    stress_data = []
+    for _ in range(stress_runs):
+        matrix1 = generate_random_matrix(matrix_size, matrix_size, seed=seed)
+        matrix2 = generate_random_matrix(matrix_size, matrix_size, seed=seed)
+
+        start_time = time.perf_counter()
+        strassen(matrix1, matrix2)
+        end_time = time.perf_counter()
+
+        runtime = end_time - start_time
+        stress_data.append(runtime)
+
+    print(f"\nStress Testing for Matrix Size {matrix_size}x{matrix_size}:")
+    print(f"Mean Runtime: {mean(stress_data)} seconds")
+    print(f"Standard Deviation: {stdev(stress_data)} seconds")
+
+    return df
+
+def multiple_independent_runs(matrix_size, independent_runs=5, repetitions=5, warm_up_runs=3, stress_runs=100, seed=None):
+    all_data = pd.DataFrame()
+
+    for run in range(independent_runs):
+        print(f"\nIndependent Run {run + 1}/{independent_runs}")
+        run_data = benchmark(matrix_size, repetitions=repetitions, warm_up_runs=warm_up_runs, stress_runs=stress_runs, seed=seed)
+        all_data = pd.concat([all_data, run_data], ignore_index=True)
+
+    return all_data
+
+# Collect benchmark data
+matrix_sizes = [2, 4, 8, 16, 32, 64, 128]
+independent_runs = 3
+repetitions = 5
+stress_runs = 100
+
+final_data = pd.DataFrame()
+
+for matrix_size in matrix_sizes:
+    matrix_data = multiple_independent_runs(matrix_size, independent_runs=independent_runs, repetitions=repetitions, stress_runs=stress_runs)
+    final_data = pd.concat([final_data, matrix_data], ignore_index=True)
+
+# Display the combined data table
+print("\nCombined Data Table:\n", final_data)