第一轮分析工作暂存
This commit is contained in:
Frank14f
@@ -0,0 +1,3 @@
|
||||
# CelerisLab/__init__.py
|
||||
|
||||
from .driver import FlowField
|
||||
@@ -0,0 +1,87 @@
|
||||
# CelerisLab/kernels/compiler.py
|
||||
|
||||
import subprocess
|
||||
import re
|
||||
import os
|
||||
|
||||
from .utils import FlowFieldConfig, CudaConfig
|
||||
|
||||
|
||||
def kernel_path(file_name: str) -> str:
|
||||
current_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
return os.path.join(current_dir, "kernels", file_name)
|
||||
|
||||
|
||||
def read_lines(file_path):
|
||||
with open(file_path, "r") as file:
|
||||
lines = file.readlines()
|
||||
return lines
|
||||
|
||||
|
||||
def write_lines(file_path, lines):
|
||||
with open(file_path, "w") as file:
|
||||
file.writelines(lines)
|
||||
|
||||
|
||||
def modify_macro(lines, macro_name, new_value):
|
||||
pattern = re.compile(rf"(#define\s+{macro_name}\s+)(\S+)")
|
||||
for i, line in enumerate(lines):
|
||||
if pattern.match(line):
|
||||
lines[i] = pattern.sub(rf"\g<1>{new_value}", line)
|
||||
break
|
||||
return lines
|
||||
|
||||
def modify_const(lines, const_name, new_type, new_value):
|
||||
pattern = re.compile(rf"(__constant__\s+)(\S+\s+{const_name}\s*=\s*)([^;]+)(;)")
|
||||
for i, line in enumerate(lines):
|
||||
if pattern.match(line):
|
||||
lines[i] = pattern.sub(rf"\g<1>{new_type} {const_name} = {new_value}\4", line)
|
||||
break
|
||||
return lines
|
||||
|
||||
def compile_kernel():
|
||||
subprocess.run(
|
||||
[
|
||||
"nvcc",
|
||||
"-ptx",
|
||||
kernel_path("kernel.cu"),
|
||||
"-o",
|
||||
kernel_path("kernel.ptx"),
|
||||
]
|
||||
)
|
||||
|
||||
def config_kernal(config_cuda: CudaConfig, config_field: FlowFieldConfig):
|
||||
lines = read_lines(kernel_path("macros.h"))
|
||||
lines = modify_macro(lines, "MULT_GPU", config_cuda.multi_gpu)
|
||||
lines = modify_macro(lines, "NT", config_cuda.threads_per_block)
|
||||
lines = modify_macro(lines, "X_1U", config_cuda.unit_dimensions[0])
|
||||
lines = modify_macro(lines, "Y_1U", config_cuda.unit_dimensions[1])
|
||||
lines = modify_macro(lines, "Z_1U", config_cuda.unit_dimensions[2])
|
||||
|
||||
if config_field.data_type == "FP32":
|
||||
lb_type = "float"
|
||||
else:
|
||||
raise ValueError(f"Unsupported data type {config_field.data_type}.")
|
||||
lines = modify_macro(lines, "LBtype", lb_type)
|
||||
lines = modify_macro(lines, "UX", config_field.field_dim_in_U[0])
|
||||
lines = modify_macro(lines, "UY", config_field.field_dim_in_U[1])
|
||||
lines = modify_macro(lines, "UZ", config_field.field_dim_in_U[2])
|
||||
lines = modify_macro(lines, "NX", config_field.field_dim_in_U[0] * config_cuda.unit_dimensions[0])
|
||||
lines = modify_macro(lines, "NY", config_field.field_dim_in_U[1] * config_cuda.unit_dimensions[1])
|
||||
lines = modify_macro(lines, "NZ", config_field.field_dim_in_U[2] * config_cuda.unit_dimensions[2])
|
||||
lines = modify_macro(lines, "DIM", config_field.dimensionality)
|
||||
lines = modify_macro(lines, "NQ", config_field.lattice)
|
||||
lines = modify_macro(lines, "VIS", config_field.viscosity)
|
||||
lines = modify_macro(lines, "U0", config_field.velocity)
|
||||
|
||||
write_lines(kernel_path("macros.h"), lines)
|
||||
|
||||
def config_object(n_obj: int):
|
||||
lines = read_lines(kernel_path("macros.h"))
|
||||
lines = modify_macro(lines, "N_OBJS", n_obj)
|
||||
write_lines(kernel_path("macros.h"), lines)
|
||||
|
||||
def config_sensor(n_sen: int):
|
||||
lines = read_lines(kernel_path("macros.h"))
|
||||
lines = modify_macro(lines, "N_SENS", n_sen)
|
||||
write_lines(kernel_path("macros.h"), lines)
|
||||
@@ -0,0 +1,409 @@
|
||||
# CelerisLab/driver.py
|
||||
|
||||
import pycuda.driver as cuda
|
||||
import numpy as np
|
||||
import struct
|
||||
from scipy.special import jv, expi
|
||||
from typing import List, Tuple, Union, Optional
|
||||
|
||||
from . import utils
|
||||
from . import preprocess as preproc
|
||||
from . import compiler
|
||||
|
||||
FLUID = 0b00000001
|
||||
SOLID = 0b00000010
|
||||
GAS = 0b00000100
|
||||
INTERFACE = 0b00001000
|
||||
SENSOR = 0b00010000
|
||||
V_TAYLOR = np.int32(1)
|
||||
|
||||
class FlowField:
|
||||
def __init__(
|
||||
self,
|
||||
field_config: utils.FlowFieldConfig,
|
||||
cuda_config: utils.CudaConfig,
|
||||
device_id: Union[int, List[int]] = None,
|
||||
):
|
||||
self.field_config = field_config
|
||||
self.cuda_config = cuda_config
|
||||
cuda.init()
|
||||
|
||||
# Sanity checks
|
||||
if cuda_config.multi_gpu:
|
||||
if device_id is None or isinstance(device_id, int):
|
||||
raise ValueError("Multi-GPU support requires a list of device IDs.")
|
||||
# self.devices = [cuda.Device(id) for id in device_id]
|
||||
raise NotImplementedError("Multi-GPU support is not implemented yet.")
|
||||
else:
|
||||
if isinstance(device_id, list):
|
||||
if len(device_id) > 1:
|
||||
raise ValueError(
|
||||
"Single-GPU mode does not support multiple device IDs."
|
||||
)
|
||||
device_id = device_id[0]
|
||||
elif device_id is None:
|
||||
device_id = 0
|
||||
utils.check_cuda_device_availability(device_id)
|
||||
self.device = cuda.Device(device_id)
|
||||
self.context = self.device.make_context()
|
||||
|
||||
utils.check_cuda_capability(field_config, cuda_config, device_id)
|
||||
|
||||
# Config kernel
|
||||
compiler.config_kernal(cuda_config, field_config)
|
||||
compiler.config_object(int(0))
|
||||
# compiler.config_sensor(int(0))
|
||||
|
||||
# Set constants
|
||||
if field_config.data_type == "FP32":
|
||||
self.DATA_TYPE = np.float32
|
||||
else:
|
||||
raise ValueError(f"Unsupported data type {field_config.data_type}.")
|
||||
|
||||
self.FIELD_SHAPE = tuple(
|
||||
size * unit
|
||||
for size, unit in zip(
|
||||
field_config.field_dim_in_U, cuda_config.unit_dimensions
|
||||
)
|
||||
)
|
||||
self.FIELD_SIZE = np.prod(self.FIELD_SHAPE)
|
||||
self.LATTICE = field_config.lattice
|
||||
self.DIM = field_config.dimensionality
|
||||
if field_config.lattice == 9 and field_config.dimensionality == 2:
|
||||
self.E = np.array(
|
||||
[0, 0, 1, 0, 0, 1, -1, 0, 0, -1, 1, 1, -1, 1, -1, -1, 1, -1],
|
||||
dtype=np.int32,
|
||||
).reshape(9, 2)
|
||||
self.OPP = np.array([0, 3, 4, 1, 2, 7, 8, 5, 6], dtype=np.int32)
|
||||
self.WW = np.array(
|
||||
[4 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 9, 1 / 36, 1 / 36, 1 / 36, 1 / 36],
|
||||
dtype=self.DATA_TYPE,
|
||||
)
|
||||
else:
|
||||
raise NotImplementedError(
|
||||
f"Unsupported lattice type {field_config.lattice} in {field_config.dimensionality} dimensions."
|
||||
)
|
||||
|
||||
# Compile kernel
|
||||
compiler.compile_kernel()
|
||||
self.ptx = cuda.module_from_file(compiler.kernel_path("kernel.ptx"))
|
||||
self.step = self.ptx.get_function("OneStep")
|
||||
initflow = self.ptx.get_function("InitTubeFlow")
|
||||
|
||||
# Initialize memory
|
||||
self.ddf = np.zeros(self.FIELD_SIZE * self.LATTICE, dtype=self.DATA_TYPE)
|
||||
self.ddf_save = np.zeros(self.FIELD_SIZE * self.LATTICE, dtype=self.DATA_TYPE)
|
||||
self.flag = np.ones(self.FIELD_SIZE, dtype=np.uint8)
|
||||
self.indx = np.zeros(self.FIELD_SIZE, dtype=np.int32)
|
||||
self.delta_curve = np.zeros(0, dtype=self.DATA_TYPE)
|
||||
self.vortex_config = np.zeros(7, dtype=float)
|
||||
|
||||
self.ddf_gpu = cuda.mem_alloc(self.ddf.nbytes)
|
||||
self.temp_gpu = cuda.mem_alloc(self.ddf.nbytes)
|
||||
self.flag_gpu = cuda.mem_alloc(self.flag.nbytes)
|
||||
self.indx_gpu = cuda.mem_alloc(self.indx.nbytes)
|
||||
self.delta_gpu = cuda.mem_alloc(1)
|
||||
self.vortex_gpu = cuda.mem_alloc(self.vortex_config.nbytes)
|
||||
self.error_flag = np.zeros(1, dtype=np.uint32)
|
||||
self.error_flag_gpu = cuda.mem_alloc(self.error_flag.nbytes)
|
||||
self.last_error_flag = 0
|
||||
|
||||
self.objects = {}
|
||||
self.action = np.zeros(0, dtype=self.DATA_TYPE)
|
||||
self.obs = np.zeros(0, dtype=self.DATA_TYPE)
|
||||
|
||||
initflow(
|
||||
self.flag_gpu,
|
||||
self.ddf_gpu,
|
||||
block=(self.cuda_config.threads_per_block, 1, 1),
|
||||
grid=(
|
||||
int(self.FIELD_SHAPE[0] / self.cuda_config.threads_per_block),
|
||||
int(self.FIELD_SHAPE[1]),
|
||||
int(self.FIELD_SHAPE[2]),
|
||||
),
|
||||
)
|
||||
cuda.memcpy_dtoh(self.flag, self.flag_gpu)
|
||||
cuda.memcpy_dtoh(self.ddf, self.ddf_gpu)
|
||||
|
||||
def add_cylinder(self, center: Tuple[float, float, float], radius: float, id_obj: Optional[int] = None):
|
||||
x_c, y_c, z_c = center
|
||||
|
||||
if (
|
||||
x_c - radius <= 0
|
||||
or x_c + radius >= self.FIELD_SHAPE[0] - 1
|
||||
or y_c - radius <= 0
|
||||
or y_c + radius >= self.FIELD_SHAPE[1] - 1
|
||||
):
|
||||
raise ValueError("Cylinder is out of bounds.")
|
||||
|
||||
index = self.delta_curve.size if self.delta_curve.size > 0 else 0
|
||||
|
||||
if self.DATA_TYPE == np.float32:
|
||||
id_object = np.int32(len(self.objects))
|
||||
# max_id = max(self.objects.keys())
|
||||
else:
|
||||
raise ValueError(f"Unsupported data type {self.DATA_TYPE}.")
|
||||
|
||||
for x in range(int(x_c - radius) - 1, int(x_c + radius) + 1):
|
||||
for y in range(int(y_c - radius) - 1, int(y_c + radius) + 1):
|
||||
if (x - x_c) ** 2 + (y - y_c) ** 2 < radius**2:
|
||||
k = x + y * self.FIELD_SHAPE[0]
|
||||
self.flag[k] = SOLID
|
||||
delta_temp = np.zeros(11, dtype=self.DATA_TYPE)
|
||||
delta_temp[0] = id_object.view(self.DATA_TYPE)
|
||||
for i in range(self.LATTICE):
|
||||
x_neb = x + self.E[i][0]
|
||||
y_neb = y + self.E[i][1]
|
||||
if (x_neb - x_c) ** 2 + (y_neb - y_c) ** 2 >= radius**2:
|
||||
self.flag[k] |= INTERFACE
|
||||
x_i, y_i = preproc.find_circle_intersection(
|
||||
x, y, x_neb, y_neb, x_c, y_c, radius
|
||||
)
|
||||
d_neb = np.sqrt((x_i - x_neb) ** 2 + (y_i - y_neb) ** 2)
|
||||
delta_temp[i] = d_neb / np.sqrt(
|
||||
self.E[i][0] ** 2 + self.E[i][1] ** 2
|
||||
)
|
||||
if self.flag[k] & INTERFACE:
|
||||
delta_temp[9] = (y_c - y) / radius
|
||||
delta_temp[10] = (x - x_c) / radius
|
||||
self.delta_curve = np.concatenate(
|
||||
(self.delta_curve, delta_temp)
|
||||
)
|
||||
self.indx[k] = index
|
||||
index += delta_temp.size
|
||||
|
||||
self.objects[id_object] = {
|
||||
"type": "cylinder",
|
||||
"center": center,
|
||||
"radius": radius,
|
||||
}
|
||||
|
||||
if hasattr(self, "delta_gpu"):
|
||||
self.delta_gpu.free()
|
||||
self.delta_gpu = cuda.mem_alloc(self.delta_curve.nbytes)
|
||||
|
||||
self.action = np.zeros(len(self.objects), dtype=self.DATA_TYPE)
|
||||
if hasattr(self, "action_gpu"):
|
||||
self.action_gpu.free()
|
||||
self.action_gpu = cuda.mem_alloc(self.action.nbytes)
|
||||
|
||||
self.obs = np.zeros(len(self.objects) * self.DIM, dtype=self.DATA_TYPE)
|
||||
if hasattr(self, "obs_gpu"):
|
||||
self.obs_gpu.free()
|
||||
self.obs_gpu = cuda.mem_alloc(self.obs.nbytes)
|
||||
|
||||
cuda.memcpy_htod(self.delta_gpu, self.delta_curve)
|
||||
cuda.memcpy_htod(self.flag_gpu, self.flag)
|
||||
cuda.memcpy_htod(self.indx_gpu, self.indx)
|
||||
|
||||
compiler.config_object(len(self.objects))
|
||||
compiler.compile_kernel()
|
||||
self.ptx = cuda.module_from_file(compiler.kernel_path("kernel.ptx"))
|
||||
self.step = self.ptx.get_function("OneStep")
|
||||
|
||||
def add_sensor(self, center: Tuple[float, float, float], radius: float):
|
||||
x_c, y_c, z_c = center
|
||||
|
||||
if (
|
||||
x_c - radius <= 0
|
||||
or x_c + radius >= self.FIELD_SHAPE[0] - 1
|
||||
or y_c - radius <= 0
|
||||
or y_c + radius >= self.FIELD_SHAPE[1] - 1
|
||||
):
|
||||
raise ValueError("Sensor is out of bounds.")
|
||||
|
||||
id_object = len(self.objects)
|
||||
for x in range(int(x_c - radius) - 1, int(x_c + radius) + 1):
|
||||
for y in range(int(y_c - radius) - 1, int(y_c + radius) + 1):
|
||||
if (x - x_c) ** 2 + (y - y_c) ** 2 < radius**2:
|
||||
k = x + y * self.FIELD_SHAPE[0]
|
||||
self.flag[k] |= SENSOR
|
||||
self.indx[k] = id_object
|
||||
|
||||
self.objects[id_object] = {
|
||||
"type": "sensor",
|
||||
"center": center,
|
||||
}
|
||||
|
||||
self.action = np.zeros(len(self.objects), dtype=self.DATA_TYPE)
|
||||
if hasattr(self, "action_gpu"):
|
||||
self.action_gpu.free()
|
||||
self.action_gpu = cuda.mem_alloc(self.action.nbytes)
|
||||
|
||||
self.obs = np.zeros(len(self.objects) * self.DIM, dtype=self.DATA_TYPE)
|
||||
if hasattr(self, "force_gpu"):
|
||||
self.obs_gpu.free()
|
||||
self.obs_gpu = cuda.mem_alloc(self.obs.nbytes)
|
||||
|
||||
cuda.memcpy_htod(self.flag_gpu, self.flag)
|
||||
cuda.memcpy_htod(self.indx_gpu, self.indx)
|
||||
|
||||
compiler.config_object(len(self.objects))
|
||||
compiler.compile_kernel()
|
||||
self.ptx = cuda.module_from_file(compiler.kernel_path("kernel.ptx"))
|
||||
self.step = self.ptx.get_function("OneStep")
|
||||
|
||||
def add_vortex(self, center: Tuple[float, float, float], radius: float, strength: float, direction: float, type: str):
|
||||
x_c, y_c, z_c = center
|
||||
|
||||
if (
|
||||
x_c - radius <= 0
|
||||
or x_c + radius >= self.FIELD_SHAPE[0] - 1
|
||||
or y_c - radius <= 0
|
||||
or y_c + radius >= self.FIELD_SHAPE[1] - 1
|
||||
):
|
||||
raise ValueError("Vortex is out of bounds.")
|
||||
|
||||
if type not in ["lamb", "oseen", "taylor"]:
|
||||
raise ValueError("Vortex type" + type + " is not supported.")
|
||||
|
||||
x = np.linspace(-x_c, self.FIELD_SHAPE[0] - 1 - x_c, self.FIELD_SHAPE[0])
|
||||
y = np.linspace(-y_c, self.FIELD_SHAPE[1] - 1 - y_c, self.FIELD_SHAPE[1])
|
||||
X, Y = np.meshgrid(x, y)
|
||||
r = np.sqrt(X**2 + Y**2)
|
||||
nu = self.field_config.viscosity
|
||||
theta = np.arctan2(Y, X)
|
||||
psi = np.zeros_like(r)
|
||||
|
||||
if type == "lamb":
|
||||
b = 3.831705970207512
|
||||
n = b / radius
|
||||
u0 = strength
|
||||
inside = r <= radius
|
||||
outside = r > radius
|
||||
|
||||
psi[inside] = (2 * u0 / n / jv(0, b) * jv(1, n * r[inside]) - u0 * r[inside]) * np.sin(theta[inside])
|
||||
psi[outside] = -u0 * radius**2 / r[outside] * np.sin(theta[outside])
|
||||
|
||||
u_vor = np.gradient(psi, axis=0)
|
||||
v_vor = -np.gradient(psi, axis=1)
|
||||
p_vor = -2 * (np.gradient(v_vor, axis=1) - np.gradient(u_vor, axis=0)) * psi - (u_vor**2 + v_vor**2) / 2
|
||||
elif type == "oseen":
|
||||
# 4 nu t = radius^2 / 4
|
||||
kappa = 2 * np.pi * radius **2 * strength
|
||||
u_vor = - kappa / (2 * np.pi * r) * (1 - np.exp(-4 * r**2 / radius**2)) * np.sin(theta)
|
||||
v_vor = kappa / (2 * np.pi * r) * (1 - np.exp(-4 * r**2 / radius**2)) * np.cos(theta)
|
||||
zeta = 4 * r**2 / radius**2
|
||||
p_vor = -kappa**2 / 8 / np.pi**2 / r**2 * (-2 * zeta * (expi(-zeta) - expi(-2 * zeta)) + (1 - np.exp(-zeta))**2)
|
||||
elif type == "taylor":
|
||||
# 4 nu t = radius^2
|
||||
M = strength * np.pi * radius**4 / 8 / nu
|
||||
u_vor = - M * r * 4 * nu / radius**4 * np.exp(-r**2 / radius**2) * np.sin(theta)
|
||||
v_vor = M * r * 4 * nu / radius**4 * np.exp(-r**2 / radius**2) * np.cos(theta)
|
||||
p_vor = -4 * M**2 * nu**2 * np.exp(-2 * r**2 / radius**2) / np.pi**2 / radius**6
|
||||
|
||||
cuda.memcpy_dtoh(self.ddf, self.ddf_gpu)
|
||||
ddf_temp = self.ddf.copy().reshape((self.LATTICE, self.FIELD_SHAPE[1], self.FIELD_SHAPE[0])).transpose(2, 1, 0)
|
||||
u_ddf = ddf_temp[:, :, 1] + ddf_temp[:, :, 5] + ddf_temp[:, :, 8] - ddf_temp[:, :, 3] - ddf_temp[:, :, 6] - ddf_temp[:, :, 7]
|
||||
v_ddf = ddf_temp[:, :, 2] + ddf_temp[:, :, 5] + ddf_temp[:, :, 6] - ddf_temp[:, :, 4] - ddf_temp[:, :, 7] - ddf_temp[:, :, 8]
|
||||
p_ddf = np.sum(ddf_temp, axis=2) / 3
|
||||
|
||||
for i in range(self.FIELD_SHAPE[0]):
|
||||
for j in range(self.FIELD_SHAPE[1]):
|
||||
k = i + j * self.FIELD_SHAPE[0]
|
||||
if (j == 0 or j == self.FIELD_SHAPE[1] - 1) or (i == 0 or i == self.FIELD_SHAPE[0] - 1):
|
||||
continue
|
||||
else:
|
||||
for e in range(self.LATTICE):
|
||||
u = u_ddf[i, j] + u_vor[j, i]
|
||||
v = v_ddf[i, j] + v_vor[j, i]
|
||||
p = p_ddf[i, j] + p_vor[j, i]
|
||||
eu = self.E[e][0] * u + self.E[e][1] * v
|
||||
u2 = u ** 2 + v ** 2
|
||||
self.ddf[k + e * self.FIELD_SIZE] = self.WW[e] * (3 * p + 3 * eu + 4.5 * eu ** 2 - 1.5 * u2)
|
||||
|
||||
cuda.memcpy_htod(self.ddf_gpu, self.ddf)
|
||||
|
||||
# def add_vortex_gpu(self, center: Tuple[float, float, float], radius: float, strength: float, direction: float, type: str):
|
||||
# x_c, y_c, z_c = center
|
||||
|
||||
# if (
|
||||
# x_c - radius <= 0
|
||||
# or x_c + radius >= self.FIELD_SHAPE[0] - 1
|
||||
# or y_c - radius <= 0
|
||||
# or y_c + radius >= self.FIELD_SHAPE[1] - 1
|
||||
# ):
|
||||
# raise ValueError("Vortex is out of bounds.")
|
||||
|
||||
# if type not in ["lamb", "oseen", "taylor"]:
|
||||
# raise ValueError("Vortex type" + type + " is not supported.")
|
||||
|
||||
# add_vortex = self.ptx.get_function("AddVortex")
|
||||
|
||||
# self.vortex_config[0:3] = np.array(center, dtype=float)
|
||||
# self.vortex_config[3] = radius
|
||||
# self.vortex_config[4] = strength
|
||||
# self.vortex_config[5] = direction
|
||||
# if type == "taylor":
|
||||
# self.vortex_config[6] =
|
||||
|
||||
def run(self, num_steps: int, action_target: np.ndarray):
|
||||
if (
|
||||
action_target.size != len(self.objects)
|
||||
or action_target.dtype != self.DATA_TYPE
|
||||
):
|
||||
raise ValueError("action data type or size does not match the objects.")
|
||||
elif len(self.objects) == 0:
|
||||
raise ValueError("No objects have been added to the flow field.")
|
||||
|
||||
weight = 0.1
|
||||
stream = cuda.Stream()
|
||||
action_pinned = cuda.pagelocked_empty_like(self.action)
|
||||
action_pinned[:] = self.action
|
||||
obs_pinned = cuda.pagelocked_empty_like(self.obs)
|
||||
self.error_flag[0] = 0
|
||||
cuda.memcpy_htod(self.error_flag_gpu, self.error_flag)
|
||||
self.obs[:] = 0
|
||||
for i in range(num_steps):
|
||||
action_pinned = (1 - weight) * action_pinned + weight * action_target
|
||||
cuda.memcpy_htod_async(self.action_gpu, action_pinned, stream)
|
||||
self.step(
|
||||
self.flag_gpu,
|
||||
self.ddf_gpu,
|
||||
self.temp_gpu,
|
||||
self.indx_gpu,
|
||||
self.delta_gpu,
|
||||
self.action_gpu,
|
||||
self.obs_gpu,
|
||||
self.error_flag_gpu,
|
||||
block=(self.cuda_config.threads_per_block, 1, 1),
|
||||
grid=(
|
||||
int(self.FIELD_SHAPE[0] / self.cuda_config.threads_per_block),
|
||||
int(self.FIELD_SHAPE[1]),
|
||||
int(self.FIELD_SHAPE[2]),
|
||||
),
|
||||
stream=stream,
|
||||
)
|
||||
self.ddf_gpu, self.temp_gpu = self.temp_gpu, self.ddf_gpu
|
||||
cuda.memcpy_dtoh_async(obs_pinned, self.obs_gpu, stream)
|
||||
cuda.memset_d32_async(self.obs_gpu, 0, self.obs.size, stream)
|
||||
self.obs += obs_pinned
|
||||
stream.synchronize()
|
||||
self.obs = (self.obs / num_steps).astype(self.DATA_TYPE)
|
||||
cuda.memcpy_dtoh(self.error_flag, self.error_flag_gpu)
|
||||
self.last_error_flag = int(self.error_flag[0])
|
||||
|
||||
def has_numeric_error(self) -> bool:
|
||||
return bool(self.last_error_flag != 0)
|
||||
|
||||
def apply_ddf(self):
|
||||
cuda.memcpy_htod(self.ddf_gpu, self.ddf)
|
||||
|
||||
def get_ddf(self):
|
||||
cuda.memcpy_dtoh(self.ddf, self.ddf_gpu)
|
||||
|
||||
def save_ddf(self):
|
||||
self.ddf_save = self.ddf.copy()
|
||||
|
||||
def restore_ddf(self):
|
||||
self.ddf = self.ddf_save.copy()
|
||||
|
||||
def __del__(self):
|
||||
# Shutdown order can invalidate current context before object cleanup.
|
||||
ctx = getattr(self, "context", None)
|
||||
if ctx is None:
|
||||
return
|
||||
try:
|
||||
ctx.pop()
|
||||
except Exception:
|
||||
pass
|
||||
@@ -0,0 +1,101 @@
|
||||
#include "macros.h"
|
||||
#include "const.h"
|
||||
|
||||
__device__ void Index_lattice(int &x, int &y, int &k) {
|
||||
// Only for D2
|
||||
x = threadIdx.x + NT * blockIdx.x;
|
||||
y = blockIdx.y;
|
||||
k = y * NX + x;
|
||||
}
|
||||
|
||||
__device__ void CollisionKernel(LBtype* g, LBtype* m) {
|
||||
// Only for D2Q9
|
||||
LBtype p, u, v;
|
||||
LBtype niu = 1.0 / (0.5 + 3 * VIS);
|
||||
|
||||
u = (g[1]+g[5]+g[8]-g[3]-g[6]-g[7])/RHO;
|
||||
v = (g[2]+g[5]+g[6]-g[4]-g[7]-g[8])/RHO;
|
||||
p = (g[0]+g[1]+g[2]+g[3]+g[4]+g[5]+g[6]+g[7]+g[8])/3.0;
|
||||
|
||||
m[0]= g[0] +g[1] +g[2] +g[3] +g[4] +g[5] +g[6] +g[7] +g[8];
|
||||
m[1]=-4*g[0] -g[1] -g[2] -g[3] -g[4]+2*g[5]+2*g[6]+2*g[7]+2*g[8];
|
||||
m[2]= 4*g[0]-2*g[1]-2*g[2]-2*g[3]-2*g[4] +g[5] +g[6] +g[7] +g[8];
|
||||
m[3]= g[1] -g[3] +g[5] -g[6] -g[7] +g[8];
|
||||
m[4]= -2*g[1] +2*g[3] +g[5] -g[6] -g[7] +g[8];
|
||||
m[5]= g[2] -g[4] +g[5] +g[6] -g[7] -g[8];
|
||||
m[6]= -2*g[2] +2*g[4] +g[5] +g[6] -g[7] -g[8];
|
||||
m[7]= g[1] -g[2] +g[3] -g[4];
|
||||
m[8]= g[5] -g[6] +g[7] -g[8];
|
||||
|
||||
m[0]=1.00*( 3*p -m[0]);
|
||||
m[1]=1.20*(-6*p +3*RHO*(u*u+v*v)-m[1]);
|
||||
m[2]=1.20*( 3*p -3*RHO*(u*u+v*v)-m[2]);
|
||||
m[3]=1.00*( RHO*u -m[3]);
|
||||
m[4]=1.20*(-RHO*u -m[4]);
|
||||
m[5]=1.00*( RHO*v -m[5]);
|
||||
m[6]=1.20*(-RHO*v -m[6]);
|
||||
m[7]= niu*( RHO*(u*u-v*v) -m[7]);
|
||||
m[8]= niu*( RHO*u*v -m[8]);
|
||||
|
||||
g[0]=g[0]+( m[0] -m[1] +m[2] )/ 9.0;
|
||||
g[1]=g[1]+(4*m[0] -m[1]-2*m[2]+6*m[3]-6*m[4] +9*m[7])/36.0;
|
||||
g[2]=g[2]+(4*m[0] -m[1]-2*m[2] +6*m[5]-6*m[6]-9*m[7])/36.0;
|
||||
g[3]=g[3]+(4*m[0] -m[1]-2*m[2]-6*m[3]+6*m[4] +9*m[7])/36.0;
|
||||
g[4]=g[4]+(4*m[0] -m[1]-2*m[2] -6*m[5]+6*m[6]-9*m[7])/36.0;
|
||||
g[5]=g[5]+(4*m[0]+2*m[1] +m[2]+6*m[3]+3*m[4]+6*m[5]+3*m[6]+9*m[8])/36.0;
|
||||
g[6]=g[6]+(4*m[0]+2*m[1] +m[2]-6*m[3]-3*m[4]+6*m[5]+3*m[6]-9*m[8])/36.0;
|
||||
g[7]=g[7]+(4*m[0]+2*m[1] +m[2]-6*m[3]-3*m[4]-6*m[5]-3*m[6]+9*m[8])/36.0;
|
||||
g[8]=g[8]+(4*m[0]+2*m[1] +m[2]+6*m[3]+3*m[4]-6*m[5]-3*m[6]-9*m[8])/36.0;
|
||||
}
|
||||
|
||||
__device__ void ParabolicInlet(LBtype* f, LBtype* f_neb, LBtype y) {
|
||||
LBtype p, u, v, yy;
|
||||
LBtype feq1, feq5, feq8, feqn1, feqn5, feqn8;
|
||||
|
||||
p=(f_neb[0]+f_neb[1]+f_neb[2]+f_neb[3]+f_neb[4]+f_neb[5]+f_neb[6]+f_neb[7]+f_neb[8])/3.0;
|
||||
yy=(y-0.5*(NY-1))/(NY-2.0);
|
||||
u=U0*1.5*(1-4*yy*yy);
|
||||
v=0.0;
|
||||
|
||||
feq1=(2*p+RHO*(2*u*u+2*u -v*v) )/ 6.0;
|
||||
feq5=( p+RHO*( u*u+3*u*v+u+v*v+v))/12.0;
|
||||
feq8=( p+RHO*( u*u-3*u*v+u+v*v-v))/12.0;
|
||||
|
||||
u=(f_neb[1]+f_neb[5]+f_neb[8]-f_neb[3]-f_neb[6]-f_neb[7])/RHO;
|
||||
v=(f_neb[2]+f_neb[5]+f_neb[6]-f_neb[4]-f_neb[7]-f_neb[8])/RHO;
|
||||
|
||||
feqn1=(2*p+RHO*(2*u*u+2*u -v*v) )/ 6.0;
|
||||
feqn5=( p+RHO*( u*u+3*u*v+u+v*v+v))/12.0;
|
||||
feqn8=( p+RHO*( u*u-3*u*v+u+v*v-v))/12.0;
|
||||
|
||||
f[1]=f_neb[1]-feqn1+feq1;
|
||||
f[5]=f_neb[5]-feqn5+feq5;
|
||||
f[8]=f_neb[8]-feqn8+feq8;
|
||||
}
|
||||
|
||||
__device__ void PressureOutlet(LBtype* f, LBtype* f_neb, LBtype y) {
|
||||
// Edit to Parabolic Outlet temporarily
|
||||
LBtype p, u, v, yy;
|
||||
LBtype feq3, feq6, feq7, feqn3, feqn6, feqn7;
|
||||
|
||||
p=0.0;
|
||||
|
||||
yy=(y-0.5*(NY-1))/(NY-2.0);
|
||||
u=U0*1.5*(1-4*yy*yy);
|
||||
v=0.0;
|
||||
|
||||
feq3=(2*p-RHO*(-2*u*u+2*u +v*v) )/ 6.0;
|
||||
feq6=( p+RHO*( u*u-3*u*v-u+v*v+v))/12.0;
|
||||
feq7=( p+RHO*( u*u+3*u*v-u+v*v-v))/12.0;
|
||||
|
||||
u=(f_neb[1]+f_neb[5]+f_neb[8]-f_neb[3]-f_neb[6]-f_neb[7])/RHO;
|
||||
v=(f_neb[2]+f_neb[5]+f_neb[6]-f_neb[4]-f_neb[7]-f_neb[8])/RHO;
|
||||
// p=(f_neb[0]+f_neb[1]+f_neb[2]+f_neb[3]+f_neb[4]+f_neb[5]+f_neb[6]+f_neb[7]+f_neb[8])/3.0;
|
||||
feqn3=(2*p-RHO*(-2*u*u+2*u +v*v) )/ 6.0;
|
||||
feqn6=( p+RHO*( u*u-3*u*v-u+v*v+v))/12.0;
|
||||
feqn7=( p+RHO*( u*u+3*u*v-u+v*v-v))/12.0;
|
||||
|
||||
f[3]=f_neb[3]-feqn3+feq3;
|
||||
f[6]=f_neb[6]-feqn6+feq6;
|
||||
f[7]=f_neb[7]-feqn7+feq7;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
// CelerisLab/kernels/const.h
|
||||
|
||||
#ifndef CONST_H
|
||||
#define CONST_H
|
||||
|
||||
__constant__ int e[9][2] = {{0, 0}, {1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {-1, -1}, {1, -1}};
|
||||
__constant__ int opp[9] = {0, 3, 4, 1, 2, 7, 8, 5, 6};
|
||||
__constant__ float w[9] = {4/9., 1/9., 1/9., 1/9., 1/9., 1/36., 1/36., 1/36., 1/36.};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,234 @@
|
||||
// CelerisLab/kernels/kernel.cu
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <cuda.h>
|
||||
|
||||
#include "macros.h"
|
||||
#include "const.h"
|
||||
#include "D2Q9.cu"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
__global__ void OneStep(uint8_t *flag, LBtype *f, LBtype *f_temp, int32_t *indx, LBtype *delta, LBtype *action, LBtype *obs, uint32_t *error_flag)
|
||||
{
|
||||
__shared__ LBtype f_share[NT * NQ];
|
||||
__shared__ LBtype obs_share[(N_OBJS * DIM > 0) ? N_OBJS * DIM : 1];
|
||||
|
||||
int x, y, k;
|
||||
LBtype g[NQ], m[NQ];
|
||||
Index_lattice(x, y, k); // Only for D2
|
||||
int totalCells = NX * NY;
|
||||
int id = indx[k];
|
||||
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
f_share[threadIdx.x + i * NT] = f[k + i * totalCells];
|
||||
}
|
||||
for (int i = threadIdx.x; i < N_OBJS * DIM; i += NT)
|
||||
{
|
||||
obs_share[i] = 0;
|
||||
}
|
||||
|
||||
__syncthreads();
|
||||
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
g[i] = f_share[threadIdx.x + i * NT];
|
||||
}
|
||||
|
||||
if (flag[k] & FLUID)
|
||||
{
|
||||
CollisionKernel(g, m);
|
||||
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
if (isnan((double)g[i]) || isinf((double)g[i]))
|
||||
{
|
||||
atomicOr(error_flag, (uint32_t)1);
|
||||
}
|
||||
f_share[threadIdx.x + i * NT] = g[i];
|
||||
}
|
||||
}
|
||||
else if (flag[k] & SOLID)
|
||||
{
|
||||
if (x == 0)
|
||||
{
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
m[i] = f_share[threadIdx.x + i * NT + 1];
|
||||
}
|
||||
ParabolicInlet(g, m, y);
|
||||
}
|
||||
else if (x == NX - 1)
|
||||
{
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
m[i] = f_share[threadIdx.x + i * NT - 1];
|
||||
}
|
||||
PressureOutlet(g, m, y);
|
||||
}
|
||||
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
if (isnan((double)g[i]) || isinf((double)g[i]))
|
||||
{
|
||||
atomicOr(error_flag, (uint32_t)1);
|
||||
}
|
||||
f_share[threadIdx.x + i * NT] = g[i];
|
||||
}
|
||||
}
|
||||
|
||||
__syncthreads();
|
||||
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
int x_neb = x + e[i][0];
|
||||
int y_neb = y + e[i][1];
|
||||
|
||||
if (y != 0 && y != NY - 1)
|
||||
{
|
||||
if ((y == 1 && y_neb == 0) || (y == NY - 2 && y_neb == NY - 1))
|
||||
{
|
||||
f_temp[k + opp[i] * totalCells] = f_share[threadIdx.x + i * NT];
|
||||
}
|
||||
else
|
||||
{
|
||||
int k_neb = ((y_neb * NX + x_neb) + totalCells) % totalCells;
|
||||
f_temp[k_neb + i * totalCells] = f_share[threadIdx.x + i * NT];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
__syncthreads();
|
||||
|
||||
if (flag[k] & SOLID && flag[k] & INTERFACE)
|
||||
{
|
||||
LBtype Uw, Vw;
|
||||
int id_obj = *reinterpret_cast<int *>(&delta[id]);
|
||||
Uw = action[id_obj] * delta[id + 9];
|
||||
Vw = action[id_obj] * delta[id + 10];
|
||||
|
||||
int x_neb, y_neb, k_neb;
|
||||
for (int i = 1; i < 9; i++)
|
||||
{
|
||||
x_neb = x + e[i][0];
|
||||
y_neb = y + e[i][1];
|
||||
k_neb = x_neb + y_neb * NX;
|
||||
if (flag[k_neb] & FLUID)
|
||||
{
|
||||
LBtype q = delta[id + i];
|
||||
int k_neb2 = (y + 2 * e[i][1]) * NX + (x + 2 * e[i][0]);
|
||||
LBtype temp = 6 * w[i] * (e[i][0] * Uw + e[i][1] * Vw);
|
||||
f_temp[k_neb + i * totalCells] = (q * f_temp[k + opp[i] * totalCells] \
|
||||
+ (1 - q) * f_temp[k_neb + opp[i] * totalCells] \
|
||||
+ q * f_temp[k_neb2 + i * totalCells] + temp) / (1 + q);
|
||||
f_temp[k + i * totalCells] = temp * Uw;
|
||||
k_neb2 = (y - e[i][1]) * NX + (x - e[i][0]);
|
||||
f_temp[k_neb2 + i * totalCells] = temp * Vw;
|
||||
|
||||
temp = f_temp[k_neb + i * totalCells] + f_temp[k + opp[i] * totalCells];
|
||||
k_neb2 = (y - e[i][1]) * NX + (x - e[i][0]);
|
||||
atomicAdd(&obs_share[DIM * id_obj], -temp * e[i][0] + f_temp[k + i * totalCells]);
|
||||
atomicAdd(&obs_share[DIM * id_obj + 1], -temp * e[i][1] + f_temp[k_neb2 + i * totalCells]);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (flag[k] & SENSOR)
|
||||
{
|
||||
LBtype u, v;
|
||||
u = (g[1] + g[5] + g[8] - g[3] - g[6] - g[7]) / RHO;
|
||||
v = (g[2] + g[5] + g[6] - g[4] - g[7] - g[8]) / RHO;
|
||||
if (isnan((double)u) || isinf((double)u) || isnan((double)v) || isinf((double)v))
|
||||
{
|
||||
atomicOr(error_flag, (uint32_t)1);
|
||||
}
|
||||
atomicAdd(&obs_share[DIM * id], u);
|
||||
atomicAdd(&obs_share[DIM * id + 1], v);
|
||||
}
|
||||
|
||||
__syncthreads();
|
||||
|
||||
for (int i = threadIdx.x; i < N_OBJS * DIM; i += NT)
|
||||
{
|
||||
atomicAdd(&obs[i], obs_share[i]);
|
||||
}
|
||||
}
|
||||
|
||||
__global__ void InitTubeFlow(uint8_t *flag, LBtype *f)
|
||||
{
|
||||
__shared__ LBtype f_share[NT * NQ];
|
||||
__shared__ uint8_t flag_share[NT];
|
||||
int x, y, k;
|
||||
LBtype u;
|
||||
Index_lattice(x, y, k);
|
||||
int totalCells = NX * NY;
|
||||
|
||||
flag_share[threadIdx.x] = flag[k];
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
f_share[threadIdx.x + i * NT] = f[k + i * totalCells];
|
||||
}
|
||||
|
||||
__syncthreads();
|
||||
|
||||
u = U0 * 1.5 * (1 - 4 * (y - 0.5 * (NY - 1)) * (y - 0.5 * (NY - 1)) / ((NY - 2) * (NY - 2)));
|
||||
if (y == 0 || y == NY - 1 || x == 0 || x == NX - 1)
|
||||
{
|
||||
flag_share[threadIdx.x] = SOLID;
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
f_share[threadIdx.x + i * NT] = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
flag_share[threadIdx.x] = FLUID;
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
f_share[threadIdx.x + i * NT] = w[i] * RHO * (3 * e[i][0] * u + \
|
||||
4.5 * e[i][0] * e[i][0] * u * u - 1.5 * u * u);
|
||||
}
|
||||
}
|
||||
|
||||
__syncthreads();
|
||||
|
||||
flag[k] = flag_share[threadIdx.x];
|
||||
for (int i = 0; i < NQ; i++)
|
||||
{
|
||||
f[k + i * totalCells] = f_share[threadIdx.x + i * NT];
|
||||
}
|
||||
}
|
||||
|
||||
// __global__ void AddVortex(LBtype *f, int32_t *config)
|
||||
// {
|
||||
// __shared__ LBtype f_share[NT * NQ];
|
||||
// int x, y, k;
|
||||
// LBtype u, v, u_vor, v_vor;
|
||||
// Index_lattice(x, y, k);
|
||||
// int totalCells = NX * NY;
|
||||
|
||||
// for (int i = 0; i < NQ; i++)
|
||||
// {
|
||||
// f_share[threadIdx.x + i * NT] = f[k + i * totalCells];
|
||||
// }
|
||||
|
||||
// __syncthreads();
|
||||
|
||||
// u = f_share[threadIdx.x + 1 * NT] - f_share[threadIdx.x + 3 * NT] + f_share[threadIdx.x + 5 * NT] - f_share[threadIdx.x + 6 * NT] - f_share[threadIdx.x + 7 * NT] + f_share[threadIdx.x + 8 * NT];
|
||||
// v = f_share[threadIdx.x + 2 * NT] - f_share[threadIdx.x + 4 * NT] + f_share[threadIdx.x + 5 * NT] + f_share[threadIdx.x + 6 * NT] - f_share[threadIdx.x + 7 * NT] - f_share[threadIdx.x + 8 * NT];
|
||||
|
||||
// if type & V_TAYLOR
|
||||
// {
|
||||
// u_vor = -2 * PI * U0 * sin(2 * PI * x / NX) * sin(2 * PI * y / NY);
|
||||
// v_vor = 2 * PI * U0 * cos(2 * PI * x / NX) * cos(2 * PI * y / NY);
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// u_vor = 0;
|
||||
// v_vor = 0;
|
||||
// }
|
||||
|
||||
|
||||
// }
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
// CelerisLab/kernels/macros.h
|
||||
|
||||
// cuda parameters
|
||||
#define MULT_GPU False
|
||||
#define NT 128
|
||||
#define X_1U 128
|
||||
#define Y_1U 32
|
||||
#define Z_1U 1
|
||||
|
||||
// flow parameters
|
||||
#define LBtype float
|
||||
#define UX 10
|
||||
#define UY 16
|
||||
#define UZ 1
|
||||
#define NX 1280
|
||||
#define NY 512
|
||||
#define NZ 1
|
||||
#define DIM 2
|
||||
#define NQ 9
|
||||
#define VIS 0.008
|
||||
#define RHO 1.0
|
||||
#define U0 0.02
|
||||
|
||||
// constants
|
||||
#define PI 3.141592653589793238
|
||||
#define FLUID 0b00000001
|
||||
#define SOLID 0b00000010
|
||||
#define GAS 0b00000100
|
||||
#define INTERFACE 0b00001000
|
||||
#define SENSOR 0b00010000
|
||||
|
||||
// vortex type
|
||||
#define V_TAYLOR 0b00000001
|
||||
|
||||
// variables
|
||||
#define N_OBJS 7
|
||||
// #define N_SENS 2
|
||||
@@ -0,0 +1,2 @@
|
||||
#include "macros.h"
|
||||
#include "const.h"
|
||||
@@ -0,0 +1,40 @@
|
||||
# CelerisLab/preprocess.py
|
||||
|
||||
import math
|
||||
import numpy as np
|
||||
from typing import Tuple
|
||||
|
||||
FLUID = 0b00000001
|
||||
SOLID = 0b00000010
|
||||
GAS = 0b00000100
|
||||
INTERFACE = 0b00001000
|
||||
SENSOR = 0b00010000
|
||||
|
||||
|
||||
def find_circle_intersection(x, y, x_neb, y_neb, xc, yc, r0):
|
||||
dx, dy = x_neb - x, y_neb - y
|
||||
a = dx ** 2 + dy ** 2
|
||||
b = 2 * (dx * (x - xc) + dy * (y - yc))
|
||||
c = (x - xc) ** 2 + (y - yc) ** 2 - r0 ** 2
|
||||
det = b ** 2 - 4 * a * c
|
||||
|
||||
if det < 0:
|
||||
return None
|
||||
|
||||
t1 = (-b + math.sqrt(det)) / (2 * a)
|
||||
t2 = (-b - math.sqrt(det)) / (2 * a)
|
||||
|
||||
if 0 <= t1 <= 1:
|
||||
return x + t1 * dx, y + t1 * dy
|
||||
elif 0 <= t2 <= 1:
|
||||
return x + t2 * dx, y + t2 * dy
|
||||
else:
|
||||
return None
|
||||
|
||||
def find_sensor_area(radius):
|
||||
area = 0
|
||||
for i in range(np.floor(-radius), np.ceil(radius)):
|
||||
for j in range(np.floor(-radius), np.ceil(radius)):
|
||||
if i ** 2 + j ** 2 <= radius ** 2:
|
||||
area += 1
|
||||
return area
|
||||
@@ -0,0 +1,256 @@
|
||||
# CelerisLab/utils.py
|
||||
|
||||
import pycuda.driver as cuda
|
||||
import subprocess
|
||||
import json
|
||||
|
||||
from typing import NamedTuple, Optional, List, Tuple, Union
|
||||
|
||||
|
||||
class CudaDeviceInfo(NamedTuple):
|
||||
name: str
|
||||
compute_capability: str
|
||||
multiprocessors: int
|
||||
total_global_memory: int
|
||||
max_shared_memory_per_block: int
|
||||
max_threads_per_block: int
|
||||
max_blocks_per_multiprocessor: int
|
||||
device_interconnect: Optional[str] = None
|
||||
|
||||
|
||||
class FlowFieldConfig(NamedTuple):
|
||||
data_type: str
|
||||
dimensionality: int
|
||||
lattice: int
|
||||
field_dim_in_U: Tuple[int, int, int]
|
||||
viscosity: float
|
||||
velocity: float
|
||||
boundary_conditions: Tuple[str, str, str, str, str, str]
|
||||
|
||||
|
||||
class CudaConfig(NamedTuple):
|
||||
multi_gpu: bool
|
||||
gpu_connection: str
|
||||
required_cuda_capability: str
|
||||
threads_per_block: int
|
||||
unit_dimensions: Tuple[int, int, int]
|
||||
|
||||
|
||||
def check_cuda_device_availability(device_id=0):
|
||||
if cuda.Device.count() == 0:
|
||||
raise RuntimeError("No CUDA device is available.")
|
||||
|
||||
if device_id < 0 or device_id >= cuda.Device.count():
|
||||
raise ValueError(
|
||||
f"Invalid device_id {device_id}. Must be between 0 and {cuda.Device.count() - 1}."
|
||||
)
|
||||
|
||||
try:
|
||||
subprocess.check_output(["nvidia-smi", "--version"])
|
||||
except subprocess.CalledProcessError:
|
||||
raise RuntimeError("nvidia-smi is not available or not installed correctly.")
|
||||
|
||||
|
||||
def query_cuda_device_info(device_id=0) -> CudaDeviceInfo:
|
||||
check_cuda_device_availability(device_id)
|
||||
|
||||
try:
|
||||
output = subprocess.check_output(
|
||||
["nvidia-smi", "-q", "-d", "TOPOLOGY", "-i", str(device_id)], text=True
|
||||
)
|
||||
if "NVLink" in output:
|
||||
device_interconnect = "NVLink"
|
||||
elif "PCIe" in output:
|
||||
device_interconnect = "PCIe"
|
||||
else:
|
||||
device_interconnect = "Unknown"
|
||||
except Exception as e:
|
||||
device_interconnect = None
|
||||
|
||||
device = cuda.Device(device_id)
|
||||
|
||||
return CudaDeviceInfo(
|
||||
name=device.name(),
|
||||
compute_capability=f"{device.compute_capability()[0]}.{device.compute_capability()[1]}",
|
||||
multiprocessors=device.get_attribute(
|
||||
cuda.device_attribute.MULTIPROCESSOR_COUNT
|
||||
),
|
||||
total_global_memory=device.total_memory(),
|
||||
max_shared_memory_per_block=device.get_attribute(
|
||||
cuda.device_attribute.MAX_SHARED_MEMORY_PER_BLOCK
|
||||
),
|
||||
max_threads_per_block=device.get_attribute(
|
||||
cuda.device_attribute.MAX_THREADS_PER_BLOCK
|
||||
),
|
||||
max_blocks_per_multiprocessor=device.get_attribute(
|
||||
cuda.device_attribute.MAX_BLOCKS_PER_MULTIPROCESSOR
|
||||
),
|
||||
device_interconnect=device_interconnect,
|
||||
)
|
||||
|
||||
|
||||
def load_flow_field_config(config_path: str) -> FlowFieldConfig:
|
||||
try:
|
||||
with open(config_path, "r") as file:
|
||||
config = json.load(file)
|
||||
|
||||
required_keys = [
|
||||
"data_type",
|
||||
"dimensionality",
|
||||
"lattice",
|
||||
"field_dim_in_U",
|
||||
"viscosity",
|
||||
"boundary_conditions",
|
||||
]
|
||||
if not all(key in config for key in required_keys):
|
||||
raise ValueError("Missing required configuration items.")
|
||||
|
||||
if config["data_type"] not in ["FP32", "FP64"]:
|
||||
raise ValueError("Data type must be either FP32 or FP64.")
|
||||
|
||||
if config["dimensionality"] not in [2, 3]:
|
||||
raise ValueError("Dimensionality must be either 2 or 3.")
|
||||
|
||||
if config["dimensionality"] == 2 and config["field_dim_in_U"][2] != 1:
|
||||
raise ValueError(
|
||||
"Field dimensions must be 1 in the third dimension for 2D simulations."
|
||||
)
|
||||
|
||||
if config["lattice"] not in [9]:
|
||||
raise ValueError("Lattice must be either 9 or 19.")
|
||||
|
||||
boundary_conditions = tuple(
|
||||
condition
|
||||
for key in ["x", "y", "z"]
|
||||
for condition in config["boundary_conditions"].get(key, [])
|
||||
)
|
||||
if len(boundary_conditions) != 6:
|
||||
raise ValueError("Boundary conditions must contain exactly six elements.")
|
||||
|
||||
return FlowFieldConfig(
|
||||
data_type=config["data_type"],
|
||||
dimensionality=config["dimensionality"],
|
||||
lattice=config["lattice"],
|
||||
field_dim_in_U=tuple(config["field_dim_in_U"]),
|
||||
viscosity=config["viscosity"],
|
||||
velocity=config["velocity"],
|
||||
boundary_conditions=boundary_conditions,
|
||||
)
|
||||
except Exception as e:
|
||||
raise RuntimeError(f"Failed to load or parse the flow field configuration: {e}")
|
||||
|
||||
|
||||
def load_cuda_config(config_path: str) -> CudaConfig:
|
||||
try:
|
||||
with open(config_path, "r") as file:
|
||||
config = json.load(file)
|
||||
|
||||
required_keys = [
|
||||
"multi_gpu",
|
||||
"gpu_connection",
|
||||
"required_cuda_capability",
|
||||
"threads_per_block",
|
||||
"X_1U",
|
||||
"Y_1U",
|
||||
"Z_1U",
|
||||
]
|
||||
|
||||
if not all(key in config for key in required_keys):
|
||||
raise ValueError("Missing required configuration items.")
|
||||
|
||||
return CudaConfig(
|
||||
multi_gpu=config["multi_gpu"],
|
||||
gpu_connection=config["gpu_connection"],
|
||||
required_cuda_capability=config["required_cuda_capability"],
|
||||
threads_per_block=config["threads_per_block"],
|
||||
unit_dimensions=(config["X_1U"], config["Y_1U"], config["Z_1U"]),
|
||||
)
|
||||
except Exception as e:
|
||||
raise RuntimeError(f"Failed to load or parse the CUDA configuration: {e}")
|
||||
|
||||
|
||||
def check_cuda_capability(
|
||||
field_config: FlowFieldConfig,
|
||||
cuda_config: CudaConfig,
|
||||
device_id: Union[int, List[int]] = None,
|
||||
):
|
||||
SAFE_FACTOR = 0.8
|
||||
|
||||
if cuda_config.multi_gpu:
|
||||
if device_id is None or isinstance(device_id, int):
|
||||
raise ValueError("Multi-GPU support requires a list of device IDs.")
|
||||
raise NotImplementedError("Multi-GPU support is not implemented yet.")
|
||||
else:
|
||||
if isinstance(device_id, list):
|
||||
if len(device_id) > 1:
|
||||
raise ValueError(
|
||||
"Single-GPU mode does not support multiple device IDs."
|
||||
)
|
||||
device_id = device_id[0]
|
||||
elif device_id is None:
|
||||
device_id = 0
|
||||
device_info = query_cuda_device_info(device_id)
|
||||
|
||||
if device_info.compute_capability != cuda_config.required_cuda_capability:
|
||||
raise ValueError(
|
||||
f"Device {device_info.name} has compute capability {device_info.compute_capability}, but {cuda_config.required_cuda_capability} is required."
|
||||
)
|
||||
|
||||
field_size = sum(
|
||||
size * unit
|
||||
for size, unit in zip(
|
||||
field_config.field_dim_in_U, cuda_config.unit_dimensions
|
||||
)
|
||||
)
|
||||
if (
|
||||
device_info.total_global_memory * SAFE_FACTOR
|
||||
< calc_field_memory_consumption(
|
||||
field_size,
|
||||
field_config.dimensionality,
|
||||
field_config.lattice,
|
||||
field_config.data_type,
|
||||
)
|
||||
):
|
||||
raise ValueError(
|
||||
f"Device {device_info.name} does not have enough memory to store the flow field."
|
||||
)
|
||||
|
||||
if (
|
||||
device_info.max_threads_per_block * SAFE_FACTOR
|
||||
< cuda_config.threads_per_block
|
||||
):
|
||||
raise ValueError(
|
||||
f"Device {device_info.name} does not have enough threads per block to run the simulation."
|
||||
)
|
||||
|
||||
block_size = cuda_config.threads_per_block
|
||||
if (
|
||||
device_info.max_shared_memory_per_block * SAFE_FACTOR
|
||||
< 2
|
||||
* calc_field_memory_consumption(
|
||||
block_size,
|
||||
field_config.dimensionality,
|
||||
field_config.lattice,
|
||||
field_config.data_type,
|
||||
)
|
||||
):
|
||||
raise ValueError(
|
||||
f"Device {device_info.name} does not have enough shared memory per block to run the simulation."
|
||||
)
|
||||
|
||||
|
||||
def calc_field_memory_consumption(
|
||||
field_size: int, dimensionality: int, directions: int, data_type: str
|
||||
) -> int:
|
||||
if data_type == "FP32":
|
||||
data_size = 4
|
||||
elif data_type == "FP64":
|
||||
data_size = 8
|
||||
else:
|
||||
raise ValueError(f"Unsupported data type {data_type}.")
|
||||
|
||||
return (
|
||||
field_size * directions * data_size * 2
|
||||
+ field_size * dimensionality * data_size
|
||||
+ field_size
|
||||
)
|
||||
Reference in New Issue
Block a user