How to use multiple GPUs with Sionna RT?

[Zihao-Felix-Zhou]

Hi, I have a question about how to properly use multiple GPUs with Sionna RT. I'm trying to calculate paths using PathSolver() on my own scene. Looking forward to your reply, thank you!

# Configuration of the transmitter
scene.tx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="tr38901",
                             polarization="V")

# Configuration of the receiver
scene.rx_array = PlanarArray(num_rows=1,
                             num_cols=1,
                             vertical_spacing=0.5,
                             horizontal_spacing=0.5,
                             pattern="iso",
                             polarization="V")

# Place transmitter
tx = Transmitter("tx0",
                 position=mi.Point3f(131, 35, 10),
                 orientation=mi.Point3f(0.0, 0.0, 0.0))
scene.add(tx)

rxs = gen_user_grid(
    box_corners=[(-80, -80, 0), (220, 100, 0)],
    steps=[1, 1, 0],
    box_offsets=[0, 0, 2],  # user at 2m height
)

n_rx = len(rxs)
n_rx_in_scene = 100  # to compute in parallel
print(f"Adding users to the scene ({n_rx_in_scene} at a time)")
for rx_idx in range(n_rx_in_scene):
    scene.add(Receiver(name=f"rx_{rx_idx}", position=rxs[rx_idx], orientation=[0, 0, 0]))

my_compute_path_params = {
    #"scene": scene,
    "max_depth": 10,
    "los": True,  # enable line-of-sight paths
    "specular_reflection": True,
    "diffuse_reflection": False,
    "refraction": True,
    "synthetic_array": False,
    "seed": 41
}

# Compute the paths for each set of receiver positions
# Specifically, for each path, the corresponding channel coefficient, delay, the angles of departure and arrival,
# as well as the Doppler shifts are computed
path_list = []
n_rx_remaining = n_rx
for x in tqdm(range(int(n_rx / n_rx_in_scene) + 1), desc="Path computation"):
    if n_rx_remaining > 0:
        n_rx_remaining -= n_rx_in_scene
    else:
        break
    if x != 0:
        # modify current RXs in scene
        for rx_idx in range(n_rx_in_scene):
            if rx_idx + n_rx_in_scene * x < n_rx:
                scene.receivers[f"rx_{rx_idx}"].position = rxs[rx_idx + n_rx_in_scene * x]
            else:
                # remove the last receivers in the scene
                scene.remove(f"rx_{rx_idx}")

    p_solver = PathSolver()
    paths = p_solver(scene=scene, **my_compute_path_params)

    paths.normalize_delays = False  # sum min_tau to tau, or tau of 1st path is always = 0

    path_list.append(paths)

[merlinND]

Closing as duplicate of #553, see e.g. #553 (comment)