Installation

pip install cupy torch pytest

Usage

python gpu_gemm_optimizer.py --m <rows_of_A> --n <columns_of_B> --k <columns_of_A_rows_of_B> --device <cuda_or_rocm> [--block_size <block_size>]

python gpu_gemm_optimizer.py --m 512 --n 256 --k 128 --device cuda

Source Code

import argparse
import numpy as np
import importlib

def analyze_and_optimize_gemm(m, n, k, device, block_size=None):
    """
    Analyzes and optimizes GEMM operations for GPUs.

    Parameters:
        m (int): Number of rows in matrix A.
        n (int): Number of columns in matrix B.
        k (int): Number of columns in matrix A / rows in matrix B.
        device (str): GPU device type ('cuda' or 'rocm').
        block_size (int, optional): Block size for optimization.

    Returns:
        dict: Optimized parameters and performance metrics.
    """
    if device not in ['cuda', 'rocm']:
        raise ValueError("Unsupported device. Use 'cuda' or 'rocm'.")

    # Initialize matrices
    A = np.random.rand(m, k).astype(np.float32)
    B = np.random.rand(k, n).astype(np.float32)

    if device == 'cuda':
        try:
            cp = importlib.import_module('cupy')
        except ImportError:
            raise ImportError("CuPy is not installed. Please install it to use CUDA functionality.")

        A_gpu = cp.array(A)
        B_gpu = cp.array(B)
        cp.cuda.Device().synchronize()

        # Perform GEMM and measure time
        start = cp.cuda.Event()
        end = cp.cuda.Event()
        start.record()
        C_gpu = cp.dot(A_gpu, B_gpu)
        end.record()
        end.synchronize()
        elapsed_time = cp.cuda.get_elapsed_time(start, end) / 1000  # seconds

    elif device == 'rocm':
        try:
            torch = importlib.import_module('torch')
        except ImportError:
            raise ImportError("PyTorch is not installed. Please install it to use ROCm functionality.")

        A_gpu = torch.tensor(A, device='cuda')
        B_gpu = torch.tensor(B, device='cuda')

        torch.cuda.synchronize()
        start = torch.cuda.Event(enable_timing=True)
        end = torch.cuda.Event(enable_timing=True)
        start.record()
        C_gpu = torch.mm(A_gpu, B_gpu)
        end.record()
        torch.cuda.synchronize()
        elapsed_time = start.elapsed_time(end) / 1000  # seconds

    # Example optimization: Adjust block size (dummy logic)
    optimized_block_size = block_size if block_size else 32

    return {
        "optimized_block_size": optimized_block_size,
        "performance_seconds": elapsed_time,
        "result_shape": C_gpu.shape
    }

def main():
    parser = argparse.ArgumentParser(description="GPU GEMM Optimizer")
    parser.add_argument('--m', type=int, required=True, help="Number of rows in matrix A")
    parser.add_argument('--n', type=int, required=True, help="Number of columns in matrix B")
    parser.add_argument('--k', type=int, required=True, help="Number of columns in matrix A / rows in matrix B")
    parser.add_argument('--device', type=str, required=True, choices=['cuda', 'rocm'], help="GPU device type")
    parser.add_argument('--block_size', type=int, default=None, help="Block size for optimization")

    args = parser.parse_args()

    try:
        result = analyze_and_optimize_gemm(args.m, args.n, args.k, args.device, args.block_size)
        print("Optimized Parameters:", result)
    except Exception as e:
        print("Error:", str(e))

if __name__ == "__main__":
    main()

README

pip install cupy torch pytest

python gpu_gemm_optimizer.py --m <rows_of_A> --n <columns_of_B> --k <columns_of_A_rows_of_B> --device <cuda_or_rocm> [--block_size <block_size>]

python gpu_gemm_optimizer.py --m 512 --n 256 --k 128 --device cuda

pytest test_gpu_gemm_optimizer.py