Creating RigidPrim of an XformPrim leads to CUDA crashes

Hello,

I am using OmniIsaacGymEnv (GitHub - NVIDIA-Omniverse/OmniIsaacGymEnvs: Reinforcement Learning Environments for Omniverse Isaac Gym), and I get error when using custom visualization markers.

Essentially, I create a VisualPin following the same template as the VisualSphere or other USDGeom shapes.
I also create FixedPin, and DynamicPin. Then I use this pin instead of the DynamicSphere in tasks such as the Crazyflie, however, when I do that the simulation crashes. The interesting thing is that it didn’t crash with the previous version of Omniverse (2022.2.0).

I think the issue comes from the fact that I base my marker out of an XformPrim, but I could also do something completely wrong. I have attached the crashlogs and the code I use.

Thanks in advance,

Regards,

Antoine

Here is the the crash logs:

PxgCudaDeviceMemoryAllocator fail to allocate memory 268435456 bytes!! Result = 2
PxgCudaDeviceMemoryAllocator fail to allocate memory 67108864 bytes!! Result = 2
2023-04-20 15:05:14 [21,747ms] [Error] [omni.physx.plugin] PhysX error: SynchronizeStreams cuEventRecord failed with error 700
, FILE /buildAgent/work/16dcef52b68a730f/source/gpucommon/include/PxgCudaUtils.h, LINE 53
2023-04-20 15:05:14 [21,747ms] [Error] [omni.physx.plugin] Cuda context manager error, simulation will be stopped and new cuda context manager will be created.
2023-04-20 15:05:14 [21,748ms] [Error] [omni.physx.plugin] PhysX error: SynchronizeStreams cuStreamWaitEvent failed with error 700
, FILE /buildAgent/work/16dcef52b68a730f/source/gpucommon/include/PxgCudaUtils.h, LINE 59
2023-04-20 15:05:14 [21,748ms] [Error] [omni.physx.plugin] Cuda context manager error, simulation will be stopped and new cuda context manager will be created.
2023-04-20 15:05:14 [21,748ms] [Error] [omni.physx.plugin] PhysX error: memcpy failed fail!
  700, FILE /buildAgent/work/16dcef52b68a730f/source/gpunarrowphase/src/PxgNarrowphaseCore.cpp, LINE 2077

A LOT OF CUDA ERRORS

Error executing job with overrides: ['task=Crazyflie', 'num_envs=512', 'headless=False', 'max_iterations=1000', 'task.sim.dt=0.02']
Traceback (most recent call last):
  File "scripts/rlgames_train.py", line 115, in parse_hydra_configs
    task = initialize_task(cfg_dict, env)
  File "/home/antoine/Documents/Orbitals/Omniverse/omniisaacgymenvs/utils/task_util.py", line 90, in initialize_task
    env.set_task(task=task, sim_params=sim_config.get_physics_params(), backend="torch", init_sim=init_sim)
  File "/home/antoine/Documents/Orbitals/Omniverse/omniisaacgymenvs/envs/vec_env_rlgames.py", line 51, in set_task
    super().set_task(task, backend, sim_params, init_sim)
  File "/home/antoine/.local/share/ov/pkg/isaac_sim-2022.2.1/exts/omni.isaac.gym/omni/isaac/gym/vec_env/vec_env_base.py", line 94, in set_task
    self._world.reset()
  File "/home/antoine/.local/share/ov/pkg/isaac_sim-2022.2.1/exts/omni.isaac.core/omni/isaac/core/world/world.py", line 281, in reset
    SimulationContext.reset(self, soft=soft)
  File "/home/antoine/.local/share/ov/pkg/isaac_sim-2022.2.1/exts/omni.isaac.core/omni/isaac/core/simulation_context/simulation_context.py", line 408, in reset
    SimulationContext.initialize_physics(self)
  File "/home/antoine/.local/share/ov/pkg/isaac_sim-2022.2.1/exts/omni.isaac.core/omni/isaac/core/simulation_context/simulation_context.py", line 388, in initialize_physics
    self._physics_sim_view = omni.physics.tensors.create_simulation_view(self.backend)
  File "/home/antoine/.local/share/ov/pkg/isaac_sim-2022.2.1/kit/extsPhysics/omni.physics.tensors-104.2.4-5.1/omni/physics/tensors/impl/api.py", line 12, in create_simulation_view
    raise Exception("Failed to create simulation view backend")
