CPU python とGPU CUDA の処理時間を比較。CUDAプログラミングにおけるスレッド数とブロック数の最適な構成とは。

import pycuda.driver as cuda
import pycuda.autoinit
from pycuda.compiler import SourceModule
import numpy as np
import time

# CUDAカーネルのコード
kernel_code = """
__global__ void vector_add(float *a, float *b, float *c, int N) {
    int i = threadIdx.x + blockIdx.x * blockDim.x;
    if (i < N) {
        c[i] = a[i] + b[i];
    }
}
"""

# CUDAカーネルのコンパイル
mod = SourceModule(kernel_code)
vector_add = mod.get_function("vector_add")

# 配列のサイズ
N = 1000000

# ホスト側のデータ
a = np.random.randn(N).astype(np.float32)
b = np.random.randn(N).astype(np.float32)
c = np.empty(N, dtype=np.float32)

# デバイスメモリの確保
d_a = cuda.mem_alloc(a.nbytes)
d_b = cuda.mem_alloc(b.nbytes)
d_c = cuda.mem_alloc(c.nbytes)

cuda.memcpy_htod(d_a, a)
cuda.memcpy_htod(d_b, b)

# スレッドとブロックの設定
for block_size in [128, 256, 512, 1024]:
    grid_size = (N + block_size - 1) // block_size
    start_time = time.time()

    # CUDAカーネルの実行
    vector_add(d_a, d_b, d_c, np.int32(N), block=(block_size, 1, 1), grid=(grid_size, 1, 1))

    cuda.memcpy_dtoh(c, d_c)
    end_time = time.time()

    print(f"Block Size: {block_size}, Time: {end_time - start_time:.5f} seconds")

!pip install pycuda


import pycuda.driver as cuda
import pycuda.autoinit
from pycuda.compiler import SourceModule
import numpy as np
import time

# CUDAカーネルコード
kernel_code = """
__global__ void matrixMultiply(float *A, float *B, float *C, int N) {
    int row = blockIdx.y * blockDim.y + threadIdx.y;
    int col = blockIdx.x * blockDim.x + threadIdx.x;

    if (row < N && col < N) {
        float value = 0;
        for (int k = 0; k < N; ++k) {
            value += A[row * N + k] * B[k * N + col];
        }
        C[row * N + col] = value;
    }
}
"""

# カーネルをコンパイル
mod = SourceModule(kernel_code)
matrix_multiply = mod.get_function("matrixMultiply")

# 行列サイズ
N = 10000  # 例: 1024x1024行列

# ホスト側のデータ
h_A = np.random.randn(N, N).astype(np.float32)
h_B = np.random.randn(N, N).astype(np.float32)
h_C = np.empty((N, N), dtype=np.float32)

# CPUで行列掛け算を実行
start_cpu = time.time()
h_C_cpu = np.dot(h_A, h_B)
end_cpu = time.time()

print(f"CPU Time: {end_cpu - start_cpu:.5f} seconds")

# デバイス側のデータ
d_A = cuda.mem_alloc(h_A.nbytes)
d_B = cuda.mem_alloc(h_B.nbytes)
d_C = cuda.mem_alloc(h_C.nbytes)

cuda.memcpy_htod(d_A, h_A)
cuda.memcpy_htod(d_B, h_B)

# グリッドとブロックの設定
block_size = 16
grid_size = (N + block_size - 1) // block_size

# GPUで行列掛け算を実行
start_gpu = time.time()
matrix_multiply(d_A, d_B, d_C, np.int32(N), block=(block_size, block_size, 1), grid=(grid_size, grid_size, 1))
cuda.Context.synchronize()
end_gpu = time.time()

print(f"GPU Time: {end_gpu - start_gpu:.5f} seconds")

# 結果をホスト側にコピー
cuda.memcpy_dtoh(h_C, d_C)

# 結果の比較
if np.allclose(h_C, h_C_cpu):
    print("CPU and GPU results are the same.")
else:
    print("CPU and GPU results differ.")

# デバイスメモリの解放
d_A.free()
d_B.free()
d_C.free()

!pip install pycuda

import pycuda.driver as cuda
import pycuda.autoinit
from pycuda.compiler import SourceModule
import numpy as np

# CUDAカーネルのコード
kernel_code = """
__global__ void vector_add(float *a, float *b, float *c, int N) {
    int i = threadIdx.x + blockIdx.x * blockDim.x;
    if (i < N) {
        c[i] = a[i] + b[i];
    }
}
"""

# CUDAカーネルのコンパイル
mod = SourceModule(kernel_code)
vector_add = mod.get_function("vector_add")

# 配列のサイズ
N = 1000

# ホスト側のデータ
a = np.random.randn(N).astype(np.float32)
b = np.random.randn(N).astype(np.float32)
c = np.empty(N, dtype=np.float32)

# デバイスメモリの確保
d_a = cuda.mem_alloc(a.nbytes)
d_b = cuda.mem_alloc(b.nbytes)
d_c = cuda.mem_alloc(c.nbytes)

# デバイスメモリにデータを転送
cuda.memcpy_htod(d_a, a)
cuda.memcpy_htod(d_b, b)

# スレッドとブロックの設定
block_size = 256  # 各ブロックに256スレッド
grid_size = (N + block_size - 1) // block_size  # グリッド内のブロック数

# CUDAカーネルの実行
vector_add(d_a, d_b, d_c, np.int32(N), block=(block_size, 1, 1), grid=(grid_size, 1, 1))

# 結果をホスト側に転送
cuda.memcpy_dtoh(c, d_c)

# 結果の表示
print("Result:", c)

!pip install pycuda

import pycuda.driver as cuda
import pycuda.autoinit
from pycuda.compiler import SourceModule
import numpy as np
import time

# CUDAカーネルのコード
kernel_code = """
__global__ void vector_add(float *a, float *b, float *c, int N) {
    int i = threadIdx.x + blockIdx.x * blockDim.x;
    if (i < N) {
        c[i] = a[i] + b[i];
    }
}
"""

# CUDAカーネルのコンパイル
mod = SourceModule(kernel_code)
vector_add = mod.get_function("vector_add")

# 配列のサイズ
N = 1000000

# ホスト側のデータ
a = np.random.randn(N).astype(np.float32)
b = np.random.randn(N).astype(np.float32)
c = np.empty(N, dtype=np.float32)

# デバイスメモリの確保
d_a = cuda.mem_alloc(a.nbytes)
d_b = cuda.mem_alloc(b.nbytes)
d_c = cuda.mem_alloc(c.nbytes)

cuda.memcpy_htod(d_a, a)
cuda.memcpy_htod(d_b, b)

# スレッドとブロックの設定
for block_size in [128, 256, 512, 1024]:
    grid_size = (N + block_size - 1) // block_size
    start_time = time.time()

    # CUDAカーネルの実行
    vector_add(d_a, d_b, d_c, np.int32(N), block=(block_size, 1, 1), grid=(grid_size, 1, 1))

    cuda.memcpy_dtoh(c, d_c)
    end_time = time.time()

    print(f"Block Size: {block_size}, Time: {end_time - start_time:.5f} seconds")