Exception: Failed to create simulation view backend

Example of the new get_target function in the Craziefly task that leads to a crash.

    def get_target(self):
        radius = 0.2
        color = torch.tensor([1, 0, 0])
        ball = DynamicPin(
            prim_path=self.default_zero_env_path + "/ball",
            translation=self._ball_position,
            name="target_0",
            ball_radius=0.125,
            poll_radius=0.025,
            poll_length=2.0,
            color=color)
        self._sim_config.apply_articulation_settings("ball", get_prim_at_path(ball.prim_path),
                                                     self._sim_config.parse_actor_config("ball"))

The code of the “DynamicPin”:

from typing import Optional, Sequence
import numpy as np
from omni.isaac.core.materials.visual_material import VisualMaterial
from omni.isaac.core.prims.rigid_prim import RigidPrim
from omni.isaac.core.prims.xform_prim import XFormPrim
from omni.isaac.core.prims.geometry_prim import GeometryPrim
from omni.isaac.core.materials import PreviewSurface
from omni.isaac.core.materials import PhysicsMaterial
from omni.isaac.core.utils.string import find_unique_string_name
from omni.isaac.core.utils.prims import get_prim_at_path, is_prim_path_valid
from omniisaacgymenvs.utils.shape_utils import Pin

class FixedPin(VisualPin):
    """_summary_

        Args:
            prim_path (str): _description_
            name (str, optional): _description_. Defaults to "fixed_sphere".
            position (Optional[np.ndarray], optional): _description_. Defaults to None.
            translation (Optional[np.ndarray], optional): _description_. Defaults to None.
            orientation (Optional[np.ndarray], optional): _description_. Defaults to None.
            scale (Optional[np.ndarray], optional): _description_. Defaults to None.
            visible (Optional[bool], optional): _description_. Defaults to None.
            color (Optional[np.ndarray], optional): _description_. Defaults to None.
            radius (Optional[np.ndarray], optional): _description_. Defaults to None.
            visual_material (Optional[VisualMaterial], optional): _description_. Defaults to None.
            physics_material (Optional[PhysicsMaterial], optional): _description_. Defaults to None.
        """

    def __init__(
        self,
        prim_path: str,
        name: str = "fixed_arrow",
        position: Optional[np.ndarray] = None,
        translation: Optional[np.ndarray] = None,
        orientation: Optional[np.ndarray] = None,
        scale: Optional[np.ndarray] = None,
        visible: Optional[bool] = None,
        color: Optional[np.ndarray] = None,
        ball_radius: Optional[float] = None,
        poll_radius: Optional[float] = None,
        poll_length: Optional[float] = None,
        visual_material: Optional[VisualMaterial] = None,
        physics_material: Optional[PhysicsMaterial] = None,
    ) -> None:
        if not is_prim_path_valid(prim_path):
            # set default values if no physics material given
            if physics_material is None:
                static_friction = 0.2
                dynamic_friction = 1.0
                restitution = 0.0
                physics_material_path = find_unique_string_name(
                    initial_name="/World/Physics_Materials/physics_material",
                    is_unique_fn=lambda x: not is_prim_path_valid(x),
                )
                physics_material = PhysicsMaterial(
                    prim_path=physics_material_path,
                    dynamic_friction=dynamic_friction,
                    static_friction=static_friction,
                    restitution=restitution,
                )
        VisualPin.__init__(
            self,
            prim_path=prim_path,
            name=name,
            position=position,
            translation=translation,
            orientation=orientation,
            scale=scale,
            visible=visible,
            color=color,
            ball_radius = ball_radius,
            poll_radius = poll_radius,
            poll_length = poll_length,
            visual_material=visual_material,
        )
        #XFormPrim.set_collision_enabled(self, True)
        #if physics_material is not None:
        #    FixedArrow.apply_physics_material(self, physics_material)
        return


class DynamicPin(RigidPrim, FixedPin):
    """_summary_

        Args:
            prim_path (str): _description_
            name (str, optional): _description_. Defaults to "dynamic_sphere".
            position (Optional[np.ndarray], optional): _description_. Defaults to None.
            translation (Optional[np.ndarray], optional): _description_. Defaults to None.
            orientation (Optional[np.ndarray], optional): _description_. Defaults to None.
            scale (Optional[np.ndarray], optional): _description_. Defaults to None.
            visible (Optional[bool], optional): _description_. Defaults to None.
            color (Optional[np.ndarray], optional): _description_. Defaults to None.
            radius (Optional[np.ndarray], optional): _description_. Defaults to None.
            visual_material (Optional[VisualMaterial], optional): _description_. Defaults to None.
            physics_material (Optional[PhysicsMaterial], optional): _description_. Defaults to None.
            mass (Optional[float], optional): _description_. Defaults to None.
            density (Optional[float], optional): _description_. Defaults to None.
            linear_velocity (Optional[Sequence[float]], optional): _description_. Defaults to None.
            angular_velocity (Optional[Sequence[float]], optional): _description_. Defaults to None.
        """

    def __init__(
        self,
        prim_path: str,
        name: str = "dynamic_sphere",
        position: Optional[np.ndarray] = None,
        translation: Optional[np.ndarray] = None,
        orientation: Optional[np.ndarray] = None,
        scale: Optional[np.ndarray] = None,
        visible: Optional[bool] = None,
        color: Optional[np.ndarray] = None,
        ball_radius: Optional[float] = None,
        poll_radius: Optional[float] = None,
        poll_length: Optional[float] = None,
        visual_material: Optional[VisualMaterial] = None,
        physics_material: Optional[PhysicsMaterial] = None,
        mass: Optional[float] = None,
        density: Optional[float] = None,
        linear_velocity: Optional[Sequence[float]] = None,
        angular_velocity: Optional[Sequence[float]] = None,
    ) -> None:
        if not is_prim_path_valid(prim_path):
            if mass is None:
                mass = 0.02
        FixedPin.__init__(
            self,
            prim_path=prim_path,
            name=name,
            position=position,
            translation=translation,
            orientation=orientation,
            scale=scale,
            visible=visible,
            color=color,
            ball_radius = ball_radius,
            poll_radius = poll_radius,
            poll_length = poll_length,
            visual_material=visual_material,
            physics_material=physics_material,
        )
        RigidPrim.__init__(
            self,
            prim_path=prim_path,
            name=name,
            position=position,
            translation=translation,
            orientation=orientation,
            scale=scale,
            visible=visible,
            mass=mass,
            density=density,
            linear_velocity=linear_velocity,
            angular_velocity=angular_velocity,
        )
from pxr import UsdGeom, Gf
from omni.isaac.core.utils.prims import get_prim_at_path, is_prim_path_valid
from omni.isaac.core.utils.stage import get_current_stage


def setXformOp(prim, value, property):
    xform = UsdGeom.Xformable(prim)
    op = None
    for xformOp in xform.GetOrderedXformOps():
        if xformOp.GetOpType() == property:
            op = xformOp
    if op:
        xform_op = op
    else:
        xform_op = xform.AddXformOp(property, UsdGeom.XformOp.PrecisionDouble, "")
    xform_op.Set(value)

def setScale(prim, value):
    setXformOp(prim, value, UsdGeom.XformOp.TypeScale)

def setTranslate(prim, value):
    setXformOp(prim, value, UsdGeom.XformOp.TypeTranslate)

def setRotateXYZ(prim, value):
    setXformOp(prim, value, UsdGeom.XformOp.TypeRotateXYZ)
    
def setOrient(prim, value):
    setXformOp(prim, value, UsdGeom.XformOp.TypeOrient)

def setTransform(prim, value: Gf.Matrix4d):
    setXformOp(prim, value, UsdGeom.XformOp.TypeTransform)

class Pin:
    def __init__(self, prim_path, ball_radius, poll_radius, poll_length):
        if ball_radius is None:
            ball_radius = 0.1
        if poll_radius is None:
            poll_radius = 0.02
        if poll_length is None:
            poll_length = 2

        self.ball_geom = None
        self.poll_geom = None

        ball_prim_path = prim_path+"/ball"
        if is_prim_path_valid(ball_prim_path):
            ball_prim = get_prim_at_path(ball_prim_path)
            if not ball_prim.IsA(UsdGeom.Sphere):
                raise Exception("The prim at path {} cannot be parsed as a pin object".format(ball_prim_path))
            self.ball_geom = UsdGeom.Sphere(ball_prim)
        else:
            self.ball_geom = UsdGeom.Sphere.Define(get_current_stage(), ball_prim_path)
            ball_prim = get_prim_at_path(ball_prim_path)

        poll_prim_path = prim_path+"/poll"
        if is_prim_path_valid(poll_prim_path):
            poll_prim = get_prim_at_path(poll_prim_path)
            if not poll_prim.IsA(UsdGeom.Cylinder):
                raise Exception("The prim at path {} cannot be parsed as a pin object".format(poll_prim_path))
            self.poll_geom = UsdGeom.Cylinder(poll_prim)
        else:
            self.poll_geom = UsdGeom.Cylinder.Define(get_current_stage(), poll_prim_path)
            poll_prim = get_prim_at_path(poll_prim_path)
  
        setTranslate(poll_prim, Gf.Vec3d([0, 0, -poll_length/2]))
        setOrient(poll_prim, Gf.Quatd(0,Gf.Vec3d([0, 0, 0])))
        setScale(poll_prim, Gf.Vec3d([1, 1, 1]))
        setTranslate(ball_prim, Gf.Vec3d([0, 0, 0]))
        setOrient(ball_prim, Gf.Quatd(1,Gf.Vec3d([0, 0, 0])))
        setScale(ball_prim, Gf.Vec3d([1, 1, 1]))

    def updateExtent(self):
        radius = self.get_ball_radius()
        self.ball_geom.GetExtentAttr().Set(
            [Gf.Vec3f([-radius, -radius, -radius]), Gf.Vec3f([radius, radius, radius])]
        )
        radius = self.get_poll_radius()
        height = self.get_poll_length()
        self.poll_geom.GetExtentAttr().Set(
            [Gf.Vec3f([-radius, -radius, -height / 2.0]), Gf.Vec3f([radius, radius, height / 2.0])]
        )
 
    def set_ball_radius(self, radius: float) -> None:
        """[summary]

        Args:
            radius (float): [description]
        """
        self.ball_geom.GetRadiusAttr().Set(radius)
        return

    def get_ball_radius(self) -> float:
        """[summary]

        Returns:
            float: [description]
        """
        return self.ball_geom.GetRadiusAttr().Get()
    
    def set_poll_radius(self, radius: float) -> None:
        """[summary]

        Args:
            radius (float): [description]
        """
        self.poll_geom.GetRadiusAttr().Set(radius)
        return

    def get_poll_radius(self) -> float:
        """[summary]

        Returns:
            float: [description]
        """
        return self.poll_geom.GetRadiusAttr().Get()
    
    def set_poll_length(self, radius: float) -> None:
        """[summary]

        Args:
            radius (float): [description]
        """
        self.poll_geom.GetHeightAttr().Set(radius)
        return

    def get_poll_length(self) -> float:
        """[summary]

        Returns:
            float: [description]
        """
        return self.poll_geom.GetHeightAttr().Get()

Hi there, it’s possible that there was not enough memory allocated to physics for the new object. Could you try increasing the GPU buffer dimensions in the task config file and see if that helps with the errors?

Thanks, it seems to work !

This topic was automatically closed 14 days after the last reply. New replies are no longer allowed.