From e023400935d01e065c8ac5e6d64a9063b7b92590 Mon Sep 17 00:00:00 2001 From: Ramya Ramineni <62723901+rraminen@users.noreply.github.com> Date: Mon, 29 Aug 2022 23:26:36 -0500 Subject: [PATCH 01/57] [SOW MS3] Centos stream9 PyTorch image support (#1090) * changes to build Centos stream 9 images * Added scripts for centos and centos stream images * Added an extra line * Add ninja installation * Optimized code * Fixes * Add comment * Optimized code * Added AMDGPU mapping for ROCm 5.2 and invalid-url for rocm_baseurl Co-authored-by: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> --- .ci/docker/build.sh | 8 +- .../centos-rocm/Dockerfile.centos.stream | 108 ++++++++++++++++++ .ci/docker/common/install_base.sh | 26 ++++- .ci/docker/common/install_db.sh | 20 +++- .ci/docker/common/install_rocm.sh | 28 ++++- .ci/docker/common/install_vision.sh | 14 ++- 6 files changed, 187 insertions(+), 17 deletions(-) create mode 100644 .ci/docker/centos-rocm/Dockerfile.centos.stream diff --git a/.ci/docker/build.sh b/.ci/docker/build.sh index 692a5ca7e7454..805c6a806dff0 100755 --- a/.ci/docker/build.sh +++ b/.ci/docker/build.sh @@ -459,6 +459,12 @@ if [[ "$image" == *cuda* && ${OS} == "ubuntu" ]]; then fi fi +if [[ "$image" == *centos9* ]]; then + DOCKERFILE_NAME="Dockerfile.centos.stream" +else + DOCKERFILE_NAME="Dockerfile" +fi + # Build image docker build \ --no-cache \ @@ -502,7 +508,7 @@ docker build \ --build-arg "ACL=${ACL:-}" \ --build-arg "SKIP_SCCACHE_INSTALL=${SKIP_SCCACHE_INSTALL:-}" \ --build-arg "SKIP_LLVM_SRC_BUILD_INSTALL=${SKIP_LLVM_SRC_BUILD_INSTALL:-}" \ - -f $(dirname ${DOCKERFILE})/Dockerfile \ + -f $(dirname ${DOCKERFILE})/${DOCKERFILE_NAME} \ -t "$tmp_tag" \ "$@" \ . diff --git a/.ci/docker/centos-rocm/Dockerfile.centos.stream b/.ci/docker/centos-rocm/Dockerfile.centos.stream new file mode 100644 index 0000000000000..41d50a8cac138 --- /dev/null +++ b/.ci/docker/centos-rocm/Dockerfile.centos.stream @@ -0,0 +1,108 @@ +ARG CENTOS_VERSION + +FROM quay.io/centos/centos:stream${CENTOS_VERSION} + + +# Set AMD gpu targets to build for +ARG PYTORCH_ROCM_ARCH +ENV PYTORCH_ROCM_ARCH ${PYTORCH_ROCM_ARCH} + +# Install required packages to build Caffe2 + +# Install common dependencies (so that this step can be cached separately) +ARG EC2 +ADD ./common/install_base.sh install_base.sh +RUN bash ./install_base.sh && rm install_base.sh + +#Install langpack +RUN yum install -y glibc-langpack-en + +# Update CentOS git version +RUN yum -y remove git +RUN yum -y remove git-* +RUN yum install -y git + +# Install devtoolset +RUN dnf install -y rpmdevtools +ENV BASH_ENV "/etc/profile" + +# Install ninja +RUN dnf --enablerepo=crb install -y ninja-build + +# (optional) Install non-default glibc version +ARG GLIBC_VERSION +ADD ./common/install_glibc.sh install_glibc.sh +RUN if [ -n "${GLIBC_VERSION}" ]; then bash ./install_glibc.sh; fi +RUN rm install_glibc.sh + +# Install user +ADD ./common/install_user.sh install_user.sh +RUN bash ./install_user.sh && rm install_user.sh + +# Install conda and other packages (e.g., numpy, pytest) +ENV PATH /opt/conda/bin:$PATH +ARG ANACONDA_PYTHON_VERSION +ARG CONDA_CMAKE +ADD requirements-ci.txt /opt/conda/requirements-ci.txt +ADD ./common/install_conda.sh install_conda.sh +RUN bash ./install_conda.sh && rm install_conda.sh +RUN rm /opt/conda/requirements-ci.txt + +# (optional) Install protobuf for ONNX +ARG PROTOBUF +ADD ./common/install_protobuf.sh install_protobuf.sh +RUN if [ -n "${PROTOBUF}" ]; then bash ./install_protobuf.sh; fi +RUN rm install_protobuf.sh +ENV INSTALLED_PROTOBUF ${PROTOBUF} + +# (optional) Install database packages like LMDB and LevelDB +ARG DB +ADD ./common/install_db.sh install_db.sh +RUN if [ -n "${DB}" ]; then bash ./install_db.sh; fi +RUN rm install_db.sh +ENV INSTALLED_DB ${DB} + +# (optional) Install vision packages like OpenCV and ffmpeg +ARG VISION +ADD ./common/install_vision.sh install_vision.sh +RUN if [ -n "${VISION}" ]; then bash ./install_vision.sh; fi +RUN rm install_vision.sh +ENV INSTALLED_VISION ${VISION} + +# Install rocm +ARG ROCM_VERSION +ADD ./common/install_rocm.sh install_rocm.sh +RUN bash ./install_rocm.sh +RUN rm install_rocm.sh +ENV PATH /opt/rocm/bin:$PATH +ENV PATH /opt/rocm/hcc/bin:$PATH +ENV PATH /opt/rocm/hip/bin:$PATH +ENV PATH /opt/rocm/opencl/bin:$PATH +ENV PATH /opt/rocm/llvm/bin:$PATH +ENV MAGMA_HOME /opt/rocm/magma +ENV LANG en_US.utf8 +ENV LC_ALL en_US.utf8 + +# (optional) Install non-default CMake version +ARG CMAKE_VERSION +ADD ./common/install_cmake.sh install_cmake.sh +RUN if [ -n "${CMAKE_VERSION}" ]; then bash ./install_cmake.sh; fi +RUN rm install_cmake.sh + +# (optional) Install non-default Ninja version +ARG NINJA_VERSION +ADD ./common/install_ninja.sh install_ninja.sh +RUN if [ -n "${NINJA_VERSION}" ]; then bash ./install_ninja.sh; fi +RUN rm install_ninja.sh + +# Install ccache/sccache (do this last, so we get priority in PATH) +ADD ./common/install_cache.sh install_cache.sh +ENV PATH /opt/cache/bin:$PATH +RUN bash ./install_cache.sh && rm install_cache.sh + +# Include BUILD_ENVIRONMENT environment variable in image +ARG BUILD_ENVIRONMENT +ENV BUILD_ENVIRONMENT ${BUILD_ENVIRONMENT} + +USER jenkins +CMD ["bash"] diff --git a/.ci/docker/common/install_base.sh b/.ci/docker/common/install_base.sh index fd58ad8a60b82..222745e37ddc1 100755 --- a/.ci/docker/common/install_base.sh +++ b/.ci/docker/common/install_base.sh @@ -90,14 +90,21 @@ install_ubuntu() { install_centos() { # Need EPEL for many packages we depend on. # See http://fedoraproject.org/wiki/EPEL - yum --enablerepo=extras install -y epel-release + # extras repo is not there for CentOS 9 and epel-release is already part of repo list + if [[ $OS_VERSION == 9 ]]; then + yum install -y epel-release + ALLOW_ERASE="--allowerasing" + else + yum --enablerepo=extras install -y epel-release + ALLOW_ERASE="" + fi ccache_deps="asciidoc docbook-dtds docbook-style-xsl libxslt" numpy_deps="gcc-gfortran" # Note: protobuf-c-{compiler,devel} on CentOS are too old to be used # for Caffe2. That said, we still install them to make sure the build # system opts to build/use protoc and libprotobuf from third-party. - yum install -y \ + yum install -y $ALLOW_ERASE \ $ccache_deps \ $numpy_deps \ autoconf \ @@ -114,15 +121,22 @@ install_centos() { glibc-headers \ glog-devel \ libstdc++-devel \ - libsndfile-devel \ make \ - opencv-devel \ sudo \ wget \ vim \ unzip \ gdb + if [[ $OS_VERSION == 9 ]] + then + dnf --enablerepo=crb -y install libsndfile-devel + else + yum install -y \ + opencv-devel \ + libsndfile-devel + fi + # Cleanup yum clean all rm -rf /var/cache/yum @@ -130,8 +144,10 @@ install_centos() { rm -rf /var/lib/yum/history } -# Install base packages depending on the base OS ID=$(grep -oP '(?<=^ID=).+' /etc/os-release | tr -d '"') +OS_VERSION=$(grep -oP '(?<=^VERSION_ID=).+' /etc/os-release | tr -d '"') + +# Install base packages depending on the base OS case "$ID" in ubuntu) install_ubuntu diff --git a/.ci/docker/common/install_db.sh b/.ci/docker/common/install_db.sh index 7e7234063b917..f819c794d8cb1 100755 --- a/.ci/docker/common/install_db.sh +++ b/.ci/docker/common/install_db.sh @@ -13,7 +13,23 @@ install_ubuntu() { install_centos() { # Need EPEL for many packages we depend on. # See http://fedoraproject.org/wiki/EPEL - yum --enablerepo=extras install -y epel-release + if [[ $OS_VERSION == 9 ]]; then + yum install -y epel-release + else + yum --enablerepo=extras install -y epel-release + fi + + yum install -y \ + hiredis-devel \ + leveldb-devel + + if [[ $OS_VERSION == 9 ]]; then + dnf --enablerepo=crb -y install lmdb-devel snappy-devel + else + yum install -y \ + lmdb-devel \ + snappy-devel + fi # Cleanup yum clean all @@ -22,6 +38,8 @@ install_centos() { rm -rf /var/lib/yum/history } +OS_VERSION=$(grep -oP '(?<=^VERSION_ID=).+' /etc/os-release | tr -d '"') + # Install base packages depending on the base OS ID=$(grep -oP '(?<=^ID=).+' /etc/os-release | tr -d '"') case "$ID" in diff --git a/.ci/docker/common/install_rocm.sh b/.ci/docker/common/install_rocm.sh index 6b746d2f92b48..63f65b252d990 100644 --- a/.ci/docker/common/install_rocm.sh +++ b/.ci/docker/common/install_rocm.sh @@ -72,10 +72,16 @@ install_centos() { yum update -y yum install -y kmod yum install -y wget - yum install -y openblas-devel + + if [[ $OS_VERSION == 9 ]]; then + dnf install -y openblas-serial + dnf install -y dkms kernel-headers kernel-devel + else + yum install -y openblas-devel + yum install -y dkms kernel-headers-`uname -r` kernel-devel-`uname -r` + fi yum install -y epel-release - yum install -y dkms kernel-headers-`uname -r` kernel-devel-`uname -r` # Add amdgpu repository local amdgpu_baseurl @@ -91,7 +97,11 @@ install_centos() { echo "gpgcheck=1" >> /etc/yum.repos.d/amdgpu.repo echo "gpgkey=http://repo.radeon.com/rocm/rocm.gpg.key" >> /etc/yum.repos.d/amdgpu.repo - local rocm_baseurl="http://repo.radeon.com/rocm/yum/${ROCM_VERSION}" + if [[ $OS_VERSION == 9 ]]; then + local rocm_baseurl="invalid-url" + else + local rocm_baseurl="http://repo.radeon.com/rocm/yum/${ROCM_VERSION}/main" + fi echo "[ROCm]" > /etc/yum.repos.d/rocm.repo echo "name=ROCm" >> /etc/yum.repos.d/rocm.repo echo "baseurl=${rocm_baseurl}" >> /etc/yum.repos.d/rocm.repo @@ -99,9 +109,13 @@ install_centos() { echo "gpgcheck=1" >> /etc/yum.repos.d/rocm.repo echo "gpgkey=http://repo.radeon.com/rocm/rocm.gpg.key" >> /etc/yum.repos.d/rocm.repo - yum update -y - - yum install -y \ + if [[ $OS_VERSION == 9 ]]; then + yum update -y --nogpgcheck + dnf --enablerepo=crb install -y perl-File-BaseDir + yum install -y --nogpgcheck rocm-ml-sdk rocm-developer-tools + else + yum update -y + yum install -y \ rocm-dev \ rocm-utils \ rocm-libs \ @@ -132,6 +146,8 @@ install_centos() { rm -rf /var/lib/yum/history } +OS_VERSION=$(grep -oP '(?<=^VERSION_ID=).+' /etc/os-release | tr -d '"') + # Install Python packages depending on the base OS ID=$(grep -oP '(?<=^ID=).+' /etc/os-release | tr -d '"') case "$ID" in diff --git a/.ci/docker/common/install_vision.sh b/.ci/docker/common/install_vision.sh index 78c445568ddcd..532d8d14a55c8 100755 --- a/.ci/docker/common/install_vision.sh +++ b/.ci/docker/common/install_vision.sh @@ -15,10 +15,14 @@ install_ubuntu() { install_centos() { # Need EPEL for many packages we depend on. # See http://fedoraproject.org/wiki/EPEL - yum --enablerepo=extras install -y epel-release - - yum install -y \ - opencv-devel + if [[ $OS_VERSION == 9 ]]; then + yum install -y epel-release + else + yum --enablerepo=extras install -y epel-release + yum install -y \ + opencv-devel \ + ffmpeg-devel + fi # Cleanup yum clean all @@ -27,6 +31,8 @@ install_centos() { rm -rf /var/lib/yum/history } +OS_VERSION=$(grep -oP '(?<=^VERSION_ID=).+' /etc/os-release | tr -d '"') + # Install base packages depending on the base OS ID=$(grep -oP '(?<=^ID=).+' /etc/os-release | tr -d '"') case "$ID" in From b8a2811c4c71862e703dd2ce83039a617534c1ba Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 30 Aug 2022 17:10:58 -0700 Subject: [PATCH 02/57] Updated to latest conda for CentOS stream 9 --- .ci/docker/common/install_conda.sh | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/.ci/docker/common/install_conda.sh b/.ci/docker/common/install_conda.sh index 3a4b48c4d7a33..f3c12c78ad36e 100755 --- a/.ci/docker/common/install_conda.sh +++ b/.ci/docker/common/install_conda.sh @@ -54,8 +54,13 @@ fi # Prevent conda from updating to 4.14.0, which causes docker build failures # See https://hud.pytorch.org/pytorch/pytorch/commit/754d7f05b6841e555cea5a4b2c505dd9e0baec1d - # Uncomment the below when resolved to track the latest conda update - # as_jenkins conda update -y -n base conda + # Uncomment the below when resolved to track the latest conda update, + # but this is required for CentOS stream 9 builds + ID=$(grep -oP '(?<=^ID=).+' /etc/os-release | tr -d '"') + OS_VERSION=$(grep -oP '(?<=^VERSION_ID=).+' /etc/os-release | tr -d '"') + if [[ $ID == centos && $OS_VERSION == 9 ]]; then + as_jenkins conda update -y -n base conda + fi if [[ $(uname -m) == "aarch64" ]]; then export SYSROOT_DEP="sysroot_linux-aarch64=2.17" From 59e9341b836a23a489fa11d4dc49d6bedb17bc61 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Wed, 22 Mar 2023 23:42:41 -0700 Subject: [PATCH 03/57] Temporarily skip test_conv3d_64bit_indexing - Rocblas API support is requested - SWDEV-383635 & sub task - SWDEV-390218 --- test/nn/test_convolution.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/test/nn/test_convolution.py b/test/nn/test_convolution.py index c030d078734f0..5a4117e236b42 100644 --- a/test/nn/test_convolution.py +++ b/test/nn/test_convolution.py @@ -55,6 +55,7 @@ parametrize as parametrize_test, run_tests, set_default_dtype, + skipIfRocm, skipIfNotMiopenSuggestNHWC, skipIfRocmVersionLessThan, subtest, @@ -4022,8 +4023,10 @@ def test_conv_double_backward_strided_with_3D_input_and_weight(self, device): self.assertEqual(grad_weight.shape, weight.shape) @onlyCUDA - @largeTensorTest("40GB") - @largeTensorTest("24GB", "cpu") + @largeTensorTest('40GB') + @largeTensorTest('24GB', 'cpu') + # Skipped for ROCm temp - https://ontrack-internal.amd.com/browse/SWDEV-383635 + @skipIfRocm def test_conv3d_64bit_indexing(self, device): x = torch.rand(1, 32, 512, 512, 256) m = torch.nn.Conv3d(32, 1, kernel_size=1, padding=0, stride=1, bias=False) From 2bb132f7843329f16c43d4666fdcbb3fcf9bfdaf Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Sun, 13 Nov 2022 14:30:43 -0800 Subject: [PATCH 04/57] Enable tensorpipe with hip_basic backend (#1135) * Add hip_basic tensorpipe support to PyTorch * Enabling hip_basic for Tensorpipe for pyTorch * removing upstream tensorpipe module * Adding ROCm specific tensopipe submodule * tensorpipe submodule updated * Update the hip invalid device string * Added ignore for tensorpipe git submodule * Moved include of tensorpipe_cuda.h to hipify * Updates based on review comments * Defining the variable __HIP_PLATFORM_AMD__ * Enabling the UTs Co-authored-by: Ronak Malik --- .gitmodules | 9 +++++---- cmake/Dependencies.cmake | 12 ++++++++++-- cmake/public/LoadHIP.cmake | 2 ++ test/run_test.py | 3 --- third_party/tensorpipe | 2 +- torch/csrc/distributed/rpc/tensorpipe_cuda.cpp | 6 +++++- .../distributed/ddp_under_dist_autograd_test.py | 2 -- .../distributed/nn/api/remote_module_test.py | 10 ++++++++-- torch/testing/_internal/distributed/rpc/rpc_test.py | 2 ++ 9 files changed, 33 insertions(+), 15 deletions(-) diff --git a/.gitmodules b/.gitmodules index c031c2fd5ad38..03419644e9cdb 100644 --- a/.gitmodules +++ b/.gitmodules @@ -90,10 +90,6 @@ ignore = dirty path = third_party/fmt url = https://github.com/fmtlib/fmt.git -[submodule "third_party/tensorpipe"] - ignore = dirty - path = third_party/tensorpipe - url = https://github.com/pytorch/tensorpipe.git [submodule "third_party/cudnn_frontend"] path = third_party/cudnn_frontend url = https://github.com/NVIDIA/cudnn-frontend.git @@ -128,3 +124,8 @@ path = third_party/cpp-httplib url = https://github.com/yhirose/cpp-httplib.git branch = v0.15.3 +[submodule "third_party/tensorpipe"] + ignore = dirty + path = third_party/tensorpipe + url = https://github.com/ROCmSoftwarePlatform/tensorpipe.git + branch = tp_rocm_54 diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index f1f2eb7cec31a..60677604c015e 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -1152,6 +1152,14 @@ if(USE_DISTRIBUTED AND USE_TENSORPIPE) set(TP_USE_CUDA ON CACHE BOOL "" FORCE) set(TP_ENABLE_CUDA_IPC ON CACHE BOOL "" FORCE) endif() + if(USE_ROCM) + add_compile_options(-D__HIP_PLATFORM_AMD__=1) + set(TP_USE_ROCM ON CACHE BOOL "" FORCE) + set(TP_ENABLE_HIP_IPC OFF CACHE BOOL "" FORCE) + set(TP_ENABLE_HIP_XTH OFF CACHE BOOL "" FORCE) + set(TP_ENABLE_HIP_GDR OFF CACHE BOOL "" FORCE) + set(TP_ENABLE_IBV OFF CACHE BOOL "" FORCE) + endif() set(TP_BUILD_LIBUV ON CACHE BOOL "" FORCE) add_compile_options(-DTORCH_USE_LIBUV) include_directories(BEFORE SYSTEM ${CMAKE_CURRENT_LIST_DIR}/../third_party/tensorpipe/third_party/libuv/include) @@ -1165,9 +1173,9 @@ if(USE_DISTRIBUTED AND USE_TENSORPIPE) if(USE_CUDA) list(APPEND Caffe2_CUDA_DEPENDENCY_LIBS tensorpipe_cuda) elseif(USE_ROCM) - message(WARNING "TensorPipe doesn't yet support ROCm") + message(WARNING "TensorPipe is supported on ROCm") # Not yet... - # list(APPEND Caffe2_HIP_DEPENDENCY_LIBS tensorpipe_hip) + list(APPEND Caffe2_HIP_DEPENDENCY_LIBS tensorpipe_hip) endif() endif() endif() diff --git a/cmake/public/LoadHIP.cmake b/cmake/public/LoadHIP.cmake index fa39156031ff3..bbe258b60cdfb 100644 --- a/cmake/public/LoadHIP.cmake +++ b/cmake/public/LoadHIP.cmake @@ -165,6 +165,8 @@ if(HIP_FOUND) find_package_and_print_version(rocthrust REQUIRED) find_package_and_print_version(hipsolver REQUIRED) + # Enabling HIP language support + enable_language(HIP) find_library(PYTORCH_HIP_LIBRARIES amdhip64 HINTS ${ROCM_PATH}/lib) # TODO: miopen_LIBRARIES should return fullpath to the library file, diff --git a/test/run_test.py b/test/run_test.py index 57e69c0d979cf..5464cf61aa3c2 100755 --- a/test/run_test.py +++ b/test/run_test.py @@ -163,10 +163,7 @@ def __contains__(self, item): ] + FSDP_TEST ROCM_BLOCKLIST = [ - "distributed/rpc/test_faulty_agent", - "distributed/rpc/test_tensorpipe_agent", "distributed/rpc/test_share_memory", - "distributed/rpc/cuda/test_tensorpipe_agent", "distributed/_shard/checkpoint/test_checkpoint" "distributed/_shard/checkpoint/test_file_system_checkpoint" "distributed/_shard/sharding_spec/test_sharding_spec", diff --git a/third_party/tensorpipe b/third_party/tensorpipe index 52791a2fd214b..cda6d6e2d2ff7 160000 --- a/third_party/tensorpipe +++ b/third_party/tensorpipe @@ -1 +1 @@ -Subproject commit 52791a2fd214b2a9dc5759d36725909c1daa7f2e +Subproject commit cda6d6e2d2ff7d610dafa91748e4435f08e9535e diff --git a/torch/csrc/distributed/rpc/tensorpipe_cuda.cpp b/torch/csrc/distributed/rpc/tensorpipe_cuda.cpp index 50cc97785f61d..e18afdd45c0aa 100644 --- a/torch/csrc/distributed/rpc/tensorpipe_cuda.cpp +++ b/torch/csrc/distributed/rpc/tensorpipe_cuda.cpp @@ -1,7 +1,7 @@ #include #include -#if defined(USE_TENSORPIPE) && !defined(USE_ROCM) +#if defined(USE_TENSORPIPE) #include #include @@ -50,6 +50,8 @@ C10_REGISTER_CREATOR(TensorPipeChannelRegistry, cuda_gdr, makeCudaGdrChannel); #endif +#if TENSORPIPE_HAS_CUDA_XTH_CHANNEL + std::unique_ptr makeCudaXthChannel() { auto context = tensorpipe::channel::cuda_xth::create(); return std::make_unique( @@ -59,6 +61,8 @@ std::unique_ptr makeCudaXthChannel() { // The cuda_xth channel supports same-process GPU-to-GPU comm C10_REGISTER_CREATOR(TensorPipeChannelRegistry, cuda_xth, makeCudaXthChannel); +#endif + std::unique_ptr makeCudaBasicChannel() { auto context = tensorpipe::channel::cuda_basic::create( tensorpipe::channel::basic::create()); diff --git a/torch/testing/_internal/distributed/ddp_under_dist_autograd_test.py b/torch/testing/_internal/distributed/ddp_under_dist_autograd_test.py index e13c814b12a5f..0002227d73b18 100644 --- a/torch/testing/_internal/distributed/ddp_under_dist_autograd_test.py +++ b/torch/testing/_internal/distributed/ddp_under_dist_autograd_test.py @@ -18,7 +18,6 @@ requires_gloo, requires_nccl, skip_if_lt_x_gpu, - skip_if_rocm, ) from torch.testing._internal.dist_utils import INIT_METHOD_TEMPLATE, dist_init from torch.testing._internal.distributed.rpc.rpc_agent_test_fixture import ( @@ -662,7 +661,6 @@ class CudaDdpComparisonTest(CommonDdpComparisonTest): @skip_if_lt_x_gpu(NUM_TRAINERS) @requires_nccl() @dist_init - @skip_if_rocm def test_ddp_dist_autograd_local_vs_remote_gpu(self): # Each trainer uses a different random seed. Otherwise, they are going # to have exactly the same initial model parameters, input, and diff --git a/torch/testing/_internal/distributed/nn/api/remote_module_test.py b/torch/testing/_internal/distributed/nn/api/remote_module_test.py index 60857685b8851..d85b0396b2afa 100644 --- a/torch/testing/_internal/distributed/nn/api/remote_module_test.py +++ b/torch/testing/_internal/distributed/nn/api/remote_module_test.py @@ -12,7 +12,7 @@ from torch.distributed.nn.api.remote_module import _REMOTE_MODULE_PICKLED_ATTRIBUTES from torch.distributed.nn.api.remote_module import _RemoteModule from torch.testing._internal.common_distributed import skip_if_lt_x_gpu -from torch.testing._internal.common_utils import TemporaryFileName +from torch.testing._internal.common_utils import TemporaryFileName, TEST_WITH_ROCM from torch.testing._internal.distributed.rpc.rpc_agent_test_fixture import ( RpcAgentTestFixture, ) @@ -613,8 +613,14 @@ def test_invalid_devices(self): ) ] + if TEST_WITH_ROCM: + errorString = (r"HIP error: invalid device ordinal\n" + r"HIP kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\n" + r"For debugging consider passing HIP_LAUNCH_BLOCKING=1.") + else: + errorString = r"CUDA error: invalid device ordinal" with self.assertRaisesRegex( - RuntimeError, r"CUDA error: invalid device ordinal" + RuntimeError, errorString ): [ m.forward() diff --git a/torch/testing/_internal/distributed/rpc/rpc_test.py b/torch/testing/_internal/distributed/rpc/rpc_test.py index 764198338636c..cba6d4657f9b8 100644 --- a/torch/testing/_internal/distributed/rpc/rpc_test.py +++ b/torch/testing/_internal/distributed/rpc/rpc_test.py @@ -32,6 +32,7 @@ skip_if_lt_x_gpu, captured_output, tp_transports, + skip_if_rocm, ) from torch.testing._internal.common_utils import ( IS_MACOS, @@ -5073,6 +5074,7 @@ def test_dynamic_rpc_existing_rank_can_communicate_with_new_rank(self): # Dynamic RPC existing ranks can communicate with new ranks using CUDA rpc @skip_if_lt_x_gpu(2) + @skip_if_rocm @dist_init(setup_rpc=False) def test_dynamic_rpc_existing_rank_can_communicate_with_new_rank_cuda(self): initialize_pg(self.file_init_method, self.rank, self.world_size) From 0b082783ce7ee3e035dcdc7022c874b7209091f2 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Fri, 28 Jul 2023 13:24:03 -0700 Subject: [PATCH 05/57] Updates to build on Jammy - Fortran package installation moved after gcc - Update libtinfo search code in cmake1 - Install libstdc++.so --- .ci/docker/common/common_utils.sh | 4 ++++ .ci/docker/common/install_conda.sh | 5 +++++ 2 files changed, 9 insertions(+) diff --git a/.ci/docker/common/common_utils.sh b/.ci/docker/common/common_utils.sh index 27c1b815a0ea8..110065698b587 100644 --- a/.ci/docker/common/common_utils.sh +++ b/.ci/docker/common/common_utils.sh @@ -23,6 +23,10 @@ conda_install() { as_jenkins conda install -q -n py_$ANACONDA_PYTHON_VERSION -y python="$ANACONDA_PYTHON_VERSION" $* } +conda_install_through_forge() { + as_jenkins conda install -c conda-forge -q -n py_$ANACONDA_PYTHON_VERSION -y python="$ANACONDA_PYTHON_VERSION" $* +} + conda_run() { as_jenkins conda run -n py_$ANACONDA_PYTHON_VERSION --no-capture-output $* } diff --git a/.ci/docker/common/install_conda.sh b/.ci/docker/common/install_conda.sh index f3c12c78ad36e..0aa2423b3781a 100755 --- a/.ci/docker/common/install_conda.sh +++ b/.ci/docker/common/install_conda.sh @@ -115,6 +115,11 @@ fi conda_install magma-cuda$(TMP=${CUDA_VERSION/./};echo ${TMP%.*[0-9]}) -c pytorch fi + # Install required libstdc++.so.6 version + if [ "$ANACONDA_PYTHON_VERSION" = "3.10" ]; then + conda_install_through_forge libstdcxx-ng=12 + fi + # Install some other packages, including those needed for Python test reporting pip_install -r /opt/conda/requirements-ci.txt From 6e7704d9cc5ba43f79aeb0c100204c3f6ec03fb7 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 12 Sep 2023 00:43:22 -0700 Subject: [PATCH 06/57] Fix lstsq related regressions (part of SWDEV-392820) --- .../ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp index 2a9f46e6f73e7..f678659052b74 100644 --- a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp +++ b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp @@ -239,7 +239,15 @@ void triangular_solve_batched_cublas(const Tensor& A, const Tensor& B, bool left template inline void apply_gels_batched(const Tensor& A, Tensor& B, Tensor& infos) { +#if not defined(ROCM_VERSION) auto trans = CUBLAS_OP_N; +#endif +#if defined(ROCM_VERSION) && (ROCM_VERSION >= 50400) + auto trans = HIPBLAS_OP_N; +#endif +#if defined(ROCM_VERSION) && (ROCM_VERSION < 50400) + auto trans = rocblas_operation_none; +#endif auto m = cuda_int_cast(A.size(-2), "m"); auto n = cuda_int_cast(A.size(-1), "n"); From 108bf575ef69b53669443b6b46acf67b511de58f Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Thu, 17 Aug 2023 19:04:13 -0700 Subject: [PATCH 07/57] [UB22.04] Updates to support latest scipy --- .ci/docker/common/install_base.sh | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.ci/docker/common/install_base.sh b/.ci/docker/common/install_base.sh index 222745e37ddc1..a4fbe07036a00 100755 --- a/.ci/docker/common/install_base.sh +++ b/.ci/docker/common/install_base.sh @@ -82,6 +82,10 @@ install_ubuntu() { # see: https://github.com/pytorch/pytorch/issues/65931 apt-get install -y libgnutls30 + if [[ "$UBUNTU_VERSION" == "22.04"* ]]; then + apt-get install -y libopenblas-dev + fi + # Cleanup package manager apt-get autoclean && apt-get clean rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* From 15da21ac9cae0a8db8443d6d2d565948d66f5eb7 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Fri, 18 Aug 2023 01:32:24 -0700 Subject: [PATCH 08/57] Build required version of libpng for CentOS7 --- .ci/docker/common/install_base.sh | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/.ci/docker/common/install_base.sh b/.ci/docker/common/install_base.sh index a4fbe07036a00..06793836facd4 100755 --- a/.ci/docker/common/install_base.sh +++ b/.ci/docker/common/install_base.sh @@ -91,6 +91,30 @@ install_ubuntu() { rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* } +build_libpng() { + # install few packages + yum install -y zlib zlib-devel + + LIBPNG_VERSION=1.6.37 + + mkdir -p libpng + pushd libpng + + wget http://download.sourceforge.net/libpng/libpng-$LIBPNG_VERSION.tar.gz + tar -xvzf libpng-$LIBPNG_VERSION.tar.gz + + pushd libpng-$LIBPNG_VERSION + + ./configure + make + make install + + popd + + popd + rm -rf libpng +} + install_centos() { # Need EPEL for many packages we depend on. # See http://fedoraproject.org/wiki/EPEL @@ -141,6 +165,11 @@ install_centos() { libsndfile-devel fi + # CentOS7 doesnt have support for higher version of libpng, + # so it is built from source. + # Libpng is required for torchvision build. + build_libpng + # Cleanup yum clean all rm -rf /var/cache/yum From 40034966a6cc32a3efd361ced988602722a90351 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Fri, 4 Aug 2023 18:50:43 -0700 Subject: [PATCH 09/57] Update tensorpipe submodule to support ROCm 6.0 --- .gitmodules | 2 +- third_party/tensorpipe | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.gitmodules b/.gitmodules index 03419644e9cdb..b2c2c01716b8d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -128,4 +128,4 @@ ignore = dirty path = third_party/tensorpipe url = https://github.com/ROCmSoftwarePlatform/tensorpipe.git - branch = tp_rocm_54 + branch = tp_rocm_60 diff --git a/third_party/tensorpipe b/third_party/tensorpipe index cda6d6e2d2ff7..135ba25f6be99 160000 --- a/third_party/tensorpipe +++ b/third_party/tensorpipe @@ -1 +1 @@ -Subproject commit cda6d6e2d2ff7d610dafa91748e4435f08e9535e +Subproject commit 135ba25f6be9991ebfe83d41d268d9c3d4cc5c5b From 2cfad86e1e4acac7294f69b835b469be011d2747 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Sun, 13 Aug 2023 11:44:26 -0700 Subject: [PATCH 10/57] Set ROCM_PATH in env for centOS docker container --- .ci/docker/centos-rocm/Dockerfile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.ci/docker/centos-rocm/Dockerfile b/.ci/docker/centos-rocm/Dockerfile index bfac9ddd85908..9ef063e7e851e 100644 --- a/.ci/docker/centos-rocm/Dockerfile +++ b/.ci/docker/centos-rocm/Dockerfile @@ -80,6 +80,8 @@ RUN rm install_rocm_magma.sh COPY ./common/install_amdsmi.sh install_amdsmi.sh RUN bash ./install_amdsmi.sh RUN rm install_amdsmi.sh + +ENV ROCM_PATH /opt/rocm ENV PATH /opt/rocm/bin:$PATH ENV PATH /opt/rocm/hcc/bin:$PATH ENV PATH /opt/rocm/hip/bin:$PATH From 3c19bf912ab39a3b82bc5787d959033fa2b37a93 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 5 Sep 2023 16:20:55 -0700 Subject: [PATCH 11/57] Updated condition for libstc++ for Jammy --- .ci/docker/common/install_conda.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.ci/docker/common/install_conda.sh b/.ci/docker/common/install_conda.sh index 0aa2423b3781a..2f4e443d10e89 100755 --- a/.ci/docker/common/install_conda.sh +++ b/.ci/docker/common/install_conda.sh @@ -116,7 +116,7 @@ fi fi # Install required libstdc++.so.6 version - if [ "$ANACONDA_PYTHON_VERSION" = "3.10" ]; then + if [ "$ANACONDA_PYTHON_VERSION" = "3.10" ] || [ "$ANACONDA_PYTHON_VERSION" = "3.9" ] ; then conda_install_through_forge libstdcxx-ng=12 fi From b7e47fa1c1a29986cc3e80c74869a08c5becdd67 Mon Sep 17 00:00:00 2001 From: Jack Taylor <108682042+jataylo@users.noreply.github.com> Date: Fri, 27 Oct 2023 16:29:04 +0100 Subject: [PATCH 12/57] Skip ddp apply_optim_in_bwd tests for gloo (#1302) To resolve https://ontrack-internal.amd.com/browse/SWDEV-403530 and https://ontrack-internal.amd.com/browse/SWDEV-419837. For more context check upstream issue https://github.com/pytorch/pytorch/issues/111834 --- .../testing/_internal/distributed/distributed_test.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/torch/testing/_internal/distributed/distributed_test.py b/torch/testing/_internal/distributed/distributed_test.py index 0ec5dd2224448..90c6722e22756 100644 --- a/torch/testing/_internal/distributed/distributed_test.py +++ b/torch/testing/_internal/distributed/distributed_test.py @@ -4858,7 +4858,11 @@ def _test_ddp_apply_optim_in_backward( # set_to_none for regular optimizer to match in backward # case. optim.zero_grad(set_to_none=True) - + + @skip_but_pass_in_sandcastle_if( + BACKEND == "gloo" and HAS_TORCHVISION, + "Failing with gloo backend + torchvision due to ongoing issue https://github.com/pytorch/pytorch/issues/111834", + ) @skip_if_lt_x_gpu(2) def test_ddp_apply_optim_in_backward(self): for optim_cls, init_before in itertools.product( @@ -4871,6 +4875,10 @@ def test_ddp_apply_optim_in_backward(self): init_before=init_before, ) + @skip_but_pass_in_sandcastle_if( + BACKEND == "gloo" and HAS_TORCHVISION, + "Failing with gloo backend + torchvision due to ongoing issue https://github.com/pytorch/pytorch/issues/111834", + ) @skip_if_lt_x_gpu(2) def test_ddp_apply_optim_in_backward_grad_as_bucket_view_false(self): for init_before in [True, False]: From 032320c1d6e6553458a58939b752b111df1a678b Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Mon, 25 Sep 2023 16:29:28 -0700 Subject: [PATCH 13/57] Changes to support docker v23 Reversed the condition as required --- .ci/docker/build.sh | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/.ci/docker/build.sh b/.ci/docker/build.sh index 805c6a806dff0..f6c2d12e20262 100755 --- a/.ci/docker/build.sh +++ b/.ci/docker/build.sh @@ -465,10 +465,15 @@ else DOCKERFILE_NAME="Dockerfile" fi +DOCKER_PROGRESS="--progress=plain" +if [[ "${DOCKER_BUILDKIT}" == 0 ]]; then + DOCKER_PROGRESS="" +fi + # Build image docker build \ --no-cache \ - --progress=plain \ + ${DOCKER_PROGRESS} \ --build-arg "BUILD_ENVIRONMENT=${image}" \ --build-arg "PROTOBUF=${PROTOBUF:-}" \ --build-arg "LLVMDEV=${LLVMDEV:-}" \ From 50d56db804187312c8d8fd0e108e788fb60b0853 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 28 Nov 2023 00:35:34 -0800 Subject: [PATCH 14/57] [CS9] Updates to CentOS stream 9 build (#1326) - Add missing common_utils.sh - Update the install vision part - Move to amdgpu rhel 9.3 builds - Update to pick python from conda path - Add a missing package - Add ROCM_PATH and magma - Updated repo radeon path --- .../centos-rocm/Dockerfile.centos.stream | 50 +++++++++++++------ .ci/docker/common/install_base.sh | 1 + .ci/docker/common/install_rocm.sh | 30 ++++++----- 3 files changed, 53 insertions(+), 28 deletions(-) diff --git a/.ci/docker/centos-rocm/Dockerfile.centos.stream b/.ci/docker/centos-rocm/Dockerfile.centos.stream index 41d50a8cac138..c314694ec555e 100644 --- a/.ci/docker/centos-rocm/Dockerfile.centos.stream +++ b/.ci/docker/centos-rocm/Dockerfile.centos.stream @@ -11,7 +11,7 @@ ENV PYTORCH_ROCM_ARCH ${PYTORCH_ROCM_ARCH} # Install common dependencies (so that this step can be cached separately) ARG EC2 -ADD ./common/install_base.sh install_base.sh +COPY ./common/install_base.sh install_base.sh RUN bash ./install_base.sh && rm install_base.sh #Install langpack @@ -31,49 +31,55 @@ RUN dnf --enablerepo=crb install -y ninja-build # (optional) Install non-default glibc version ARG GLIBC_VERSION -ADD ./common/install_glibc.sh install_glibc.sh +COPY ./common/install_glibc.sh install_glibc.sh RUN if [ -n "${GLIBC_VERSION}" ]; then bash ./install_glibc.sh; fi RUN rm install_glibc.sh # Install user -ADD ./common/install_user.sh install_user.sh +COPY ./common/install_user.sh install_user.sh RUN bash ./install_user.sh && rm install_user.sh # Install conda and other packages (e.g., numpy, pytest) -ENV PATH /opt/conda/bin:$PATH ARG ANACONDA_PYTHON_VERSION ARG CONDA_CMAKE -ADD requirements-ci.txt /opt/conda/requirements-ci.txt -ADD ./common/install_conda.sh install_conda.sh -RUN bash ./install_conda.sh && rm install_conda.sh -RUN rm /opt/conda/requirements-ci.txt +ENV ANACONDA_PYTHON_VERSION=$ANACONDA_PYTHON_VERSION +ENV PATH /opt/conda/envs/py_$ANACONDA_PYTHON_VERSION/bin:/opt/conda/bin:$PATH +COPY requirements-ci.txt /opt/conda/requirements-ci.txt +COPY ./common/install_conda.sh install_conda.sh +COPY ./common/common_utils.sh common_utils.sh +RUN bash ./install_conda.sh && rm install_conda.sh common_utils.sh /opt/conda/requirements-ci.txt # (optional) Install protobuf for ONNX ARG PROTOBUF -ADD ./common/install_protobuf.sh install_protobuf.sh +COPY ./common/install_protobuf.sh install_protobuf.sh RUN if [ -n "${PROTOBUF}" ]; then bash ./install_protobuf.sh; fi RUN rm install_protobuf.sh ENV INSTALLED_PROTOBUF ${PROTOBUF} # (optional) Install database packages like LMDB and LevelDB ARG DB -ADD ./common/install_db.sh install_db.sh +COPY ./common/install_db.sh install_db.sh RUN if [ -n "${DB}" ]; then bash ./install_db.sh; fi RUN rm install_db.sh ENV INSTALLED_DB ${DB} # (optional) Install vision packages like OpenCV and ffmpeg ARG VISION -ADD ./common/install_vision.sh install_vision.sh +COPY ./common/install_vision.sh ./common/cache_vision_models.sh ./common/common_utils.sh ./ RUN if [ -n "${VISION}" ]; then bash ./install_vision.sh; fi -RUN rm install_vision.sh +RUN rm install_vision.sh cache_vision_models.sh common_utils.sh ENV INSTALLED_VISION ${VISION} # Install rocm ARG ROCM_VERSION -ADD ./common/install_rocm.sh install_rocm.sh +COPY ./common/install_rocm.sh install_rocm.sh RUN bash ./install_rocm.sh RUN rm install_rocm.sh +COPY ./common/install_rocm_magma.sh install_rocm_magma.sh +RUN bash ./install_rocm_magma.sh +RUN rm install_rocm_magma.sh + +ENV ROCM_PATH /opt/rocm ENV PATH /opt/rocm/bin:$PATH ENV PATH /opt/rocm/hcc/bin:$PATH ENV PATH /opt/rocm/hip/bin:$PATH @@ -85,18 +91,30 @@ ENV LC_ALL en_US.utf8 # (optional) Install non-default CMake version ARG CMAKE_VERSION -ADD ./common/install_cmake.sh install_cmake.sh +COPY ./common/install_cmake.sh install_cmake.sh RUN if [ -n "${CMAKE_VERSION}" ]; then bash ./install_cmake.sh; fi RUN rm install_cmake.sh # (optional) Install non-default Ninja version ARG NINJA_VERSION -ADD ./common/install_ninja.sh install_ninja.sh +COPY ./common/install_ninja.sh install_ninja.sh RUN if [ -n "${NINJA_VERSION}" ]; then bash ./install_ninja.sh; fi RUN rm install_ninja.sh +ARG TRITON +# Install triton, this needs to be done before sccache because the latter will +# try to reach out to S3, which docker build runners don't have access +ENV CMAKE_C_COMPILER cc +ENV CMAKE_CXX_COMPILER c++ +COPY ./common/install_triton.sh install_triton.sh +COPY ./common/common_utils.sh common_utils.sh +COPY ci_commit_pins/triton-rocm.txt triton-rocm.txt +COPY triton_version.txt triton_version.txt +RUN if [ -n "${TRITON}" ]; then bash ./install_triton.sh; fi +RUN rm install_triton.sh common_utils.sh triton-rocm.txt triton_version.txt + # Install ccache/sccache (do this last, so we get priority in PATH) -ADD ./common/install_cache.sh install_cache.sh +COPY ./common/install_cache.sh install_cache.sh ENV PATH /opt/cache/bin:$PATH RUN bash ./install_cache.sh && rm install_cache.sh diff --git a/.ci/docker/common/install_base.sh b/.ci/docker/common/install_base.sh index 06793836facd4..3da6fa9e53df1 100755 --- a/.ci/docker/common/install_base.sh +++ b/.ci/docker/common/install_base.sh @@ -159,6 +159,7 @@ install_centos() { if [[ $OS_VERSION == 9 ]] then dnf --enablerepo=crb -y install libsndfile-devel + yum install -y procps else yum install -y \ opencv-devel \ diff --git a/.ci/docker/common/install_rocm.sh b/.ci/docker/common/install_rocm.sh index 63f65b252d990..0973415c06fa9 100644 --- a/.ci/docker/common/install_rocm.sh +++ b/.ci/docker/common/install_rocm.sh @@ -83,19 +83,25 @@ install_centos() { yum install -y epel-release - # Add amdgpu repository - local amdgpu_baseurl - if [[ $OS_VERSION == 9 ]]; then - amdgpu_baseurl="https://repo.radeon.com/amdgpu/${ROCM_VERSION}/rhel/9.0/main/x86_64" - else - amdgpu_baseurl="https://repo.radeon.com/amdgpu/${ROCM_VERSION}/rhel/7.9/main/x86_64" + if [[ $(ver $ROCM_VERSION) -ge $(ver 4.5) ]]; then + # Add amdgpu repository + local amdgpu_baseurl + if [[ $OS_VERSION == 9 ]]; then + amdgpu_baseurl="https://repo.radeon.com/amdgpu/${AMDGPU_VERSIONS[$ROCM_VERSION]}/rhel/9.1/main/x86_64" + else + if [[ $(ver $ROCM_VERSION) -ge $(ver 5.3) ]]; then + amdgpu_baseurl="https://repo.radeon.com/amdgpu/${ROCM_VERSION}/rhel/7.9/main/x86_64" + else + amdgpu_baseurl="https://repo.radeon.com/amdgpu/${AMDGPU_VERSIONS[$ROCM_VERSION]}/rhel/7.9/main/x86_64" + fi + fi + echo "[AMDGPU]" > /etc/yum.repos.d/amdgpu.repo + echo "name=AMDGPU" >> /etc/yum.repos.d/amdgpu.repo + echo "baseurl=${amdgpu_baseurl}" >> /etc/yum.repos.d/amdgpu.repo + echo "enabled=1" >> /etc/yum.repos.d/amdgpu.repo + echo "gpgcheck=1" >> /etc/yum.repos.d/amdgpu.repo + echo "gpgkey=http://repo.radeon.com/rocm/rocm.gpg.key" >> /etc/yum.repos.d/amdgpu.repo fi - echo "[AMDGPU]" > /etc/yum.repos.d/amdgpu.repo - echo "name=AMDGPU" >> /etc/yum.repos.d/amdgpu.repo - echo "baseurl=${amdgpu_baseurl}" >> /etc/yum.repos.d/amdgpu.repo - echo "enabled=1" >> /etc/yum.repos.d/amdgpu.repo - echo "gpgcheck=1" >> /etc/yum.repos.d/amdgpu.repo - echo "gpgkey=http://repo.radeon.com/rocm/rocm.gpg.key" >> /etc/yum.repos.d/amdgpu.repo if [[ $OS_VERSION == 9 ]]; then local rocm_baseurl="invalid-url" From 17ba54fa5f4c056e5e542ed484a2a6f6434cf6b2 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Wed, 6 Dec 2023 01:38:10 -0800 Subject: [PATCH 15/57] Update to hipify mapping --- torch/utils/hipify/cuda_to_hip_mappings.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torch/utils/hipify/cuda_to_hip_mappings.py b/torch/utils/hipify/cuda_to_hip_mappings.py index 976e12e42d336..32ba13a4d7efe 100644 --- a/torch/utils/hipify/cuda_to_hip_mappings.py +++ b/torch/utils/hipify/cuda_to_hip_mappings.py @@ -3,7 +3,7 @@ from .constants import (API_BLAS, API_C10, API_CAFFE2, API_DRIVER, API_FFT, API_PYTORCH, API_RAND, API_ROCTX, API_RTC, API_RUNTIME, API_SPECIAL, API_ROCMSMI, CONV_CACHE, CONV_CONTEXT, CONV_D3D9, - CONV_D3D10, CONV_D3D11, CONV_DEF, CONV_DEVICE, + API_PYT_EXT, CONV_D3D10, CONV_D3D11, CONV_DEF, CONV_DEVICE, CONV_DEVICE_FUNC, CONV_EGL, CONV_ERROR, CONV_EVENT, CONV_EXEC, CONV_GL, CONV_GRAPHICS, CONV_INCLUDE, CONV_INCLUDE_CUDA_MAIN_H, CONV_INIT, CONV_JIT, From e00045a8c8f6dbfdcc86425a12ea003a87e709da Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Wed, 6 Dec 2023 10:45:45 -0800 Subject: [PATCH 16/57] Correcting usage of USE_ROCM --- .../native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp index f678659052b74..915d5f50a1790 100644 --- a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp +++ b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLibBlas.cpp @@ -239,14 +239,12 @@ void triangular_solve_batched_cublas(const Tensor& A, const Tensor& B, bool left template inline void apply_gels_batched(const Tensor& A, Tensor& B, Tensor& infos) { -#if not defined(ROCM_VERSION) - auto trans = CUBLAS_OP_N; -#endif -#if defined(ROCM_VERSION) && (ROCM_VERSION >= 50400) +#if defined(USE_ROCM) && (ROCM_VERSION >= 50400) auto trans = HIPBLAS_OP_N; -#endif -#if defined(ROCM_VERSION) && (ROCM_VERSION < 50400) +#elif defined(USE_ROCM) && (ROCM_VERSION < 50400) auto trans = rocblas_operation_none; +#else + auto trans = CUBLAS_OP_N; #endif auto m = cuda_int_cast(A.size(-2), "m"); auto n = cuda_int_cast(A.size(-1), "n"); From 7f3172f7cc6610fe648927036f9e3e9e80128c9f Mon Sep 17 00:00:00 2001 From: Xinya Zhang Date: Wed, 20 Dec 2023 16:26:17 -0600 Subject: [PATCH 17/57] Enable gesvda for ROCM >= 6.1 (#1339) This also fixes a problem in gesvd driver when UV is not needed. --- .../native/cuda/linalg/BatchLinearAlgebraLib.cpp | 16 ++++++++-------- aten/src/ATen/native/cuda/linalg/CUDASolver.cpp | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp index bc06f118ae9a0..3cadc120d2063 100644 --- a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp +++ b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp @@ -328,11 +328,11 @@ inline static void svd_cusolver_gesvd(const Tensor& A, const Tensor& U, const Te // gesvd just knows how to handle m >= n, so in the other case we need to transpose A const auto not_A_H = A.size(-2) >= A.size(-1); Tensor Vcopy = V; // Shallow copy -#ifdef USE_ROCM +#ifdef ROCM_VERSION // Similar to the case in svd_magma(), experiments have shown Vh tensor is // not guaranteed to be column major on ROCM, we have to create a copy to // deal with this - if (!not_A_H) { + if (compute_uv && !not_A_H) { Vcopy = at::empty_like(V.mT(), V.options() .device(V.device()) @@ -347,8 +347,8 @@ inline static void svd_cusolver_gesvd(const Tensor& A, const Tensor& U, const Te infos, full_matrices, compute_uv, calculate_all_batches, batches); }); -#ifdef USE_ROCM - if (!not_A_H) { +#ifdef ROCM_VERSION + if (compute_uv && !not_A_H) { V.copy_(Vcopy); } #endif @@ -522,8 +522,8 @@ inline static void svd_cusolver_gesvdjBatched(const Tensor& A, const Tensor& U, template inline static void apply_svd_cusolver_gesvdaStridedBatched(const Tensor& A, const Tensor& U, const Tensor& S, const Tensor& V, const Tensor& infos, bool full_matrices, bool compute_uv) { -#ifndef CUDART_VERSION - TORCH_CHECK(false, "gesvda: Batched version is supported only with cuBLAS backend.") +#if defined(CUDART_VERSION) || defined(USE_ROCM) && ROCM_VERSION < 60100 + TORCH_CHECK(false, "gesvda: Batched version is supported only with cuBLAS backend or ROCM >= 5.7.0.") #else using value_t = typename c10::scalar_value_type::type; int m = cuda_int_cast(A.size(-2), "m"); @@ -648,7 +648,7 @@ std::string _format_non_converging_batches(const std::vector& batches) void svd_cusolver(const Tensor& A, const bool full_matrices, const bool compute_uv, - const std::optional& driver, + const c10::optional& driver, const Tensor& U, const Tensor& S, const Tensor& V, @@ -661,7 +661,7 @@ void svd_cusolver(const Tensor& A, static const char* check_svd_doc = "Check doc at https://pytorch.org/docs/stable/generated/torch.linalg.svd.html"; // The default heuristic is to use gesvdj driver -#ifdef USE_ROCM +#if defined(ROCM_VERSION) && ROCM_VERSION < 60100 const auto driver_v = c10::string_view("gesvdj"); #else const auto driver_v = driver.value_or("gesvdj"); diff --git a/aten/src/ATen/native/cuda/linalg/CUDASolver.cpp b/aten/src/ATen/native/cuda/linalg/CUDASolver.cpp index 7b068b5f5aec1..b2343aac54014 100644 --- a/aten/src/ATen/native/cuda/linalg/CUDASolver.cpp +++ b/aten/src/ATen/native/cuda/linalg/CUDASolver.cpp @@ -470,8 +470,8 @@ void gesvdjBatched>( } -// ROCM does not implement gesdva yet -#ifdef CUDART_VERSION +// ROCM does not implement gesdva correctly before 6.1 +#if defined(CUDART_VERSION) || defined(ROCM_VERSION) && ROCM_VERSION >= 60100 template<> void gesvdaStridedBatched_buffersize( cusolverDnHandle_t handle, cusolverEigMode_t jobz, int rank, int m, int n, float *A, int lda, long long int strideA, From a2d6ace39091da3f39f99fde41934042706fabd9 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Sun, 31 Dec 2023 14:28:00 -0800 Subject: [PATCH 18/57] Increase lifespan of test-times files - build_environment is hard coded to value from upstream when branch for created, since the dev/QA ENV build_environment value can be varing --- test/run_test.py | 3 ++- tools/stats/import_test_stats.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/test/run_test.py b/test/run_test.py index 5464cf61aa3c2..94d8706dd3a05 100755 --- a/test/run_test.py +++ b/test/run_test.py @@ -1428,7 +1428,8 @@ def load_test_times_from_file( with open(path) as f: test_times_file = cast(Dict[str, Any], json.load(f)) - build_environment = os.environ.get("BUILD_ENVIRONMENT") + # build_environment hard coded to value from upstream when branch is created + build_environment = "linux-focal-rocm6.0-py3.8" test_config = os.environ.get("TEST_CONFIG") if test_config in test_times_file.get(build_environment, {}): print_to_stderr("Found test times from artifacts") diff --git a/tools/stats/import_test_stats.py b/tools/stats/import_test_stats.py index 513edb12fcfe6..9a93ccbc2718c 100644 --- a/tools/stats/import_test_stats.py +++ b/tools/stats/import_test_stats.py @@ -30,7 +30,8 @@ def get_disabled_issues() -> List[str]: TD_HEURISTIC_PREVIOUSLY_FAILED = "previous_failures.json" TD_HEURISTIC_PREVIOUSLY_FAILED_ADDITIONAL = "previous_failures_additional.json" -FILE_CACHE_LIFESPAN_SECONDS = datetime.timedelta(hours=3).seconds +#increse the cache time to 6 months +FILE_CACHE_LIFESPAN_SECONDS = 6 * 30 * 24 * 3600 def fetch_and_cache( From 00307cc0762c7e3c721b2cb585fe17b5a370ccc0 Mon Sep 17 00:00:00 2001 From: Xinya Zhang Date: Fri, 26 Jan 2024 14:44:20 -0600 Subject: [PATCH 19/57] Fixes CI build script (#1350) * Fix the parsing of /etc/os-release The old code parses OS_DISTRO as 'PRETTY_Ubuntu' on Ubuntu and thus never links to libtinfo correctly. * Configurable CMAKE_PREFIX_PATH in CI script. --- .ci/pytorch/build.sh | 4 +--- cmake/Dependencies.cmake | 4 ++-- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/.ci/pytorch/build.sh b/.ci/pytorch/build.sh index 187e6d788bddd..1a1be1977f1ef 100755 --- a/.ci/pytorch/build.sh +++ b/.ci/pytorch/build.sh @@ -85,9 +85,7 @@ else elif [[ -v ANACONDA_PYTHON_VERSION ]]; then export CMAKE_PREFIX_PATH="/opt/conda/envs/py_${ANACONDA_PYTHON_VERSION}" else - # already checked by `! which conda` - CMAKE_PREFIX_PATH="$(conda info --base)" - export CMAKE_PREFIX_PATH + export CMAKE_PREFIX_PATH="$(conda info --base)" fi # Workaround required for MKL library linkage diff --git a/cmake/Dependencies.cmake b/cmake/Dependencies.cmake index 60677604c015e..63fd75ac858af 100644 --- a/cmake/Dependencies.cmake +++ b/cmake/Dependencies.cmake @@ -1010,11 +1010,11 @@ if(USE_ROCM) set(DISTRO_VERSION "") foreach(line ${OS_RELEASE}) string(REGEX MATCH "^NAME=" DISTRO_NAME_MATCH ${line}) - if(NOT DISTRO_NAME_MATCH STREQUAL "") + if (NOT DISTRO_NAME_MATCH STREQUAL "") string(REGEX REPLACE "^NAME=\"(.*)\"" "\\1" DISTRO_NAME ${line}) endif() string(REGEX MATCH "^VERSION_ID=" DISTRO_VERSION_MATCH ${line}) - if(NOT DISTRO_VERSION_MATCH STREQUAL "") + if (NOT DISTRO_VERSION_MATCH STREQUAL "") string(REGEX REPLACE "^VERSION_ID=\"(.*)\"" "\\1" DISTRO_VERSION ${line}) endif() endforeach() From 312077844463faa37c09994800f0c72942fdd305 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Mon, 29 Jan 2024 18:04:15 -0800 Subject: [PATCH 20/57] [NO CP] Temporary dumping of test exec log to stderr - This is done as per QA request, needs to be reverted and not required to be cherry-picked into later releases. --- test/run_test.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/run_test.py b/test/run_test.py index 94d8706dd3a05..bff83a1ec893a 100755 --- a/test/run_test.py +++ b/test/run_test.py @@ -945,6 +945,11 @@ def handle_log_file( if re.search("Running .* items in this shard:", line): print_to_stderr(line.rstrip()) print_to_stderr("") + + # Temporary dumping the log file into stderr for QA reference + print_to_stderr(f"\n START of temporary dumping of {test} execution log file from ({file_path})") + print_to_stderr(full_text) + print_to_stderr(f"END of temporary dumping of {test} execution log file form ({file_path})\n") return # otherwise: print entire file From 9726c26366d03390f8c090570dc43767efe93b56 Mon Sep 17 00:00:00 2001 From: Jack Taylor <108682042+jataylo@users.noreply.github.com> Date: Mon, 26 Feb 2024 17:07:48 +0000 Subject: [PATCH 21/57] Add skipIfRocmArch decorator for Navi skips (#1356) --- test/inductor/test_cuda_repro.py | 6 +++- test/inductor/test_torchinductor.py | 25 ++++++++++++++++ test/inductor/test_torchinductor_opinfo.py | 14 +++++++++ torch/testing/_internal/common_utils.py | 33 ++++++++++++++++++++++ 4 files changed, 77 insertions(+), 1 deletion(-) diff --git a/test/inductor/test_cuda_repro.py b/test/inductor/test_cuda_repro.py index 8d0b6652be1e3..bee98c6c45c89 100644 --- a/test/inductor/test_cuda_repro.py +++ b/test/inductor/test_cuda_repro.py @@ -27,6 +27,7 @@ freeze_rng_state, IS_FBCODE, skipIfRocm, + skipIfRocmArch, TEST_WITH_ASAN, ) @@ -48,7 +49,7 @@ sys.exit(0) raise - +NAVI_ARCH = ("gfx1100", "gfx1101") # Used for navi exclusive skips on ROCm TestCase = test_torchinductor.TestCase ToTuple = test_torchinductor.ToTuple check_model_cuda = test_torchinductor.check_model_cuda @@ -313,6 +314,7 @@ def foo(x): out_ref.add_(2) # self.assertEqual(out_ref, out) + @skipIfRocmArch(NAVI_ARCH) def test_accuracy_issue1(self): class Repro(torch.nn.Module): def __init__(self): @@ -349,6 +351,7 @@ def forward(self, start_positions: torch.Tensor, x: torch.Tensor): assert same_two_models(mod, opt_mod, args), "Dynamo failed" @config.patch(allow_buffer_reuse=False) + @skipIfRocmArch(NAVI_ARCH) def test_issue103461(self): def forward(add_1): var_mean = torch.ops.aten.var_mean.correction( @@ -832,6 +835,7 @@ def forward(self, x): res2 = jit_func(x) self.assertEqual(res1, res2) + @skipIfRocmArch(NAVI_ARCH) def test_issue103481(self): def fn(x, y): # NOTE: 6 dimensions is important! does not fail for 5 dimensions diff --git a/test/inductor/test_torchinductor.py b/test/inductor/test_torchinductor.py index 38b1abc6aa085..cb11479e6d8fd 100644 --- a/test/inductor/test_torchinductor.py +++ b/test/inductor/test_torchinductor.py @@ -87,6 +87,7 @@ skipIfRocm, skipIfXpu, subtest, + skipIfRocmArch, TEST_WITH_ASAN, TEST_WITH_ROCM, ) @@ -129,6 +130,10 @@ ) HAS_AVX2 = "fbgemm" in torch.backends.quantized.supported_engines +_desired_test_bases = get_desired_device_type_test_bases() +RUN_CPU = any(getattr(x, "device_type", "") == "cpu" for x in _desired_test_bases) +RUN_GPU = any(getattr(x, "device_type", "") == GPU_TYPE for x in _desired_test_bases) +NAVI_ARCH = ("gfx1100", "gfx1101") # Used for navi exclusive skips on ROCm aten = torch.ops.aten @@ -1648,6 +1653,7 @@ def fn(x): # make sure things also work if they aren't unrolled self.common(fn, (torch.randn(8, 3),)) + @skipIfRocmArch(NAVI_ARCH) def test_multilayer_sum_low_prec(self): # fp16 nyi for cpu if self.device == "cpu": @@ -1658,6 +1664,7 @@ def fn(a): self.common(fn, ((torch.rand((10, 3, 352, 352), dtype=torch.float16),))) + @skipIfRocmArch(NAVI_ARCH) def test_multilayer_prime_size(self): def fn(a): return torch.max(a), torch.sum(a) @@ -1668,6 +1675,7 @@ def fn(a): self.common(fn, (sample,)) @skipCPUIf(IS_MACOS, "fails on macos") + @skipIfRocmArch(NAVI_ARCH) def test_multilayer_var(self): def fn(a): return torch.var(a) @@ -2667,6 +2675,7 @@ def fn(a, b): self.common(fn, (torch.randn(8, 8), torch.randn(8, 8))) + @skipIfRocmArch(NAVI_ARCH) def test_large_tensor_reduction(self): if not _has_sufficient_memory(self.device, 4.5 * 1024**3): # 4.5 GiB raise unittest.SkipTest("insufficient memory") @@ -2687,6 +2696,7 @@ def fn(a): expect = torch.tensor(2, dtype=torch.int8, device=self.device) self.assertEqual(actual, expect) + @skipIfRocmArch(NAVI_ARCH) def test_large_broadcast_reduction(self): if self.device == "cpu": raise unittest.SkipTest("Fails on CPU") @@ -3761,6 +3771,7 @@ def test_conv2d_channels_last(self): check_lowp=False, ) + @skipIfRocmArch(NAVI_ARCH) def test_conv2d_backward_channels_last(self): def fn(grad_output, inp, weight): convolution_backward_8 = torch.ops.aten.convolution_backward.default( @@ -4520,6 +4531,7 @@ def fn(x, y): self.assertEqual(a.stride(), c.stride()) self.assertEqual(c.stride()[2], 1) + @skipIfRocmArch(NAVI_ARCH) def test_std(self): def fn(x): return ( @@ -4562,6 +4574,7 @@ def test_batch_norm_2d(self): # From yolov3 @with_tf32_off + @skipIfRocmArch(NAVI_ARCH) def test_batch_norm_2d_2(self): if self.device == "cpu": raise unittest.SkipTest(f"requires {GPU_TYPE}") @@ -4697,6 +4710,7 @@ def fn(x): self.common(fn, (x,)) + @skipIfRocmArch(NAVI_ARCH) def test_cauchy(self): def fn(x, y): return torch.sum(1 / (torch.unsqueeze(x, -1) - y)) @@ -6034,6 +6048,7 @@ def fn(a): y = fn_compiled(x) self.assertTrue(y is not x) + @skipIfRocmArch(NAVI_ARCH) def test_l1_loss(self): def fn(a, b): return torch.nn.functional.l1_loss(a, b), torch.nn.functional.mse_loss(a, b) @@ -6430,6 +6445,7 @@ def fn(x): fn, (torch.tensor([1, float("inf"), 2, float("-inf"), float("nan")]),) ) + @skipIfRocmArch(NAVI_ARCH) def test_any(self): def fn(x): return ( @@ -7177,6 +7193,8 @@ def fn(a, dim, index, b, reduce): check_lowp=check_lowp, ) + # issue #1150 + @skipIfRocmArch(NAVI_ARCH) def test_dense_mask_index(self): r""" There will be a little difference for reduce order between aten and inductor @@ -8152,6 +8170,7 @@ def fn(a, b): b = torch.rand(2, 2, 1, 4, 1).int() self.common(fn, (a, b)) + @skipIfRocmArch(NAVI_ARCH) def test_argmax_argmin1(self): def fn(x): return (aten.argmax(x), aten.argmin(x)) @@ -8163,6 +8182,7 @@ def fn(x): ], ) + @skipIfRocmArch(NAVI_ARCH) def test_argmax_argmin2(self): def fn(x): return ( @@ -8174,6 +8194,7 @@ def fn(x): self.common(fn, (torch.randn([144, 144]),)) + @skipIfRocmArch(NAVI_ARCH) def test_argmax_argmin_with_duplicates(self): def fn(x): return ( @@ -8195,6 +8216,7 @@ def fn(x): t1 = torch.randint(8, size=(1028, 1028)) self.common(fn, (t1,)) + @skipIfRocmArch(NAVI_ARCH) def test_argmax_argmin_with_nan(self): def fn(x): return ( @@ -8327,6 +8349,7 @@ def fn(x): ], ) + @skipIfRocmArch(NAVI_ARCH) def test_tmp_not_defined_issue1(self): def forward( primals_3, @@ -8721,6 +8744,7 @@ def __torch_dispatch__(self, func, types, args=(), kwargs=None): else: self.assertEqual(len(inps), 0) + @skipIfRocmArch(NAVI_ARCH) def test_dtype_mismatch_issue(self): def fn(x): attn = torch.nn.functional.pad(x, [0, 1]) @@ -11388,6 +11412,7 @@ def test_rnn_compile_safe(self): class NanCheckerTest(TestCase): @config.patch("nan_asserts", True) + @skipIfRocmArch(NAVI_ARCH) def test_nan_checker_pass(self): def f(x): return torch.softmax(x, dim=-1) diff --git a/test/inductor/test_torchinductor_opinfo.py b/test/inductor/test_torchinductor_opinfo.py index 7998a3aff58d6..13507dc41c6e3 100644 --- a/test/inductor/test_torchinductor_opinfo.py +++ b/test/inductor/test_torchinductor_opinfo.py @@ -31,6 +31,7 @@ from torch.testing._internal.common_methods_invocations import op_db, skipOps from torch.testing._internal.common_utils import ( dtype_abbrs, + IS_NAVI, IS_MACOS, IS_X86, skipCUDAMemoryLeakCheckIf, @@ -203,6 +204,19 @@ def format_op(op): # Tensors are not alike inductor_skips["cuda"]["logcumsumexp"] = {f32} inductor_skips["cuda"]["special.modified_bessel_i1"] = {f64} + if IS_NAVI: + inductor_skips["cuda"]["aminmax"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["dist"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["kron"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["masked.std"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["masked.var"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"][("max", "reduction_no_dim")] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"][("min", "reduction_no_dim")] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["nn.functional.conv_transpose3d"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["std"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["std_mean"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["var"] = {b8, f16, f32, f64, i32, i64} + inductor_skips["cuda"]["var_mean"] = {b8, f16, f32, f64, i32, i64} inductor_expected_failures_single_sample = defaultdict(dict) diff --git a/torch/testing/_internal/common_utils.py b/torch/testing/_internal/common_utils.py index bb5f3fa8e3308..8a6d988834da0 100644 --- a/torch/testing/_internal/common_utils.py +++ b/torch/testing/_internal/common_utils.py @@ -1180,6 +1180,13 @@ def printErrors(self) -> None: IS_X86 = platform.machine() in ('x86_64', 'i386') IS_ARM64 = platform.machine() in ('arm64', 'aarch64') +IS_NAVI=False +if torch.cuda.is_available(): + prop = torch.cuda.get_device_properties(0) + gfx_arch = prop.gcnArchName.split(":")[0] + if gfx_arch in ["gfx1100", "gfx1101", "gfx1102"]: + IS_NAVI = True + def is_avx512_vnni_supported(): if sys.platform != 'linux': return False @@ -1590,6 +1597,19 @@ def wrapper(*args, **kwargs): return dec_fn(func) return dec_fn +def skipIfRocmArch(arch: Tuple[str, ...]): + def dec_fn(fn): + @wraps(fn) + def wrap_fn(self, *args, **kwargs): + if TEST_WITH_ROCM: + prop = torch.cuda.get_device_properties(0) + if prop.gcnArchName.split(":")[0] in arch: + reason = f"skipIfRocm: test skipped on {arch}" + raise unittest.SkipTest(reason) + return fn(self, *args, **kwargs) + return wrap_fn + return dec_fn + def runOnRocm(fn): @wraps(fn) def wrapper(*args, **kwargs): @@ -1599,6 +1619,19 @@ def wrapper(*args, **kwargs): raise unittest.SkipTest("test currently only works on the ROCm stack") return wrapper +def runOnRocmArch(arch: Tuple[str, ...]): + def dec_fn(fn): + @wraps(fn) + def wrap_fn(self, *args, **kwargs): + if TEST_WITH_ROCM: + prop = torch.cuda.get_device_properties(0) + if prop.gcnArchName.split(":")[0] not in arch: + reason = f"skipIfRocm: test skipped on {arch}" + raise unittest.SkipTest(reason) + return fn(self, *args, **kwargs) + return wrap_fn + return dec_fn + def skipIfXpu(func=None, *, msg="test doesn't currently work on the XPU stack"): def dec_fn(fn): reason = f"skipIfXpu: {msg}" From 91125f1654ac2bac6f9c37293f4bc3001a11cd21 Mon Sep 17 00:00:00 2001 From: Bo Li <110066325+BLOrange-AMD@users.noreply.github.com> Date: Thu, 7 Mar 2024 17:42:31 -0600 Subject: [PATCH 22/57] Converted NAVI check as a function (#1364) * Moved NAVI check to the test file * Revised NAVI check as a function --- test/inductor/test_torchinductor_opinfo.py | 4 ++-- torch/testing/_internal/common_utils.py | 13 +++++++------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/test/inductor/test_torchinductor_opinfo.py b/test/inductor/test_torchinductor_opinfo.py index 13507dc41c6e3..a7c2400cc5761 100644 --- a/test/inductor/test_torchinductor_opinfo.py +++ b/test/inductor/test_torchinductor_opinfo.py @@ -31,9 +31,9 @@ from torch.testing._internal.common_methods_invocations import op_db, skipOps from torch.testing._internal.common_utils import ( dtype_abbrs, - IS_NAVI, IS_MACOS, IS_X86, + is_navi_arch, skipCUDAMemoryLeakCheckIf, skipIfCrossRef, skipIfTorchDynamo, @@ -204,7 +204,7 @@ def format_op(op): # Tensors are not alike inductor_skips["cuda"]["logcumsumexp"] = {f32} inductor_skips["cuda"]["special.modified_bessel_i1"] = {f64} - if IS_NAVI: + if is_navi_arch(): inductor_skips["cuda"]["aminmax"] = {b8, f16, f32, f64, i32, i64} inductor_skips["cuda"]["dist"] = {b8, f16, f32, f64, i32, i64} inductor_skips["cuda"]["kron"] = {b8, f16, f32, f64, i32, i64} diff --git a/torch/testing/_internal/common_utils.py b/torch/testing/_internal/common_utils.py index 8a6d988834da0..9c746bd4392b6 100644 --- a/torch/testing/_internal/common_utils.py +++ b/torch/testing/_internal/common_utils.py @@ -1180,12 +1180,13 @@ def printErrors(self) -> None: IS_X86 = platform.machine() in ('x86_64', 'i386') IS_ARM64 = platform.machine() in ('arm64', 'aarch64') -IS_NAVI=False -if torch.cuda.is_available(): - prop = torch.cuda.get_device_properties(0) - gfx_arch = prop.gcnArchName.split(":")[0] - if gfx_arch in ["gfx1100", "gfx1101", "gfx1102"]: - IS_NAVI = True +def is_navi_arch(): + if torch.cuda.is_available(): + prop = torch.cuda.get_device_properties(0) + gfx_arch = prop.gcnArchName.split(":")[0] + if gfx_arch in ["gfx1100", "gfx1101", "gfx1102"]: + return True + return False def is_avx512_vnni_supported(): if sys.platform != 'linux': From 623579fbc1787537874e27860cbecac50b4d4883 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Fri, 8 Mar 2024 11:29:12 -0800 Subject: [PATCH 23/57] Triton build conditionalized on ROCM_VERSION --- .github/scripts/build_triton_wheel.py | 28 +++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/.github/scripts/build_triton_wheel.py b/.github/scripts/build_triton_wheel.py index f422f6766cc40..cd82045492272 100644 --- a/.github/scripts/build_triton_wheel.py +++ b/.github/scripts/build_triton_wheel.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import os +import re import shutil import sys from pathlib import Path @@ -43,6 +44,31 @@ def patch_init_py( with open(path, "w") as f: f.write(orig) +def get_rocm_version() -> str: + rocm_path = os.environ.get('ROCM_HOME') or os.environ.get('ROCM_PATH') or "/opt/rocm" + rocm_version = "0.0.0" + rocm_version_h = f"{rocm_path}/include/rocm-core/rocm_version.h" + if not os.path.isfile(rocm_version_h): + rocm_version_h = f"{rocm_path}/include/rocm_version.h" + + # The file could be missing due to 1) ROCm version < 5.2, or 2) no ROCm install. + if os.path.isfile(rocm_version_h): + RE_MAJOR = re.compile(r"#define\s+ROCM_VERSION_MAJOR\s+(\d+)") + RE_MINOR = re.compile(r"#define\s+ROCM_VERSION_MINOR\s+(\d+)") + RE_PATCH = re.compile(r"#define\s+ROCM_VERSION_PATCH\s+(\d+)") + major, minor, patch = 0, 0, 0 + for line in open(rocm_version_h): + match = RE_MAJOR.search(line) + if match: + major = int(match.group(1)) + match = RE_MINOR.search(line) + if match: + minor = int(match.group(1)) + match = RE_PATCH.search(line) + if match: + patch = int(match.group(1)) + rocm_version = str(major)+"."+str(minor)+"."+str(patch) + return rocm_version def build_triton( *, @@ -146,6 +172,8 @@ def build_triton( cwd=triton_basedir, shell=True, ) + cur_rocm_ver = get_rocm_version() + check_call(["scripts/amd/setup_rocm_libs.sh", cur_rocm_ver], cwd=triton_basedir) print("ROCm libraries setup for triton installation...") check_call( From b39d5fa36287f9fb417484315c8d3577324829b3 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 12 Mar 2024 09:56:58 -0700 Subject: [PATCH 24/57] Remove ROCmloops specific test --- aten/src/ATen/test/cuda_vectorized_test.cu | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/aten/src/ATen/test/cuda_vectorized_test.cu b/aten/src/ATen/test/cuda_vectorized_test.cu index 2bd192c07e6e5..4557689c4a14b 100644 --- a/aten/src/ATen/test/cuda_vectorized_test.cu +++ b/aten/src/ATen/test/cuda_vectorized_test.cu @@ -27,23 +27,6 @@ void reset_buffers() { } } -#if defined(USE_ROCM) -TEST(TestLoops, HasSameArgTypes) { - // This is a compile-time unit test. If this file compiles without error, - // then the test passes and during runtime, we just need to return. - using namespace at::native::modern::detail; - using func1_t = int (*)(float, float); - using func2_t = int (*)(bool, float, float); - using func3_t = int (*)(float); - using func4_t = int (*)(); - static_assert(has_same_arg_types::value, "func1_t has the same argument types"); - static_assert(!has_same_arg_types::value, "func2_t does not have the same argument types"); - static_assert(has_same_arg_types::value, "func3_t has the same argument types"); - static_assert(has_same_arg_types::value, "func4_t has the same argument types"); - return; -} -#endif - TEST(TestVectorizedMemoryAccess, CanVectorizeUpTo) { char *ptr = reinterpret_cast(buffer1); From 6d3494e4d992d5a478ca2556176091226382c7f2 Mon Sep 17 00:00:00 2001 From: Prachi Gupta Date: Wed, 20 Mar 2024 17:21:20 -0400 Subject: [PATCH 25/57] Bad import in test_torchinductor and skip torchvision related UT (#1374) --- test/inductor/test_torchinductor.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/test/inductor/test_torchinductor.py b/test/inductor/test_torchinductor.py index cb11479e6d8fd..5356a5d5b15e1 100644 --- a/test/inductor/test_torchinductor.py +++ b/test/inductor/test_torchinductor.py @@ -88,6 +88,7 @@ skipIfXpu, subtest, skipIfRocmArch, + subtest, TEST_WITH_ASAN, TEST_WITH_ROCM, ) @@ -6375,6 +6376,7 @@ def fn(in_ptr0, in_ptr1, in_ptr2): ), ) + @skipIfRocm def test_roi_align(self): if not has_torchvision_roi_align(): raise unittest.SkipTest("requires torchvision") From f02e87f69ef16bfd3a11e045312f09b92d490278 Mon Sep 17 00:00:00 2001 From: Prachi Gupta Date: Wed, 20 Mar 2024 17:21:43 -0400 Subject: [PATCH 26/57] skip test_inductor_freezing failing UTs (#1375) --- test/inductor/test_inductor_freezing.py | 1 + 1 file changed, 1 insertion(+) diff --git a/test/inductor/test_inductor_freezing.py b/test/inductor/test_inductor_freezing.py index 89538636149a0..945e52235dc8a 100644 --- a/test/inductor/test_inductor_freezing.py +++ b/test/inductor/test_inductor_freezing.py @@ -27,6 +27,7 @@ IS_WINDOWS, TEST_WITH_ASAN, TEST_WITH_ROCM, + skipIfRocm, ) if IS_WINDOWS and IS_CI: From c1f1f51589110d9450a59ed980d59ef5101b605b Mon Sep 17 00:00:00 2001 From: Prachi Gupta Date: Thu, 21 Mar 2024 15:50:23 -0400 Subject: [PATCH 27/57] Skip test_mm_triton_kernel_benchmark (#1376) * Running triton kernel on ROCM only has one GB/s metric reported * Update test_kernel_benchmark.py --- test/inductor/test_kernel_benchmark.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/inductor/test_kernel_benchmark.py b/test/inductor/test_kernel_benchmark.py index ffe0300d8aad2..5b27f3cb55e4d 100644 --- a/test/inductor/test_kernel_benchmark.py +++ b/test/inductor/test_kernel_benchmark.py @@ -15,7 +15,7 @@ from torch.testing import FileCheck from torch.testing._internal.common_device_type import expectedFailureXPU from torch.testing._internal.inductor_utils import GPU_TYPE, HAS_GPU - +from torch.testing._internal.common_utils import skipIfRocm class TestKernelBenchmark(TestCase): device_type = GPU_TYPE @@ -135,6 +135,7 @@ def f(a, b): @expectedFailureXPU @config.patch(max_autotune=True, max_autotune_gemm_backends="TRITON") @fresh_inductor_cache() + @skipIfRocm #This seems to be disabled upstream https://github.com/pytorch/pytorch/issues/118346 def test_mm_triton_kernel_benchmark(self): M = 2048 N = 2432 From 37209529937774e1b8b4b2c68693d2bfdb780e1d Mon Sep 17 00:00:00 2001 From: Bo Li <110066325+BLOrange-AMD@users.noreply.github.com> Date: Thu, 18 Apr 2024 11:12:30 -0500 Subject: [PATCH 28/57] Implementation of PyTorch ut parsing script - QA helper function (#1386) * Initial implementation of PyTorch ut parsing script * Extracted path variables * Use nested dict to save results * Fixes typo * Cleanup * Fixes several issues * Minor name change * Update run_pytorch_unit_tests.py * Added file banners * Supported running from API * Added more help info * Consistent naming * Format help text --------- Co-authored-by: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> Co-authored-by: Jithun Nair --- .automation_scripts/parse_xml_results.py | 172 +++++++ .automation_scripts/run_pytorch_unit_tests.py | 445 ++++++++++++++++++ 2 files changed, 617 insertions(+) create mode 100644 .automation_scripts/parse_xml_results.py create mode 100644 .automation_scripts/run_pytorch_unit_tests.py diff --git a/.automation_scripts/parse_xml_results.py b/.automation_scripts/parse_xml_results.py new file mode 100644 index 0000000000000..4a18d7bfca4ee --- /dev/null +++ b/.automation_scripts/parse_xml_results.py @@ -0,0 +1,172 @@ +""" The Python PyTorch testing script. +## +# Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +""" + +import xml.etree.ElementTree as ET +from pathlib import Path +from typing import Any, Dict, Tuple + +# Backends list +BACKENDS_LIST = [ + "dist-gloo", + "dist-nccl" +] + +TARGET_WORKFLOW = "--rerun-disabled-tests" + +def get_job_id(report: Path) -> int: + # [Job id in artifacts] + # Retrieve the job id from the report path. In our GHA workflows, we append + # the job id to the end of the report name, so `report` looks like: + # unzipped-test-reports-foo_5596745227/test/test-reports/foo/TEST-foo.xml + # and we want to get `5596745227` out of it. + try: + return int(report.parts[0].rpartition("_")[2]) + except ValueError: + return -1 + +def is_rerun_disabled_tests(root: ET.ElementTree) -> bool: + """ + Check if the test report is coming from rerun_disabled_tests workflow + """ + skipped = root.find(".//*skipped") + # Need to check against None here, if not skipped doesn't work as expected + if skipped is None: + return False + + message = skipped.attrib.get("message", "") + return TARGET_WORKFLOW in message or "num_red" in message + +def parse_xml_report( + tag: str, + report: Path, + workflow_id: int, + workflow_run_attempt: int, + work_flow_name: str +) -> Dict[Tuple[str], Dict[str, Any]]: + """Convert a test report xml file into a JSON-serializable list of test cases.""" + print(f"Parsing {tag}s for test report: {report}") + + job_id = get_job_id(report) + print(f"Found job id: {job_id}") + + test_cases: Dict[Tuple[str], Dict[str, Any]] = {} + + root = ET.parse(report) + # TODO: unlike unittest, pytest-flakefinder used by rerun disabled tests for test_ops + # includes skipped messages multiple times (50 times by default). This slows down + # this script too much (O(n)) because it tries to gather all the stats. This should + # be fixed later in the way we use pytest-flakefinder. A zipped test report from rerun + # disabled test is only few MB, but will balloon up to a much bigger XML file after + # extracting from a dozen to few hundred MB + if is_rerun_disabled_tests(root): + return test_cases + + for test_case in root.iter(tag): + case = process_xml_element(test_case) + if tag == 'testcase': + case["workflow_id"] = workflow_id + case["workflow_run_attempt"] = workflow_run_attempt + case["job_id"] = job_id + case["work_flow_name"] = work_flow_name + + # [invoking file] + # The name of the file that the test is located in is not necessarily + # the same as the name of the file that invoked the test. + # For example, `test_jit.py` calls into multiple other test files (e.g. + # jit/test_dce.py). For sharding/test selection purposes, we want to + # record the file that invoked the test. + # + # To do this, we leverage an implementation detail of how we write out + # tests (https://bit.ly/3ajEV1M), which is that reports are created + # under a folder with the same name as the invoking file. + case_name = report.parent.name + for ind in range(len(BACKENDS_LIST)): + if BACKENDS_LIST[ind] in report.parts: + case_name = case_name + "_" + BACKENDS_LIST[ind] + break + case["invoking_file"] = case_name + test_cases[ ( case["invoking_file"], case["classname"], case["name"], case["work_flow_name"] ) ] = case + elif tag == 'testsuite': + case["work_flow_name"] = work_flow_name + case["invoking_file"] = report.parent.name + case["invoking_xml"] = report.name + case["running_time_xml"] = case["time"] + test_cases[ ( case["invoking_file"], case["invoking_xml"], case["work_flow_name"] ) ] = case + + return test_cases + +def process_xml_element(element: ET.Element) -> Dict[str, Any]: + """Convert a test suite element into a JSON-serializable dict.""" + ret: Dict[str, Any] = {} + + # Convert attributes directly into dict elements. + # e.g. + # + # becomes: + # {"name": "test_foo", "classname": "test_bar"} + ret.update(element.attrib) + + # The XML format encodes all values as strings. Convert to ints/floats if + # possible to make aggregation possible in Rockset. + for k, v in ret.items(): + try: + ret[k] = int(v) + except ValueError: + pass + try: + ret[k] = float(v) + except ValueError: + pass + + # Convert inner and outer text into special dict elements. + # e.g. + # my_inner_text my_tail + # becomes: + # {"text": "my_inner_text", "tail": " my_tail"} + if element.text and element.text.strip(): + ret["text"] = element.text + if element.tail and element.tail.strip(): + ret["tail"] = element.tail + + # Convert child elements recursively, placing them at a key: + # e.g. + # + # hello + # world + # another + # + # becomes + # { + # "foo": [{"text": "hello"}, {"text": "world"}], + # "bar": {"text": "another"} + # } + for child in element: + if child.tag not in ret: + ret[child.tag] = process_xml_element(child) + else: + # If there are multiple tags with the same name, they should be + # coalesced into a list. + if not isinstance(ret[child.tag], list): + ret[child.tag] = [ret[child.tag]] + ret[child.tag].append(process_xml_element(child)) + return ret \ No newline at end of file diff --git a/.automation_scripts/run_pytorch_unit_tests.py b/.automation_scripts/run_pytorch_unit_tests.py new file mode 100644 index 0000000000000..5a9ed72424a37 --- /dev/null +++ b/.automation_scripts/run_pytorch_unit_tests.py @@ -0,0 +1,445 @@ +#!/usr/bin/env python3 + +""" The Python PyTorch testing script. +## +# Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. +""" + +import argparse +import os +import shutil +import subprocess + +from collections import namedtuple +from datetime import datetime +from pathlib import Path +from parse_xml_results import ( + parse_xml_report +) +from pprint import pprint +from typing import Any, Dict, List + +# unit test status list +UT_STATUS_LIST = [ + "PASSED", + "MISSED", + "SKIPPED", + "FAILED", + "XFAILED", + "ERROR" +] + +DEFAULT_CORE_TESTS = [ + "test_nn", + "test_torch", + "test_cuda", + "test_ops", + "test_unary_ufuncs", + "test_autograd", + "inductor/test_torchinductor" +] + +DISTRIBUTED_CORE_TESTS = [ + "distributed/test_c10d_common", + "distributed/test_c10d_nccl", + "distributed/test_distributed_spawn" +] + +def parse_xml_reports_as_dict(workflow_run_id, workflow_run_attempt, tag, workflow_name, path="."): + test_cases = {} + items_list = os.listdir(path) + for dir in items_list: + new_dir = path + '/' + dir + '/' + if os.path.isdir(new_dir): + for xml_report in Path(new_dir).glob("**/*.xml"): + test_cases.update( + parse_xml_report( + tag, + xml_report, + workflow_run_id, + workflow_run_attempt, + workflow_name + ) + ) + return test_cases + +def get_test_status(test_case): + # In order of priority: S=skipped, F=failure, E=error, P=pass + if "skipped" in test_case and test_case["skipped"]: + type_message = test_case["skipped"] + if type_message.__contains__('type') and type_message['type'] == "pytest.xfail": + return "XFAILED" + else: + return "SKIPPED" + elif "failure" in test_case and test_case["failure"]: + return "FAILED" + elif "error" in test_case and test_case["error"]: + return "ERROR" + else: + return "PASSED" + +def get_test_message(test_case, status=None): + if status == "SKIPPED": + return test_case["skipped"] if "skipped" in test_case else "" + elif status == "FAILED": + return test_case["failure"] if "failure" in test_case else "" + elif status == "ERROR": + return test_case["error"] if "error" in test_case else "" + else: + if "skipped" in test_case: + return test_case["skipped"] + elif "failure" in test_case: + return test_case["failure"] + elif "error" in test_case: + return test_case["error"] + else: + return "" + +def get_test_running_time(test_case): + if test_case.__contains__('time'): + return test_case["time"] + return "" + +def summarize_xml_files(path, workflow_name): + # statistics + TOTAL_TEST_NUM = 0 + TOTAL_PASSED_NUM = 0 + TOTAL_SKIPPED_NUM = 0 + TOTAL_XFAIL_NUM = 0 + TOTAL_FAILED_NUM = 0 + TOTAL_ERROR_NUM = 0 + + #parse the xml files + test_cases = parse_xml_reports_as_dict(-1, -1, 'testcase', workflow_name, path) + test_file_and_status = namedtuple("test_file_and_status", ["file_name", "status"]) + # results dict + res = {} + res_item_list = [ "PASSED", "SKIPPED", "XFAILED", "FAILED", "ERROR" ] + test_file_items = set() + for (k,v) in list(test_cases.items()): + file_name = k[0] + if not file_name in test_file_items: + test_file_items.add(file_name) + # initialization + for item in res_item_list: + temp_item = test_file_and_status(file_name, item) + res[temp_item] = {} + temp_item_statistics = test_file_and_status(file_name, "STATISTICS") + res[temp_item_statistics] = {'TOTAL': 0, 'PASSED': 0, 'SKIPPED': 0, 'XFAILED': 0, 'FAILED': 0, 'ERROR': 0} + + for (k,v) in list(test_cases.items()): + file_name = k[0] + class_name = k[1] + test_name = k[2] + combined_name = file_name + "::" + class_name + "::" + test_name + test_status = get_test_status(v) + test_running_time = get_test_running_time(v) + test_message = get_test_message(v, test_status) + test_info_value = "" + test_tuple_key_status = test_file_and_status(file_name, test_status) + test_tuple_key_statistics = test_file_and_status(file_name, "STATISTICS") + TOTAL_TEST_NUM += 1 + res[test_tuple_key_statistics]["TOTAL"] += 1 + if test_status == "PASSED": + test_info_value = str(test_running_time) + res[test_tuple_key_status][combined_name] = test_info_value + res[test_tuple_key_statistics]["PASSED"] += 1 + TOTAL_PASSED_NUM += 1 + elif test_status == "SKIPPED": + test_info_value = str(test_running_time) + res[test_tuple_key_status][combined_name] = test_info_value + res[test_tuple_key_statistics]["SKIPPED"] += 1 + TOTAL_SKIPPED_NUM += 1 + elif test_status == "XFAILED": + test_info_value = str(test_running_time) + res[test_tuple_key_status][combined_name] = test_info_value + res[test_tuple_key_statistics]["XFAILED"] += 1 + TOTAL_XFAIL_NUM += 1 + elif test_status == "FAILED": + test_info_value = test_message + res[test_tuple_key_status][combined_name] = test_info_value + res[test_tuple_key_statistics]["FAILED"] += 1 + TOTAL_FAILED_NUM += 1 + elif test_status == "ERROR": + test_info_value = test_message + res[test_tuple_key_status][combined_name] = test_info_value + res[test_tuple_key_statistics]["ERROR"] += 1 + TOTAL_ERROR_NUM += 1 + + # generate statistics_dict + statistics_dict = {} + statistics_dict["TOTAL"] = TOTAL_TEST_NUM + statistics_dict["PASSED"] = TOTAL_PASSED_NUM + statistics_dict["SKIPPED"] = TOTAL_SKIPPED_NUM + statistics_dict["XFAILED"] = TOTAL_XFAIL_NUM + statistics_dict["FAILED"] = TOTAL_FAILED_NUM + statistics_dict["ERROR"] = TOTAL_ERROR_NUM + aggregate_item = workflow_name + "_aggregate" + total_item = test_file_and_status(aggregate_item, "STATISTICS") + res[total_item] = statistics_dict + + return res + +def run_entire_tests(workflow_name, test_shell_path, overall_logs_path_current_run, test_reports_src): + if os.path.exists(test_reports_src): + shutil.rmtree(test_reports_src) + + os.mkdir(test_reports_src) + copied_logs_path = "" + if workflow_name == "default": + os.environ['TEST_CONFIG'] = 'default' + copied_logs_path = overall_logs_path_current_run + "default_xml_results_entire_tests/" + elif workflow_name == "distributed": + os.environ['TEST_CONFIG'] = 'distributed' + copied_logs_path = overall_logs_path_current_run + "distributed_xml_results_entire_tests/" + elif workflow_name == "inductor": + os.environ['TEST_CONFIG'] = 'inductor' + copied_logs_path = overall_logs_path_current_run + "inductor_xml_results_entire_tests/" + # use test.sh for tests execution + subprocess.call(test_shell_path, shell=True) + copied_logs_path_destination = shutil.copytree(test_reports_src, copied_logs_path) + entire_results_dict = summarize_xml_files(copied_logs_path_destination, workflow_name) + return entire_results_dict + +def run_priority_tests(workflow_name, test_run_test_path, overall_logs_path_current_run, test_reports_src): + if os.path.exists(test_reports_src): + shutil.rmtree(test_reports_src) + + os.mkdir(test_reports_src) + copied_logs_path = "" + if workflow_name == "default": + os.environ['TEST_CONFIG'] = 'default' + os.environ['HIP_VISIBLE_DEVICES'] = '0' + copied_logs_path = overall_logs_path_current_run + "default_xml_results_priority_tests/" + # use run_test.py for tests execution + default_priority_test_suites = " ".join(DEFAULT_CORE_TESTS) + command = "python " + test_run_test_path + " --include " + default_priority_test_suites + " --exclude-jit-executor --exclude-distributed-tests --verbose" + subprocess.call(command, shell=True) + del os.environ['HIP_VISIBLE_DEVICES'] + elif workflow_name == "distributed": + os.environ['TEST_CONFIG'] = 'distributed' + os.environ['HIP_VISIBLE_DEVICES'] = '0,1' + copied_logs_path = overall_logs_path_current_run + "distributed_xml_results_priority_tests/" + # use run_test.py for tests execution + distributed_priority_test_suites = " ".join(DISTRIBUTED_CORE_TESTS) + command = "python " + test_run_test_path + " --include " + distributed_priority_test_suites + " --distributed-tests --verbose" + subprocess.call(command, shell=True) + del os.environ['HIP_VISIBLE_DEVICES'] + copied_logs_path_destination = shutil.copytree(test_reports_src, copied_logs_path) + priority_results_dict = summarize_xml_files(copied_logs_path_destination, workflow_name) + + return priority_results_dict + +def run_selected_tests(workflow_name, test_run_test_path, overall_logs_path_current_run, test_reports_src, selected_list): + if os.path.exists(test_reports_src): + shutil.rmtree(test_reports_src) + + os.mkdir(test_reports_src) + copied_logs_path = "" + if workflow_name == "default": + os.environ['TEST_CONFIG'] = 'default' + os.environ['HIP_VISIBLE_DEVICES'] = '0' + copied_logs_path = overall_logs_path_current_run + "default_xml_results_selected_tests/" + # use run_test.py for tests execution + default_selected_test_suites = " ".join(selected_list) + command = "python " + test_run_test_path + " --include " + default_selected_test_suites + " --exclude-jit-executor --exclude-distributed-tests --verbose" + subprocess.call(command, shell=True) + del os.environ['HIP_VISIBLE_DEVICES'] + elif workflow_name == "distributed": + os.environ['TEST_CONFIG'] = 'distributed' + os.environ['HIP_VISIBLE_DEVICES'] = '0,1' + copied_logs_path = overall_logs_path_current_run + "distributed_xml_results_selected_tests/" + # use run_test.py for tests execution + distributed_selected_test_suites = " ".join(selected_list) + command = "python " + test_run_test_path + " --include " + distributed_selected_test_suites + " --distributed-tests --verbose" + subprocess.call(command, shell=True) + del os.environ['HIP_VISIBLE_DEVICES'] + elif workflow_name == "inductor": + os.environ['TEST_CONFIG'] = 'inductor' + copied_logs_path = overall_logs_path_current_run + "inductor_xml_results_selected_tests/" + inductor_selected_test_suites = "" + non_inductor_selected_test_suites = "" + for item in selected_list: + if "inductor/" in item: + inductor_selected_test_suites += item + inductor_selected_test_suites += " " + else: + non_inductor_selected_test_suites += item + non_inductor_selected_test_suites += " " + if inductor_selected_test_suites != "": + inductor_selected_test_suites = inductor_selected_test_suites[:-1] + command = "python " + test_run_test_path + " --include " + inductor_selected_test_suites + " --verbose" + subprocess.call(command, shell=True) + if non_inductor_selected_test_suites != "": + non_inductor_selected_test_suites = non_inductor_selected_test_suites[:-1] + command = "python " + test_run_test_path + " --inductor --include " + non_inductor_selected_test_suites + " --verbose" + subprocess.call(command, shell=True) + copied_logs_path_destination = shutil.copytree(test_reports_src, copied_logs_path) + selected_results_dict = summarize_xml_files(copied_logs_path_destination, workflow_name) + + return selected_results_dict + +def run_test_and_summarize_results( + pytorch_root_dir: str, + priority_tests: bool, + test_config: List[str], + default_list: List[str], + distributed_list: List[str], + inductor_list: List[str]) -> Dict[str, Any]: + # copy current environment variables + _environ = dict(os.environ) + + # modify path + test_shell_path = pytorch_root_dir + "/.ci/pytorch/test.sh" + test_run_test_path = pytorch_root_dir + "/test/run_test.py" + repo_test_log_folder_path = pytorch_root_dir + "/.automation_logs/" + test_reports_src = pytorch_root_dir + "/test/test-reports/" + + # change directory to pytorch root + os.chdir(pytorch_root_dir) + + # all test results dict + res_all_tests_dict = {} + + # create logs folder + if not os.path.exists(repo_test_log_folder_path): + os.mkdir(repo_test_log_folder_path) + + # Set common environment variables for all scenarios + os.environ['CI'] = '1' + os.environ['PYTORCH_TEST_WITH_ROCM'] = '1' + os.environ['HSA_FORCE_FINE_GRAIN_PCIE'] = '1' + os.environ['PYTORCH_TESTING_DEVICE_ONLY_FOR'] = 'cuda' + os.environ['CONTINUE_THROUGH_ERROR'] = 'True' + + # Time stamp + current_datetime = datetime.now().strftime("%Y%m%d_%H-%M-%S") + print("Current date & time : ", current_datetime) + # performed as Job ID + str_current_datetime = str(current_datetime) + overall_logs_path_current_run = repo_test_log_folder_path + str_current_datetime + "/" + # Run entire tests for each workflow + if not priority_tests and not default_list and not distributed_list and not inductor_list: + # run entire tests for default, distributed and inductor workflows → use test.sh + if not test_config: + # default test process + res_default_all = run_entire_tests("default", test_shell_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["default"] = res_default_all + # distributed test process + res_distributed_all = run_entire_tests("distributed", test_shell_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["distributed"] = res_distributed_all + # inductor test process + res_inductor_all = run_entire_tests("inductor", test_shell_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["inductor"] = res_inductor_all + else: + workflow_list = [] + for item in test_config: + workflow_list.append(item) + if "default" in workflow_list: + res_default_all = run_entire_tests("default", test_shell_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["default"] = res_default_all + if "distributed" in workflow_list: + res_distributed_all = run_entire_tests("distributed", test_shell_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["distributed"] = res_distributed_all + if "inductor" in workflow_list: + res_inductor_all = run_entire_tests("inductor", test_shell_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["inductor"] = res_inductor_all + # Run priority test for each workflow + elif priority_tests and not default_list and not distributed_list and not inductor_list: + if not test_config: + # default test process + res_default_priority = run_priority_tests("default", test_run_test_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["default"] = res_default_priority + # distributed test process + res_distributed_priority = run_priority_tests("distributed", test_run_test_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["distributed"] = res_distributed_priority + # will not run inductor priority tests + print("Inductor priority tests cannot run since no core tests defined with inductor workflow.") + else: + workflow_list = [] + for item in test_config: + workflow_list.append(item) + if "default" in workflow_list: + res_default_priority = run_priority_tests("default", test_run_test_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["default"] = res_default_priority + if "distributed" in workflow_list: + res_distributed_priority = run_priority_tests("distributed", test_run_test_path, overall_logs_path_current_run, test_reports_src) + res_all_tests_dict["distributed"] = res_distributed_priority + if "inductor" in workflow_list: + print("Inductor priority tests cannot run since no core tests defined with inductor workflow.") + # Run specified tests for each workflow + elif (default_list or distributed_list or inductor_list) and not test_config and not priority_tests: + if default_list: + default_workflow_list = [] + for item in default_list: + default_workflow_list.append(item) + res_default_selected = run_selected_tests("default", test_run_test_path, overall_logs_path_current_run, test_reports_src, default_workflow_list) + res_all_tests_dict["default"] = res_default_selected + if distributed_list: + distributed_workflow_list = [] + for item in distributed_list: + distributed_workflow_list.append(item) + res_distributed_selected = run_selected_tests("distributed", test_run_test_path, overall_logs_path_current_run, test_reports_src, distributed_workflow_list) + res_all_tests_dict["distributed"] = res_distributed_selected + if inductor_list: + inductor_workflow_list = [] + for item in inductor_list: + inductor_workflow_list.append(item) + res_inductor_selected = run_selected_tests("inductor", test_run_test_path, overall_logs_path_current_run, test_reports_src, inductor_workflow_list) + res_all_tests_dict["inductor"] = res_inductor_selected + else: + raise Exception("Invalid test configurations!") + + # restore environment variables + os.environ.clear() + os.environ.update(_environ) + + return res_all_tests_dict + +def parse_args(): + parser = argparse.ArgumentParser(description='Run PyTorch unit tests and generate xml results summary', formatter_class=argparse.RawTextHelpFormatter) + parser.add_argument('--test_config', nargs='+', default=[], type=str, help="space-separated list of test workflows to be executed eg. 'default distributed'") + parser.add_argument('--priority_tests', action='store_true', help="run priority tests only") + parser.add_argument('--default_list', nargs='+', default=[], help="space-separated list of 'default' config test suites/files to be executed eg. 'test_weak test_dlpack'") + parser.add_argument('--distributed_list', nargs='+', default=[], help="space-separated list of 'distributed' config test suites/files to be executed eg. 'distributed/test_c10d_common distributed/test_c10d_nccl'") + parser.add_argument('--inductor_list', nargs='+', default=[], help="space-separated list of 'inductor' config test suites/files to be executed eg. 'inductor/test_torchinductor test_ops'") + parser.add_argument('--pytorch_root', default='.', type=str, help="PyTorch root directory") + parser.add_argument('--example_output', type=str, help="{'workflow_name': {\n" + " test_file_and_status(file_name='workflow_aggregate', status='STATISTICS'): {}, \n" + " test_file_and_status(file_name='test_file_name_1', status='ERROR'): {}, \n" + " test_file_and_status(file_name='test_file_name_1', status='FAILED'): {}, \n" + " test_file_and_status(file_name='test_file_name_1', status='PASSED'): {}, \n" + " test_file_and_status(file_name='test_file_name_1', status='SKIPPED'): {}, \n" + " test_file_and_status(file_name='test_file_name_1', status='STATISTICS'): {} \n" + "}}\n") + parser.add_argument('--example_usages', type=str, help="RUN ALL TESTS: python run_pytorch_unit_tests.py \n" + "RUN PRIORITY TESTS: python run_pytorch_unit_tests.py --test_config distributed --priority_test \n" + "RUN SELECTED TESTS: python run_pytorch_unit_tests.py --default_list test_weak test_dlpack --inductor_list inductor/test_torchinductor") + return parser.parse_args() + +def main(): + global args + args = parse_args() + all_tests_results = run_test_and_summarize_results(args.pytorch_root, args.priority_tests, args.test_config, args.default_list, args.distributed_list, args.inductor_list) + pprint(dict(all_tests_results)) + +if __name__ == "__main__": + main() From 6f65d22c20432d6e0177e68c38c91802fda813bb Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Sun, 12 May 2024 17:17:35 -0700 Subject: [PATCH 29/57] [HIP] Returned error string update --- .../testing/_internal/distributed/nn/api/remote_module_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torch/testing/_internal/distributed/nn/api/remote_module_test.py b/torch/testing/_internal/distributed/nn/api/remote_module_test.py index d85b0396b2afa..825e4b59b6ce9 100644 --- a/torch/testing/_internal/distributed/nn/api/remote_module_test.py +++ b/torch/testing/_internal/distributed/nn/api/remote_module_test.py @@ -616,7 +616,7 @@ def test_invalid_devices(self): if TEST_WITH_ROCM: errorString = (r"HIP error: invalid device ordinal\n" r"HIP kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\n" - r"For debugging consider passing HIP_LAUNCH_BLOCKING=1.") + r"For debugging consider passing AMD_SERIALIZE_KERNEL=3.") else: errorString = r"CUDA error: invalid device ordinal" with self.assertRaisesRegex( From 98df198a557a95b0347b4f85b810115be5746486 Mon Sep 17 00:00:00 2001 From: ramcherukuri Date: Wed, 15 May 2024 06:40:07 +0000 Subject: [PATCH 30/57] PR #1255 to rocm6.2 release --- test/test_matmul_cuda.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/test/test_matmul_cuda.py b/test/test_matmul_cuda.py index 83e0f9e80a685..95f8bb4876b71 100644 --- a/test/test_matmul_cuda.py +++ b/test/test_matmul_cuda.py @@ -103,7 +103,11 @@ def cublas_addmm(self, size: int, dtype: torch.dtype, reduced_precision: bool = # Move to CPU for comparison res_cuda = res_cuda.to("cpu") # Compare - self.assertEqual(res_cpu, res_cuda) + if dtype == torch.float16: + self.assertEqual(res_cpu, res_cuda, atol=size*2.5e-5, rtol=0.0) + else: + self.assertEqual(res_cpu, res_cuda) + torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction = orig_bf16 torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction = orig_fp16 From f18c0600986e78757e981e6ee793ef836381713b Mon Sep 17 00:00:00 2001 From: Ramana Cherukuri Date: Wed, 15 May 2024 14:03:55 -0700 Subject: [PATCH 31/57] [ROCm] skip warp update to 64 for gfx10 and gfx11 (#1417) * Warp update to 64 for NAVI3x is skipped * adding warp_size to device properties * adding warp_size to device properties --- torch/_C/__init__.pyi.in | 1 + torch/_inductor/codegen/codegen_device_driver.py | 6 +++--- torch/csrc/cuda/Module.cpp | 1 + 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/torch/_C/__init__.pyi.in b/torch/_C/__init__.pyi.in index f37c3a326fda5..485f37b47b744 100644 --- a/torch/_C/__init__.pyi.in +++ b/torch/_C/__init__.pyi.in @@ -1915,6 +1915,7 @@ class _CudaDeviceProperties: is_multi_gpu_board: _int max_threads_per_multi_processor: _int gcnArchName: str + warp_size: _int # Functions related to SDPA class _SDPAParams: diff --git a/torch/_inductor/codegen/codegen_device_driver.py b/torch/_inductor/codegen/codegen_device_driver.py index 73fcb7afd5237..96e6114ee0516 100644 --- a/torch/_inductor/codegen/codegen_device_driver.py +++ b/torch/_inductor/codegen/codegen_device_driver.py @@ -73,9 +73,9 @@ def cuda_kernel_driver() -> str: } """ if torch.version.hip is not None: - # Replace the warp size from 32 (cuLaunchKernel) to 64 (hipModuleLaunchKernel) - # The warp size on NV GPU is 32, while the wavefront size on AMD GPU is 64 - source_codes = source_codes.replace("32*numWarps", "64*numWarps") + # Adjusting the warp size to GPU supported wavefront size on AMD GPU + prop = torch.cuda.get_device_properties(torch.cuda.current_device()) + source_codes = source_codes.replace("32*numWarps", str(prop.warp_size)+"*numWarps") return source_codes diff --git a/torch/csrc/cuda/Module.cpp b/torch/csrc/cuda/Module.cpp index 4197c2aa5e81d..fc31bdd704449 100644 --- a/torch/csrc/cuda/Module.cpp +++ b/torch/csrc/cuda/Module.cpp @@ -922,6 +922,7 @@ static void registerCudaDeviceProperties(PyObject* module) { .def_readonly( "max_threads_per_multi_processor", &cudaDeviceProp::maxThreadsPerMultiProcessor) + .def_readonly("warp_size", &cudaDeviceProp::warpSize) #if !USE_ROCM // NVIDA only property .def_readonly( From cb0e9ad04d09b4f28f984f47ce25b56880770bdb Mon Sep 17 00:00:00 2001 From: Andres Lugo <108368282+alugorey@users.noreply.github.com> Date: Thu, 16 May 2024 15:23:39 -0500 Subject: [PATCH 32/57] Reformat test_float8_basics for current rocm support (#1415) --- test/test_matmul_cuda.py | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/test/test_matmul_cuda.py b/test/test_matmul_cuda.py index 95f8bb4876b71..3e9481daaf1a7 100644 --- a/test/test_matmul_cuda.py +++ b/test/test_matmul_cuda.py @@ -378,21 +378,24 @@ def _test_tautological_mm(self, device: str = "cuda", @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) def test_float8_basics(self, device) -> None: self._test_tautological_mm(device, e4m3_type, e4m3_type, size=16) - # hipblaslt does not yet support mixed e4m3_type input if torch.version.hip is None: - self._test_tautological_mm(device, e4m3_type, e5m2_type, size=32) - self._test_tautological_mm(device, e5m2_type, e4m3_type, size=48) - # According to https://docs.nvidia.com/cuda/cublas/#id99 8F_E5M2 MM is unsupported - with self.assertRaises(RuntimeError): + # According to https://docs.nvidia.com/cuda/cublas/#id99 8F_E5M2 MM is unsupported + with self.assertRaises(RuntimeError): + self._test_tautological_mm(device, e5m2_type, e5m2_type) + else: self._test_tautological_mm(device, e5m2_type, e5m2_type) + + self._test_tautological_mm(device, e4m3_type, e5m2_type, size=32) + self._test_tautological_mm(device, e5m2_type, e4m3_type, size=48) + self._test_tautological_mm(device, size=64, out_dtype=torch.float16) self._test_tautological_mm(device, size=96, out_dtype=torch.float32) - # hipblaslt does not yet support bfloat16 output + self._test_tautological_mm(device, size=80, out_dtype=torch.bfloat16) + if torch.version.hip is None: - self._test_tautological_mm(device, size=80, out_dtype=torch.bfloat16) - with self.assertRaises(RuntimeError): - self._test_tautological_mm(device, out_dtype=e5m2_type) + with self.assertRaises(RuntimeError): + self._test_tautological_mm(device, out_dtype=e5m2_type) @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) def test_float8_scale(self, device) -> None: From b4abc4b9795e3b39246c3caca57a4a92bab53ad5 Mon Sep 17 00:00:00 2001 From: Andres Lugo <108368282+alugorey@users.noreply.github.com> Date: Thu, 16 May 2024 15:29:02 -0500 Subject: [PATCH 33/57] Enable e5m2 x e4m3 test in test_float8_scale (#1419) --- test/test_matmul_cuda.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/test/test_matmul_cuda.py b/test/test_matmul_cuda.py index 3e9481daaf1a7..51bc95e31c457 100644 --- a/test/test_matmul_cuda.py +++ b/test/test_matmul_cuda.py @@ -401,8 +401,7 @@ def test_float8_basics(self, device) -> None: def test_float8_scale(self, device) -> None: size = (16, 16) x = torch.full(size, .5, device=device, dtype=e4m3_type) - # hipblaslt does not yet support mixed e4m3_type input - y_type = e4m3_type if torch.version.hip else e5m2_type + y_type = e5m2_type y = torch.full(size, .5, device=device, dtype=y_type).t() scale_a = torch.tensor(1.5, device=device) scale_b = torch.tensor(0.66, device=device) From c716c2eae81a584f77291dad666684a15ae91221 Mon Sep 17 00:00:00 2001 From: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> Date: Wed, 24 Apr 2024 15:50:12 -0500 Subject: [PATCH 34/57] [release/2.1] Skip certificate check for CentOS7 since certificate expired (#1399) * Skip certificate check only for CentOS7 since certificate expired * Naming --- .ci/docker/common/install_conda.sh | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.ci/docker/common/install_conda.sh b/.ci/docker/common/install_conda.sh index 2f4e443d10e89..f0a7a56daffd1 100755 --- a/.ci/docker/common/install_conda.sh +++ b/.ci/docker/common/install_conda.sh @@ -38,7 +38,10 @@ fi source "$(dirname "${BASH_SOURCE[0]}")/common_utils.sh" pushd /tmp - wget -q "${BASE_URL}/${CONDA_FILE}" + if [ -n $CENTOS_VERSION ] && [[ $CENTOS_VERSION == 7.* ]]; then + NO_CHECK_CERTIFICATE_FLAG="--no-check-certificate" + fi + wget -q "${BASE_URL}/${CONDA_FILE}" ${NO_CHECK_CERTIFICATE_FLAG} # NB: Manually invoke bash per https://github.com/conda/conda/issues/10431 as_jenkins bash "${CONDA_FILE}" -b -f -p "/opt/conda" popd From 09b800a795f3b7a24fa327addc28bb98fdb739ee Mon Sep 17 00:00:00 2001 From: Andres Lugo <108368282+alugorey@users.noreply.github.com> Date: Tue, 21 May 2024 13:41:39 -0500 Subject: [PATCH 35/57] skip vmapvjpvjp_linalg_householder_product_cuda_float32 (#1420) --- test/functorch/test_ops.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/functorch/test_ops.py b/test/functorch/test_ops.py index 44ff51a7d680d..4fcc14b6708c2 100644 --- a/test/functorch/test_ops.py +++ b/test/functorch/test_ops.py @@ -934,7 +934,7 @@ def fn(inp, *args, **kwargs): # (3) encountering this error in PyTorch internals. xfail("index_reduce", "prod"), decorate( - "linalg.householder_product", decorator=runOnRocm + "linalg.householder_product", decorator=skipIfRocm ), # works on ROCm xfail( "nanquantile", device_type="cpu" From a0872c00b839ea42966ce5b83db100e9059c9077 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 21 May 2024 16:09:54 -0700 Subject: [PATCH 36/57] Include the ROCm version in triton version --- .github/scripts/build_triton_wheel.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.github/scripts/build_triton_wheel.py b/.github/scripts/build_triton_wheel.py index cd82045492272..fdc8d1405c654 100644 --- a/.github/scripts/build_triton_wheel.py +++ b/.github/scripts/build_triton_wheel.py @@ -88,7 +88,8 @@ def build_triton( if not release: # Nightly binaries include the triton commit hash, i.e. 2.1.0+e6216047b8 # while release build should only include the version, i.e. 2.1.0 - version_suffix = f"+{commit_hash[:10]}" + rocm_version = get_rocm_version() + version_suffix = f"+rocm{rocm_version}_{commit_hash[:10]}" version += version_suffix with TemporaryDirectory() as tmpdir: From 700ee13dc45dd4284dae76275c53394fe389eb1f Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 21 May 2024 18:58:20 -0700 Subject: [PATCH 37/57] Change Torch extra install requirement - PYTORCH_EXTRA_INSTALL_REQUIREMENTS is set in builder repo - Remove the PYTORCH_EXTRA_INSTALL_REQUIREMENTS step from this file --- .circleci/scripts/binary_populate_env.sh | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/.circleci/scripts/binary_populate_env.sh b/.circleci/scripts/binary_populate_env.sh index a45a2c9754ba5..61328e5338d41 100755 --- a/.circleci/scripts/binary_populate_env.sh +++ b/.circleci/scripts/binary_populate_env.sh @@ -86,20 +86,6 @@ if [[ "$PACKAGE_TYPE" =~ .*wheel.* && -n "${PYTORCH_EXTRA_INSTALL_REQUIREMENTS: export PYTORCH_EXTRA_INSTALL_REQUIREMENTS="${PYTORCH_EXTRA_INSTALL_REQUIREMENTS} | ${TRITON_REQUIREMENT}" fi -# Set triton via PYTORCH_EXTRA_INSTALL_REQUIREMENTS for triton rocm package -if [[ "$PACKAGE_TYPE" =~ .*wheel.* && -n "$PYTORCH_BUILD_VERSION" && "$PYTORCH_BUILD_VERSION" =~ .*rocm.* && $(uname) == "Linux" && "$DESIRED_PYTHON" != "3.12" ]]; then - TRITON_REQUIREMENT="pytorch-triton-rocm==${TRITON_VERSION}" - if [[ -n "$PYTORCH_BUILD_VERSION" && "$PYTORCH_BUILD_VERSION" =~ .*dev.* ]]; then - TRITON_SHORTHASH=$(cut -c1-10 $PYTORCH_ROOT/.ci/docker/ci_commit_pins/triton-rocm.txt) - TRITON_REQUIREMENT="pytorch-triton-rocm==${TRITON_VERSION}+${TRITON_SHORTHASH}" - fi - if [[ -z "${PYTORCH_EXTRA_INSTALL_REQUIREMENTS:-}" ]]; then - export PYTORCH_EXTRA_INSTALL_REQUIREMENTS="${TRITON_REQUIREMENT}" - else - export PYTORCH_EXTRA_INSTALL_REQUIREMENTS="${PYTORCH_EXTRA_INSTALL_REQUIREMENTS} | ${TRITON_REQUIREMENT}" - fi -fi - JAVA_HOME= BUILD_JNI=OFF if [[ "$PACKAGE_TYPE" == libtorch ]]; then From 8f958240b3fe1499c79d037f90d7a2cb6c9f12e0 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Wed, 22 May 2024 12:48:40 -0700 Subject: [PATCH 38/57] Remove the installation of rocm-llvm-dev package - Causing regression - SWDEV-463083 --- .ci/docker/common/install_rocm.sh | 4 ---- 1 file changed, 4 deletions(-) diff --git a/.ci/docker/common/install_rocm.sh b/.ci/docker/common/install_rocm.sh index 0973415c06fa9..a52e4a830547d 100644 --- a/.ci/docker/common/install_rocm.sh +++ b/.ci/docker/common/install_rocm.sh @@ -42,10 +42,6 @@ install_ubuntu() { roctracer-dev \ amd-smi-lib - if [[ $(ver $ROCM_VERSION) -ge $(ver 6.1) ]]; then - DEBIAN_FRONTEND=noninteractive apt-get install -y --allow-unauthenticated rocm-llvm-dev - fi - # precompiled miopen kernels added in ROCm 3.5, renamed in ROCm 5.5 # search for all unversioned packages # if search fails it will abort this script; use true to avoid case where search fails From 5f9b3f418f40a65290815c7e5e67b728273d6c1a Mon Sep 17 00:00:00 2001 From: Xinya Zhang Date: Sun, 2 Jun 2024 11:55:23 -0500 Subject: [PATCH 39/57] Fix SWDEV-459623 (#1428) * Fix SWDEV-459623. The Rank of logsumexp Tensor must be 3. This tensor was considered for internal use only but apparently exposed to UTs. * Fix for mGPU. The stream should be selected after picking the current device according to input tensor. --- .../transformers/hip/flash_attn/flash_api.hip | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/aten/src/ATen/native/transformers/hip/flash_attn/flash_api.hip b/aten/src/ATen/native/transformers/hip/flash_attn/flash_api.hip index 7af480a7ae495..6dcc099018f3b 100644 --- a/aten/src/ATen/native/transformers/hip/flash_attn/flash_api.hip +++ b/aten/src/ATen/native/transformers/hip/flash_attn/flash_api.hip @@ -95,6 +95,10 @@ mha_fwd(const at::Tensor &q, // batch_size x seqlen_q x num_heads x head int window_size_right, const bool return_softmax, c10::optional gen_) { + // Otherwise the kernel will be launched from cuda:0 device + // Cast to char to avoid compiler warning about narrowing + at::hip::HIPGuardMasqueradingAsCUDA device_guard{(char)q.get_device()}; + auto stream = at::hip::getCurrentHIPStreamMasqueradingAsCUDA().stream(); check_gpu_arch(stream); @@ -154,10 +158,6 @@ mha_fwd(const at::Tensor &q, // batch_size x seqlen_q x num_heads x head const int seqlen_q_rounded = round_multiple(seqlen_q, 128); const int seqlen_k_rounded = round_multiple(seqlen_k, 128); - // Otherwise the kernel will be launched from cuda:0 device - // Cast to char to avoid compiler warning about narrowing - at::hip::HIPGuardMasqueradingAsCUDA device_guard{(char)q.get_device()}; - // We want to checkpoint and save the RNG state for backward if dropout // We get the default generator and return the seed and offset which will // be used in the backward function @@ -207,14 +207,14 @@ mha_fwd(const at::Tensor &q, // batch_size x seqlen_q x num_heads x head at::Tensor v_t = v_padded.permute({0,2,1,3}); at::Tensor output_t = out.permute({0,2,1,3}); - at::Tensor M = at::empty({batch_size * num_heads, seqlen_q}, at::dtype(at::kFloat).device(q.device())); // aka softmax_lse + auto opts = q.options(); + at::Tensor M = at::empty({batch_size * num_heads, seqlen_q}, opts.dtype(at::kFloat)); // aka softmax_lse at::Tensor softmax_fa_t; if (return_softmax) { - softmax_fa_t = at::empty({batch_size, num_heads, seqlen_q, seqlen_k}, - at::dtype(q.dtype()).device(q.device())); + softmax_fa_t = at::empty({batch_size, num_heads, seqlen_q, seqlen_k}, opts); } else { - softmax_fa_t = at::empty({ 0, 0, 0, 0 }, at::dtype(q.dtype()).device(q.device())); + softmax_fa_t = at::empty({ 0, 0, 0, 0 }, opts); } hipError_t err; // TODO: Error handling @@ -236,7 +236,7 @@ mha_fwd(const at::Tensor &q, // batch_size x seqlen_q x num_heads x head is_causal, stream); - return {out, q_padded, k_padded, v_padded, M, seed_t, offset_t, softmax_fa_t}; + return {out, q_padded, k_padded, v_padded, M.view({batch_size, num_heads, seqlen_q}), seed_t, offset_t, softmax_fa_t}; } std::tuple @@ -411,8 +411,8 @@ mha_bwd(const at::Tensor &dout, // batch_size x seqlen_q x num_heads, x head_si at::Tensor dv_t = dv.permute({0,2,1,3}); at::Tensor dout_t = dout.permute({0,2,1,3}); - at::Tensor softmax_lse_cont = softmax_lse.contiguous(); - at::Tensor delta = at::empty_like(softmax_lse).contiguous(); + at::Tensor softmax_lse_cont = softmax_lse.view({batch_size * num_heads, seqlen_q}).contiguous(); + at::Tensor delta = at::empty_like(softmax_lse_cont).contiguous(); int d_head = head_size_og; hipError_t err; // TODO: Error handling From 90df4872a421743360c99a4f910ba7792cf45fd0 Mon Sep 17 00:00:00 2001 From: Andres Lugo <108368282+alugorey@users.noreply.github.com> Date: Sun, 2 Jun 2024 11:57:36 -0500 Subject: [PATCH 40/57] Enable fp8 inductor unit tests (#1421) * Add formal FP8 check in common_cuda.py * Enable inductor/test_valid_cast * Support for test_eager_fallback * allow fnuz types on amax test * Finalize passing tests vs failing * Fix fnuz constants in _to_fp8_saturated --- test/inductor/test_fp8.py | 73 ++++++++++++++++---------- test/test_matmul_cuda.py | 35 ++++++------ torch/_inductor/codegen/triton.py | 2 +- torch/testing/_internal/common_cuda.py | 11 ++++ 4 files changed, 71 insertions(+), 50 deletions(-) diff --git a/test/inductor/test_fp8.py b/test/inductor/test_fp8.py index 5d910a74c9837..5427def24b4aa 100644 --- a/test/inductor/test_fp8.py +++ b/test/inductor/test_fp8.py @@ -7,7 +7,7 @@ from torch import Tensor from torch._inductor import utils from torch._inductor.test_case import run_tests, TestCase -from torch.testing._internal.common_cuda import SM90OrLater +from torch.testing._internal.common_cuda import PLATFORM_SUPPORTS_FP8, SM90OrLater from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, @@ -18,9 +18,13 @@ torch.set_float32_matmul_precision("high") +f8_msg = "FP8 is only supported on H100+ and sm_89 and MI300+ devices" + # define the e4m3/e5m2 constants -E4M3_MAX_POS = 448.0 -E5M2_MAX_POS = 57344.0 +E4M3_MAX_POS = torch.finfo(torch.float8_e4m3fn).max +E5M2_MAX_POS = torch.finfo(torch.float8_e5m2).max +E4M3FNUZ_MAX_POS = torch.finfo(torch.float8_e4m3fnuz).max +E5M2FNUZ_MAX_POS = torch.finfo(torch.float8_e5m2fnuz).max def _to_fp8_saturated(x: Tensor, float8_dtype: torch.dtype) -> Tensor: @@ -32,26 +36,33 @@ def _to_fp8_saturated(x: Tensor, float8_dtype: torch.dtype) -> Tensor: # scaling. if float8_dtype == torch.float8_e4m3fn: x = x.clamp(min=-1 * E4M3_MAX_POS, max=E4M3_MAX_POS) - else: + elif float8_dtype == torch.float8_e5m2: x = x.clamp(min=-1 * E5M2_MAX_POS, max=E5M2_MAX_POS) + elif float8_dtype == torch.float8_e4m3fnuz: + x = x.clamp(min=-1 * E4M3FNUZ_MAX_POS, max=E4M3FNUZ_MAX_POS) + elif float8_dtype == torch.float8_e5m2fnuz: + x = x.clamp(min=-1 * E5M2FNUZ_MAX_POS, max=E5M2FNUZ_MAX_POS) + else: + raise TypeError(f"Unsupported float8_dtype: {float8_dtype}") return x.to(float8_dtype) @instantiate_parametrized_tests class TestFP8Types(TestCase): - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") - @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @parametrize("dtype", (torch.float16, torch.bfloat16)) def test_eager_fallback(self, dtype: torch.dtype): weight_shape = (32, 16) + e4m3_type = torch.float8_e4m3fn if torch.version.hip is None else torch.float8_e4m3fnuz + def fp8_matmul_unwrapped(x): a_scale = torch.Tensor([1.0]).to(device="cuda") b_scale = torch.Tensor([1.0]).to(device="cuda") output_scale = None input_bias = torch.rand(32, device="cuda", dtype=dtype) weight = torch.rand(*weight_shape, device="cuda", dtype=dtype).T.to( - torch.float8_e4m3fn + e4m3_type ) a_inverse_scale = 1 / a_scale b_inverse_scale = 1 / b_scale @@ -71,21 +82,27 @@ def fp8_matmul_unwrapped(x): ) x_shape = (16, 16) - x = torch.rand(*x_shape, device="cuda", dtype=dtype).to(torch.float8_e4m3fn) + x = torch.rand(*x_shape, device="cuda", dtype=dtype).to(e4m3_type) y_fp8 = compiled_fp8_matmul(x) x_shape = (15, 16) - x = torch.rand(*x_shape, device="cuda", dtype=dtype).to(torch.float8_e4m3fn) + x = torch.rand(*x_shape, device="cuda", dtype=dtype).to(e4m3_type) y_fp8 = compiled_fp8_matmul(x) - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") - @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") + + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @parametrize("dtype", (torch.float16, torch.bfloat16, torch.float)) @parametrize("shape", ("15,3,13", "4,2048,4096")) - def test_valid_cast(self, dtype: torch.dtype, shape: str): + @parametrize("dst_types", [(torch.float8_e4m3fn, torch.float8_e5m2)] if torch.version.hip is None else [(torch.float8_e4m3fnuz, torch.float8_e5m2fnuz)]) + def test_valid_cast(self, dtype: torch.dtype, shape: str, dst_types: tuple): + + e4m3, e5m2 = dst_types + print("e4m3: ", type(e4m3)) + print("e5m2: ", type(e5m2)) + def fp8_cast(x): - y0 = x.to(dtype=torch.float8_e4m3fn).to(dtype) - y1 = x.to(dtype=torch.float8_e5m2).to(dtype) + y0 = x.to(dtype=e4m3).to(dtype) + y1 = x.to(dtype=e5m2).to(dtype) return y0, y1 compiled_fp8_cast = torch.compile(fp8_cast, backend="inductor", dynamic=True) @@ -96,9 +113,9 @@ def fp8_cast(x): torch.testing.assert_close(y0_fp8, x, rtol=5e-1, atol=5e-1) torch.testing.assert_close(y1_fp8, x, rtol=5e-1, atol=5e-1) + - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") - @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_bad_cast(self): def fp8_cast(x, dtype): return x.to(dtype=dtype) @@ -121,10 +138,10 @@ def fp8_cast(x, dtype): x = torch.rand(*x_shape, device="cuda").to(dtype=torch.float8_e5m2) y = compiled_fp8_cast(x, torch.float8_e4m3fn) - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") - @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") + + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @parametrize("src_dtype", (torch.float16, torch.bfloat16, torch.float)) - @parametrize("dst_dtype", (torch.float8_e4m3fn, torch.float8_e5m2)) + @parametrize("dst_dtype", (torch.float8_e4m3fn, torch.float8_e5m2) if torch.version.hip is None else (torch.float8_e4m3fnuz, torch.float8_e5m2fnuz)) @parametrize("shape", ("16,16,16", "4,2048,4096")) def test_to_fp8_saturated( self, src_dtype: torch.dtype, dst_dtype: torch.dtype, shape: str @@ -142,9 +159,9 @@ def fp8_saturated(x, dtype): torch.testing.assert_close(y_compiled.half(), y.half(), rtol=5e-1, atol=5e-1) - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") + @unittest.skipIf(TEST_WITH_ROCM, "ROCm fails with accuracy issue") @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") - @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2)) + @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2) if torch.version.hip is None else (torch.float8_e4m3fnuz, torch.float8_e5m2fnuz)) @parametrize("shape", ("1,1,15", "1,10,15", "1,10,512", "1,10,4096", "4,2048,4096")) def test_amax_fp8_quant(self, float8_dtype: torch.dtype, shape: str): shape = [int(dim) for dim in shape.split(",")] @@ -167,9 +184,8 @@ def amax_fp8(x: Tensor, scale: Tensor): torch.testing.assert_close(y_compiled.half(), y.half(), rtol=1e-2, atol=1e-2) - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") - @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") - @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2)) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) + @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2) if torch.version.hip is None else (torch.float8_e4m3fnuz, torch.float8_e5m2fnuz)) @parametrize("shape", ("1,1,15", "1,10,15", "1,10,512", "1,10,4096", "4,2048,4096")) def test_amax_along_with_fp8_quant(self, float8_dtype: torch.dtype, shape: str): shape = [int(dim) for dim in shape.split(",")] @@ -197,9 +213,9 @@ def amax_fp8(x: Tensor, scale: Tensor, amax_buffer: Tensor): amax_buffer_compiled, amax_buffer, rtol=1e-2, atol=1e-2 ) - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") + @unittest.skipIf(TEST_WITH_ROCM, "ROCm fails with accuracy issue") @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") - @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2)) + @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2) if torch.version.hip is None else (torch.float8_e4m3fnuz, torch.float8_e5m2fnuz)) @parametrize("amax_keep_dim", (True, False)) @parametrize("shape", ("1,1,15", "1,10,15", "1,10,512", "1,10,4096", "4,2048,4096")) def test_layernorm_fp8_quant( @@ -239,9 +255,8 @@ def ln_fp8(x: Tensor, scale: Tensor, amax_buffer: Tensor): amax_buffer_compiled, amax_buffer, rtol=1e-2, atol=1e-2 ) - @unittest.skipIf(TEST_WITH_ROCM, "FP8 is not supported on ROCM") - @unittest.skipIf(not SM90OrLater, "FP8 is only supported on H100+") - @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2)) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) + @parametrize("float8_dtype", (torch.float8_e4m3fn, torch.float8_e5m2) if torch.version.hip is None else (torch.float8_e4m3fnuz, torch.float8_e5m2fnuz)) @parametrize("shape", ("4,2048,4096",)) @parametrize("keepdim", (False, True)) def test_layernorm_fp8_quant_benchmark( diff --git a/test/test_matmul_cuda.py b/test/test_matmul_cuda.py index 51bc95e31c457..a5eb85d0913b9 100644 --- a/test/test_matmul_cuda.py +++ b/test/test_matmul_cuda.py @@ -13,7 +13,11 @@ ) from torch.testing import make_tensor -from torch.testing._internal.common_cuda import SM53OrLater, _get_torch_cuda_version +from torch.testing._internal.common_cuda import ( + SM53OrLater, + _get_torch_cuda_version, + PLATFORM_SUPPORTS_FP8 +) from torch.testing._internal.common_device_type import ( dtypes, instantiate_device_type_tests, @@ -225,15 +229,6 @@ def _expand_to_batch(t: torch.Tensor): # avoid division by zero when calculating scale EPS = 1e-12 -def scaled_mm_supported_device(): - if torch.cuda.is_available(): - if torch.version.hip: - return 'gfx94' in torch.cuda.get_device_properties(0).gcnArchName - else: - return torch.cuda.get_device_capability() >= (9, 0) or torch.cuda.get_device_capability() == (8, 9) - return False - - def amax_to_scale( amax: torch.Tensor, float8_dtype: torch.dtype, orig_dtype: torch.dtype ): @@ -359,7 +354,7 @@ class TestFP8MatmulCuda(TestCase): - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def _test_tautological_mm(self, device: str = "cuda", x_dtype: torch.dtype = e4m3_type, y_dtype: torch.dtype = e4m3_type, @@ -375,7 +370,7 @@ def _test_tautological_mm(self, device: str = "cuda", self.assertEqual(out_dtype, out_fp8.dtype) self.assertEqual(out_fp32, out_fp8.to(torch.float)) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_float8_basics(self, device) -> None: self._test_tautological_mm(device, e4m3_type, e4m3_type, size=16) if torch.version.hip is None: @@ -397,7 +392,7 @@ def test_float8_basics(self, device) -> None: with self.assertRaises(RuntimeError): self._test_tautological_mm(device, out_dtype=e5m2_type) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_float8_scale(self, device) -> None: size = (16, 16) x = torch.full(size, .5, device=device, dtype=e4m3_type) @@ -410,7 +405,7 @@ def test_float8_scale(self, device) -> None: out_fp8_s = torch._scaled_mm(x, y, scale_a=scale_a, scale_b=scale_b) self.assertEqual(out_fp8, out_fp8_s) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @parametrize("base_dtype", [torch.float16, torch.bfloat16, torch.float32]) def test_scaled_mm_vs_emulated(self, base_dtype): torch.manual_seed(42) @@ -459,7 +454,7 @@ def test_scaled_mm_vs_emulated(self, base_dtype): torch.testing.assert_close(out_scaled_mm, out_emulated, atol=atol, rtol=rtol) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_float8_bias(self, device) -> None: (k, l, m) = (16, 48, 32) x = torch.ones((k, l), device=device).to(e4m3_type) @@ -475,7 +470,7 @@ def test_float8_bias(self, device) -> None: difference = torch.abs(out_fp32 - outb_fp32) self.assertEqual(difference, torch.tensor(4.0, device=device).expand_as(out_fp32)) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) @parametrize("bias", [True, False]) def test_non_divisible_leading_dim(self, device, bias: bool) -> None: x = torch.rand((17, 16), device=device).to(e4m3_type) @@ -487,7 +482,7 @@ def test_non_divisible_leading_dim(self, device, bias: bool) -> None: input_bias = torch.rand((16,), device=device).to(torch.half) _ = torch._scaled_mm(x, y, scale_a, scale_b, bias=input_bias) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_float8_bias_relu_edgecase(self, device) -> None: (k, l, m) = (16, 48, 32) x = torch.full((k, l), 0.0, device=device).to(e4m3_type) @@ -499,7 +494,7 @@ def test_float8_bias_relu_edgecase(self, device) -> None: outb_fp32 = outb_fp8.to(torch.float32) self.assertEqual(outb_fp32, torch.tensor(-3.0, device=device).expand_as(outb_fp32)) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_float32_output_errors_with_bias(self, device) -> None: (k, l, m) = (16, 48, 32) x = torch.rand((k, l), device=device).to(e4m3_type) @@ -513,7 +508,7 @@ def test_float32_output_errors_with_bias(self, device) -> None: lambda: torch._scaled_mm(x, y, scale_a, scale_b, bias=bias, out_dtype=torch.float32), ) - @unittest.skipIf(scaled_mm_supported_device(), + @unittest.skipIf(PLATFORM_SUPPORTS_FP8, "This test is only for devices with compute capability < 8.9") def test_error_message_fp8_pre_sm89(self, device) -> None: (k, l, m) = (16, 48, 32) @@ -527,7 +522,7 @@ def test_error_message_fp8_pre_sm89(self, device) -> None: lambda: torch._scaled_mm(x, y, scale_a, scale_b, out_dtype=torch.float32), ) - @unittest.skipIf(not scaled_mm_supported_device(), f8_msg) + @unittest.skipIf(not PLATFORM_SUPPORTS_FP8, f8_msg) def test_float8_scale_fast_accum(self, device) -> None: size = (16, 16) x = torch.full(size, .5, device=device, dtype=e4m3_type) diff --git a/torch/_inductor/codegen/triton.py b/torch/_inductor/codegen/triton.py index 381bbebf3acc5..365d2a391c065 100644 --- a/torch/_inductor/codegen/triton.py +++ b/torch/_inductor/codegen/triton.py @@ -536,7 +536,7 @@ def triton_compute_type(dtype): triton_type_name = "float8e5" elif triton_type_name == "float8_e4m3fnuz": triton_type_name = "float8e4b8" - elif triton_type_name == "float8_e5m2": + elif triton_type_name == "float8_e5m2fnuz": triton_type_name = "float8e5b16" return f"tl.{triton_type_name}" diff --git a/torch/testing/_internal/common_cuda.py b/torch/testing/_internal/common_cuda.py index 189be09d8ba96..beb36ef6c41e3 100644 --- a/torch/testing/_internal/common_cuda.py +++ b/torch/testing/_internal/common_cuda.py @@ -69,6 +69,17 @@ def evaluate_platform_supports_efficient_attention(): PLATFORM_SUPPORTS_BF16: bool = LazyVal(lambda: TEST_CUDA and SM80OrLater) +def evaluate_platform_supports_fp8(): + if torch.cuda.is_available(): + if torch.version.hip: + return 'gfx94' in torch.cuda.get_device_properties(0).gcnArchName + else: + return SM90OrLater or torch.cuda.get_device_capability() == (8, 9) + return False + +PLATFORM_SUPPORTS_FP8: bool = LazyVal(lambda: evaluate_platform_supports_fp8()) + + if TEST_NUMBA: try: import numba.cuda From 4380b153820ff14d0d28346b46b7e15a06d78e2a Mon Sep 17 00:00:00 2001 From: Dmitry Nikolaev <139769634+dnikolaev-amd@users.noreply.github.com> Date: Tue, 4 Jun 2024 19:40:29 +0200 Subject: [PATCH 41/57] Enable NHWC batchnorm for miopen (#1400) * Enable batchnorm NHWC for MIOpen * cleanup * test to compare NHWC MIOpen batchnorm with CPU * fix 'use_miopen' condition for nhwc miopen * fix includes * use native nhwc batchnorm to verify miopen * remove extra spaces * remove empty lines * set PYTORCH_MIOPEN_SUGGEST_NHWC=1 for all test_nn.py test --- aten/src/ATen/native/Normalization.cpp | 11 +++- .../ATen/native/miopen/BatchNorm_miopen.cpp | 13 ++-- test/test_nn.py | 61 ++++++++++++++++++- 3 files changed, 77 insertions(+), 8 deletions(-) diff --git a/aten/src/ATen/native/Normalization.cpp b/aten/src/ATen/native/Normalization.cpp index e9e7c001837a4..b3363cbcae00f 100644 --- a/aten/src/ATen/native/Normalization.cpp +++ b/aten/src/ATen/native/Normalization.cpp @@ -510,6 +510,11 @@ BatchNormBackend _select_batch_norm_backend( return BatchNormBackend::Cudnn; } + // TODO: Remove PYTORCH_MIOPEN_SUGGEST_NHWC once ROCm officially supports NHWC in MIOpen + // See #64427 + // non static variable is used to be able to change environment variable in runtime for testing + bool PYTORCH_MIOPEN_SUGGEST_NHWC = c10::utils::check_env("PYTORCH_MIOPEN_SUGGEST_NHWC").value_or(false); + if ( input.is_cuda() && input.dim() <= MIOPEN_DIM_MAX @@ -522,8 +527,8 @@ BatchNormBackend _select_batch_norm_backend( && (input.dim() >= 3) && detail::getCUDAHooks().compiledWithMIOpen() && cudnn_enabled - && input.suggest_memory_format() != MemoryFormat::ChannelsLast - && input.suggest_memory_format() != MemoryFormat::ChannelsLast3d + && (input.suggest_memory_format() == MemoryFormat::Contiguous + || (input.suggest_memory_format() == MemoryFormat::ChannelsLast && PYTORCH_MIOPEN_SUGGEST_NHWC)) ) { return BatchNormBackend::Miopen; } @@ -603,7 +608,7 @@ std::tuple _batch_norm_impl_index( if (backend == BatchNormBackend::Miopen) { return std::tuple_cat( at::miopen_batch_norm( - input.contiguous(), weight.contiguous(), bias.contiguous(), + input.contiguous(input.suggest_memory_format()), weight.contiguous(), bias.contiguous(), running_mean.defined() ? running_mean.contiguous() : running_mean, running_var.defined() ? running_var.contiguous() : running_var, training, momentum, eps), diff --git a/aten/src/ATen/native/miopen/BatchNorm_miopen.cpp b/aten/src/ATen/native/miopen/BatchNorm_miopen.cpp index 9f9ef77f90a34..a1928e2268eb2 100644 --- a/aten/src/ATen/native/miopen/BatchNorm_miopen.cpp +++ b/aten/src/ATen/native/miopen/BatchNorm_miopen.cpp @@ -100,7 +100,7 @@ std::tuple miopen_batch_norm( mode = miopenBNSpatial; } - auto output_t = at::empty(input->sizes(), input->options()); + auto output_t = at::empty(input->sizes(), input->options(), input->suggest_memory_format()); TensorArg output{ output_t, "output", 0 }; auto handle = getMiopenHandle(); @@ -177,8 +177,10 @@ std::tuple miopen_batch_norm_backward( const Tensor& save_var_t = c10::value_or_else(save_var_t_opt, [] { return Tensor(); }); + auto grad_output_contig = + grad_output_t.contiguous(input_t.suggest_memory_format()); TensorArg input{ input_t, "input", 1 }, - grad_output{ grad_output_t, "grad_output", 2 }, + grad_output{ grad_output_contig, "grad_output", 2 }, weight{ weight_t, "weight", 3 }, save_mean{ save_mean_t, "save_mean", 4 }, save_var{ save_var_t, "save_var", 5 }; @@ -193,7 +195,9 @@ std::tuple miopen_batch_norm_backward( } checkAllSameType(c, {input, grad_output}); checkAllSameType(c, {weight, save_mean, save_var}); - checkAllContiguous(c, {input, grad_output, save_mean, save_var}); + checkAllContiguous(c, {save_mean, save_var}); + TORCH_CHECK(input->is_contiguous(input->suggest_memory_format())); + TORCH_CHECK(grad_output->is_contiguous(input->suggest_memory_format())); checkDimRange(c, input, 2, 6 /* exclusive */); checkSameSize(c, input, grad_output); auto num_features = input->size(1); @@ -208,7 +212,8 @@ std::tuple miopen_batch_norm_backward( mode = miopenBNSpatial; } - auto grad_input_t = at::empty(input->sizes(), input->options()); + auto grad_input_t = at::empty( + input->sizes(), input->options(), input->suggest_memory_format()); auto grad_weight_t = at::empty(weight->sizes(), weight->options()); auto grad_bias_t = at::empty(weight->sizes(), weight->options()); diff --git a/test/test_nn.py b/test/test_nn.py index 2553db01ee6bb..c22f8f7d71844 100644 --- a/test/test_nn.py +++ b/test/test_nn.py @@ -9,6 +9,7 @@ import warnings import pickle import re +import os from copy import deepcopy from itertools import product from functools import partial @@ -4860,6 +4861,54 @@ def run_test(input, grad_output): grad = grad.permute(0, 2, 1, 3) run_test(input, grad) + @unittest.skipIf(not TEST_CUDA, "CUDA unavailable") + @unittest.skipIf(not TEST_CUDNN, "needs cudnn") + def test_batchnorm_nhwc_miopen(self): + def run_test(input, grad_output): + c = input.size(1) + mod = nn.BatchNorm2d(c).cuda().float() + mod.weight.data.uniform_() + mod.bias.data.uniform_() + ref_input = input.detach().clone(memory_format=torch.preserve_format).requires_grad_(True) + ref_grad = grad.detach().clone(memory_format=torch.preserve_format) + ref_mod = nn.BatchNorm2d(c).cuda().float() + ref_mod.load_state_dict(mod.state_dict()) + out = mod(input) + out.backward(grad_output) + with torch.backends.cudnn.flags(enabled=False): # force to use native nhwc batchnorm + ref_out = ref_mod(ref_input) + ref_out.backward(ref_grad) + self.assertTrue(out.is_contiguous(memory_format=torch.channels_last)) + self.assertTrue(ref_out.is_contiguous(memory_format=torch.channels_last)) + self.assertEqual(out, ref_out) + self.assertEqual(mod.weight.grad, ref_mod.weight.grad) + self.assertEqual(mod.bias.grad, ref_mod.bias.grad) + self.assertEqual(input.grad, ref_input.grad) + + # TODO: Remove PYTORCH_MIOPEN_SUGGEST_NHWC once ROCm officially supports NHWC in MIOpen + PYTORCH_MIOPEN_SUGGEST_NHWC = "PYTORCH_MIOPEN_SUGGEST_NHWC" + prev_val = os.getenv(PYTORCH_MIOPEN_SUGGEST_NHWC) + try: + os.environ[PYTORCH_MIOPEN_SUGGEST_NHWC] = "1" + input = torch.randint(1, 10, (4, 8, 2, 2), dtype=torch.float32, device="cuda") + input = input.contiguous(memory_format=torch.channels_last).detach().requires_grad_() + + grad = torch.randint(1, 10, (4, 8, 2, 2), dtype=torch.float32, device="cuda") + grad = grad.contiguous(memory_format=torch.channels_last) + run_test(input, grad) + # see #42588, grad is channels_last contiguous, but grad.suggest_memory_format (rightly) return "contiguous" + # not channels_last + input = torch.randint(1, 10, (2, 8, 8, 1), dtype=torch.float32, device="cuda") + input = input.contiguous(memory_format=torch.channels_last).detach().requires_grad_() + grad = torch.randint(1, 10, (2, 8, 8, 1), dtype=torch.float32, device="cuda") + grad = grad.permute(0, 2, 1, 3) + run_test(input, grad) + finally: + if prev_val is None: + del os.environ[PYTORCH_MIOPEN_SUGGEST_NHWC] + else: + os.environ[PYTORCH_MIOPEN_SUGGEST_NHWC] = prev_val + @unittest.skipIf(not TEST_CUDA, "CUDA unavailable") def test_batchnorm_cudnn_half(self): # THNN @@ -12838,4 +12887,14 @@ def __init__(self): if __name__ == '__main__': TestCase._default_dtype_check_enabled = True - run_tests() + # TODO: Remove PYTORCH_MIOPEN_SUGGEST_NHWC once ROCm officially supports NHWC in MIOpen + PYTORCH_MIOPEN_SUGGEST_NHWC = "PYTORCH_MIOPEN_SUGGEST_NHWC" + prev_val = os.getenv(PYTORCH_MIOPEN_SUGGEST_NHWC) + try: + os.environ[PYTORCH_MIOPEN_SUGGEST_NHWC] = "1" + run_tests() + finally: + if prev_val is None: + del os.environ[PYTORCH_MIOPEN_SUGGEST_NHWC] + else: + os.environ[PYTORCH_MIOPEN_SUGGEST_NHWC] = prev_val From a390471ab968802b77b5ffe69a9f29089a379d79 Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Tue, 11 Jun 2024 10:59:31 -0700 Subject: [PATCH 42/57] [HIP] Few more updates to the returned error string --- .../testing/_internal/distributed/nn/api/remote_module_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/torch/testing/_internal/distributed/nn/api/remote_module_test.py b/torch/testing/_internal/distributed/nn/api/remote_module_test.py index 825e4b59b6ce9..f4bbe337e4e96 100644 --- a/torch/testing/_internal/distributed/nn/api/remote_module_test.py +++ b/torch/testing/_internal/distributed/nn/api/remote_module_test.py @@ -615,7 +615,7 @@ def test_invalid_devices(self): if TEST_WITH_ROCM: errorString = (r"HIP error: invalid device ordinal\n" - r"HIP kernel errors might be asynchronously reported at some other API call,so the stacktrace below might be incorrect.\n" + r"HIP kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.\n" r"For debugging consider passing AMD_SERIALIZE_KERNEL=3.") else: errorString = r"CUDA error: invalid device ordinal" From 6be1d5daf443c936b8d1d0ccaad4a17986d00d94 Mon Sep 17 00:00:00 2001 From: Jithun Nair Date: Thu, 13 Jun 2024 18:23:15 +0000 Subject: [PATCH 43/57] skipIfRocm needs msg parameter --- test/test_cuda.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/test/test_cuda.py b/test/test_cuda.py index 7ec86bd6f47b4..c5acdac009517 100644 --- a/test/test_cuda.py +++ b/test/test_cuda.py @@ -2327,9 +2327,8 @@ def test_graph_capture_oom(self): with torch.cuda.graph(torch.cuda.CUDAGraph()): torch.zeros(2**40, device="cuda") - @unittest.skipIf( - not TEST_CUDA_GRAPH, "CUDA >= 11.0 or ROCM >= 5.3 required for graphs" - ) + @unittest.skipIf(not TEST_CUDA_GRAPH, "CUDA >= 11.0 or ROCM >= 5.3 required for graphs") + @skipIfRocm(msg="TODO: temp skip on ROCm 6.2") @serialTest() def test_repeat_graph_capture_cublas_workspace_memory(self): (x, y, z) = 1024, 512, 64 @@ -3139,9 +3138,8 @@ def forward(self, x): model_graphed({"x": real_inputs[0]}), model_control({"x": real_inputs[0]}) ) - @unittest.skipIf( - not TEST_CUDA_GRAPH, "CUDA >= 11.0 or ROCM >= 5.3 required for graphs" - ) + @unittest.skipIf(not TEST_CUDA_GRAPH, "CUDA >= 11.0 or ROCM >= 5.3 required for graphs") + @skipIfRocm(msg="TODO: temp skip on ROCm 6.2") def test_graph_make_graphed_callables_same_pool(self): torch.manual_seed(5) torch.cuda.manual_seed(5) From 31b3681882c5fb0ba4730c590052a05669ef483d Mon Sep 17 00:00:00 2001 From: Pruthvi Madugundu Date: Thu, 13 Jun 2024 12:36:21 -0700 Subject: [PATCH 44/57] [NO CP] Updated changes to skip few UTs --- test/dynamo/test_structured_trace.py | 1 + test/inductor/test_torchinductor_dynamic_shapes.py | 1 + test/run_test.py | 3 +++ test/test_fx.py | 1 + 4 files changed, 6 insertions(+) diff --git a/test/dynamo/test_structured_trace.py b/test/dynamo/test_structured_trace.py index f84e08b8f9cce..145a35ae5b61f 100644 --- a/test/dynamo/test_structured_trace.py +++ b/test/dynamo/test_structured_trace.py @@ -161,6 +161,7 @@ def test_schedule(self): self.assertParses() @requires_cuda + @skipIfRocm(msg="TODO: temp skip on ROCm 6.2") def test_cudagraphs(self): fn_opt = torch.compile(mode="reduce-overhead")(inductor_schedule_fn) fn_opt(torch.ones(1000, 1000, device="cuda")) diff --git a/test/inductor/test_torchinductor_dynamic_shapes.py b/test/inductor/test_torchinductor_dynamic_shapes.py index 8d05625002a4e..4c143b0e4c771 100644 --- a/test/inductor/test_torchinductor_dynamic_shapes.py +++ b/test/inductor/test_torchinductor_dynamic_shapes.py @@ -195,6 +195,7 @@ def fn(x, y): self.assertEqual(r, opt_r) @torch._dynamo.config.patch(capture_scalar_outputs=True) + @skipIfRocm(msg="TODO: temp skip on ROCm 6.2") def test_unwrap_storage_didnt_work_repro(self, device): def f(): full = torch.full((), 11) diff --git a/test/run_test.py b/test/run_test.py index bff83a1ec893a..91e5c0d29f7d3 100755 --- a/test/run_test.py +++ b/test/run_test.py @@ -182,6 +182,9 @@ def __contains__(self, item): "distributed/_tensor/test_attention", ] +if sys.version_info.major < 3 or (sys.version_info.major == 3 and sys.version_info.minor <= 9): + ROCM_BLOCKLIST.append("test_typing") + XPU_BLOCKLIST = [ "test_autograd", ] diff --git a/test/test_fx.py b/test/test_fx.py index a58abb906d89c..2c35598ae2e48 100644 --- a/test/test_fx.py +++ b/test/test_fx.py @@ -4106,6 +4106,7 @@ def test_class_member_back_compat(self): f"and subsequently --accept the change." raise AssertionError(msg) from e + @skipIfRocm(msg="TODO: flaky - https://github.com/pytorch/pytorch/issues/104012") def test_public_api_surface(self): non_back_compat_objects = {} From cefda3a58673a18e9a59a75e207c8cfb75264b74 Mon Sep 17 00:00:00 2001 From: Jerry Mannil <65309407+jerrymannil@users.noreply.github.com> Date: Tue, 16 Apr 2024 17:15:07 -0700 Subject: [PATCH 45/57] Add new kernel config for AMD GPUs --- torch/_inductor/kernel/mm_common.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/torch/_inductor/kernel/mm_common.py b/torch/_inductor/kernel/mm_common.py index 9ffaba040e7f1..4681fdcdc4880 100644 --- a/torch/_inductor/kernel/mm_common.py +++ b/torch/_inductor/kernel/mm_common.py @@ -136,6 +136,7 @@ def filtered_configs( {"config": (128, 64, 32, 4, 8), "cond": True}, {"config": (128, 128, 32, 2, 8), "cond": True}, {"config": (128, 128, 32, 3, 4), "cond": True}, + {"config": (128, 128, 64, 2, 8), "cond": torch.version.hip is not None}, {"config": (128, 128, 64, 3, 4), "cond": True}, {"config": (128, 128, 64, 5, 8), "cond": True}, ] @@ -165,6 +166,7 @@ def filtered_configs( # {"config": (32, 32, 16, 1, 2), "cond": True}, {"config": (128, 256, 128, 3, 8), "cond": torch.version.hip is None}, {"config": (256, 128, 128, 3, 8), "cond": torch.version.hip is None}, + {"config": (128, 128, 64, 2, 8), "cond": torch.version.hip is not None}, ] # Mixed precision kernel configs for small sizes of m for mm's like (16, 8192) x (8192, 8192). From 8068d3d006d0792684eaa43e000a970f07e000c4 Mon Sep 17 00:00:00 2001 From: Dmitry Nikolaev Date: Thu, 20 Jun 2024 19:34:07 +0000 Subject: [PATCH 46/57] Update gesvda USE_ROCM guards --- aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp index 3cadc120d2063..0351c4d5aaa45 100644 --- a/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp +++ b/aten/src/ATen/native/cuda/linalg/BatchLinearAlgebraLib.cpp @@ -328,7 +328,7 @@ inline static void svd_cusolver_gesvd(const Tensor& A, const Tensor& U, const Te // gesvd just knows how to handle m >= n, so in the other case we need to transpose A const auto not_A_H = A.size(-2) >= A.size(-1); Tensor Vcopy = V; // Shallow copy -#ifdef ROCM_VERSION +#ifdef USE_ROCM // Similar to the case in svd_magma(), experiments have shown Vh tensor is // not guaranteed to be column major on ROCM, we have to create a copy to // deal with this @@ -347,7 +347,7 @@ inline static void svd_cusolver_gesvd(const Tensor& A, const Tensor& U, const Te infos, full_matrices, compute_uv, calculate_all_batches, batches); }); -#ifdef ROCM_VERSION +#ifdef USE_ROCM if (compute_uv && !not_A_H) { V.copy_(Vcopy); } @@ -661,7 +661,7 @@ void svd_cusolver(const Tensor& A, static const char* check_svd_doc = "Check doc at https://pytorch.org/docs/stable/generated/torch.linalg.svd.html"; // The default heuristic is to use gesvdj driver -#if defined(ROCM_VERSION) && ROCM_VERSION < 60100 +#if defined(USE_ROCM) && ROCM_VERSION < 60100 const auto driver_v = c10::string_view("gesvdj"); #else const auto driver_v = driver.value_or("gesvdj"); From 5187ca9c8a47eb9870b17e8c2000ad4f0b2762e6 Mon Sep 17 00:00:00 2001 From: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> Date: Tue, 18 Jun 2024 00:54:42 -0500 Subject: [PATCH 47/57] Print consolidated log file for pytorch unit test automation scripts (#1433) * Print consolidated log file for pytorch uts * Update run_entire_tests subprocess call as well * lint * Add ERROR string --- .automation_scripts/run_pytorch_unit_tests.py | 30 ++++++++++++++----- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/.automation_scripts/run_pytorch_unit_tests.py b/.automation_scripts/run_pytorch_unit_tests.py index 5a9ed72424a37..4db0492bd5991 100644 --- a/.automation_scripts/run_pytorch_unit_tests.py +++ b/.automation_scripts/run_pytorch_unit_tests.py @@ -27,6 +27,7 @@ import os import shutil import subprocess +from subprocess import STDOUT, CalledProcessError from collections import namedtuple from datetime import datetime @@ -63,6 +64,8 @@ "distributed/test_distributed_spawn" ] +CONSOLIDATED_LOG_FILE_NAME="pytorch_unit_tests.log" + def parse_xml_reports_as_dict(workflow_run_id, workflow_run_attempt, tag, workflow_name, path="."): test_cases = {} items_list = os.listdir(path) @@ -198,6 +201,14 @@ def summarize_xml_files(path, workflow_name): return res +def run_command_and_capture_output(cmd): + try: + print(f"Running command '{cmd}'") + with open(CONSOLIDATED_LOG_FILE_PATH, "a+") as output_file: + p = subprocess.run(cmd, shell=True, stdout=output_file, stderr=STDOUT, text=True) + except CalledProcessError as e: + print(f"ERROR: Cmd {cmd} failed with return code: {e.returncode}!") + def run_entire_tests(workflow_name, test_shell_path, overall_logs_path_current_run, test_reports_src): if os.path.exists(test_reports_src): shutil.rmtree(test_reports_src) @@ -214,7 +225,7 @@ def run_entire_tests(workflow_name, test_shell_path, overall_logs_path_current_r os.environ['TEST_CONFIG'] = 'inductor' copied_logs_path = overall_logs_path_current_run + "inductor_xml_results_entire_tests/" # use test.sh for tests execution - subprocess.call(test_shell_path, shell=True) + run_command_and_capture_output(test_shell_path) copied_logs_path_destination = shutil.copytree(test_reports_src, copied_logs_path) entire_results_dict = summarize_xml_files(copied_logs_path_destination, workflow_name) return entire_results_dict @@ -232,7 +243,7 @@ def run_priority_tests(workflow_name, test_run_test_path, overall_logs_path_curr # use run_test.py for tests execution default_priority_test_suites = " ".join(DEFAULT_CORE_TESTS) command = "python " + test_run_test_path + " --include " + default_priority_test_suites + " --exclude-jit-executor --exclude-distributed-tests --verbose" - subprocess.call(command, shell=True) + run_command_and_capture_output(command) del os.environ['HIP_VISIBLE_DEVICES'] elif workflow_name == "distributed": os.environ['TEST_CONFIG'] = 'distributed' @@ -241,7 +252,7 @@ def run_priority_tests(workflow_name, test_run_test_path, overall_logs_path_curr # use run_test.py for tests execution distributed_priority_test_suites = " ".join(DISTRIBUTED_CORE_TESTS) command = "python " + test_run_test_path + " --include " + distributed_priority_test_suites + " --distributed-tests --verbose" - subprocess.call(command, shell=True) + run_command_and_capture_output(command) del os.environ['HIP_VISIBLE_DEVICES'] copied_logs_path_destination = shutil.copytree(test_reports_src, copied_logs_path) priority_results_dict = summarize_xml_files(copied_logs_path_destination, workflow_name) @@ -261,7 +272,7 @@ def run_selected_tests(workflow_name, test_run_test_path, overall_logs_path_curr # use run_test.py for tests execution default_selected_test_suites = " ".join(selected_list) command = "python " + test_run_test_path + " --include " + default_selected_test_suites + " --exclude-jit-executor --exclude-distributed-tests --verbose" - subprocess.call(command, shell=True) + run_command_and_capture_output(command) del os.environ['HIP_VISIBLE_DEVICES'] elif workflow_name == "distributed": os.environ['TEST_CONFIG'] = 'distributed' @@ -270,7 +281,7 @@ def run_selected_tests(workflow_name, test_run_test_path, overall_logs_path_curr # use run_test.py for tests execution distributed_selected_test_suites = " ".join(selected_list) command = "python " + test_run_test_path + " --include " + distributed_selected_test_suites + " --distributed-tests --verbose" - subprocess.call(command, shell=True) + run_command_and_capture_output(command) del os.environ['HIP_VISIBLE_DEVICES'] elif workflow_name == "inductor": os.environ['TEST_CONFIG'] = 'inductor' @@ -287,11 +298,11 @@ def run_selected_tests(workflow_name, test_run_test_path, overall_logs_path_curr if inductor_selected_test_suites != "": inductor_selected_test_suites = inductor_selected_test_suites[:-1] command = "python " + test_run_test_path + " --include " + inductor_selected_test_suites + " --verbose" - subprocess.call(command, shell=True) + run_command_and_capture_output(command) if non_inductor_selected_test_suites != "": non_inductor_selected_test_suites = non_inductor_selected_test_suites[:-1] command = "python " + test_run_test_path + " --inductor --include " + non_inductor_selected_test_suites + " --verbose" - subprocess.call(command, shell=True) + run_command_and_capture_output(command) copied_logs_path_destination = shutil.copytree(test_reports_src, copied_logs_path) selected_results_dict = summarize_xml_files(copied_logs_path_destination, workflow_name) @@ -336,6 +347,11 @@ def run_test_and_summarize_results( # performed as Job ID str_current_datetime = str(current_datetime) overall_logs_path_current_run = repo_test_log_folder_path + str_current_datetime + "/" + os.mkdir(overall_logs_path_current_run) + + global CONSOLIDATED_LOG_FILE_PATH + CONSOLIDATED_LOG_FILE_PATH = overall_logs_path_current_run + CONSOLIDATED_LOG_FILE_NAME + # Run entire tests for each workflow if not priority_tests and not default_list and not distributed_list and not inductor_list: # run entire tests for default, distributed and inductor workflows → use test.sh From 0c2f97c4e171c6977ea70e267217814be7e415e2 Mon Sep 17 00:00:00 2001 From: Jack Taylor <108682042+jataylo@users.noreply.github.com> Date: Tue, 18 Jun 2024 17:06:28 +0100 Subject: [PATCH 48/57] [ROCm] Intra-node all reduce initial implementation (#1435) * Initial commit to port intra_node_comm to ROCm (cherry picked from commit 48d1c330d4e3daa886b5dcde33eb758d2030dac8) * gpt-fast running now with intra-node comm (cherry picked from commit 618c54e00ef600c31ccf92beb44585282cc82001) --------- Co-authored-by: Prachi Gupta --- caffe2/CMakeLists.txt | 4 ++ .../csrc/distributed/c10d/intra_node_comm.cpp | 44 ++++++++++++++++--- .../csrc/distributed/c10d/intra_node_comm.cu | 33 +++++++++----- 3 files changed, 66 insertions(+), 15 deletions(-) diff --git a/caffe2/CMakeLists.txt b/caffe2/CMakeLists.txt index 8426741609fe7..b80c8d560b34d 100644 --- a/caffe2/CMakeLists.txt +++ b/caffe2/CMakeLists.txt @@ -609,6 +609,10 @@ if(USE_ROCM) append_filelist("libtorch_cuda_distributed_base_sources" Caffe2_HIP_SRCS) if(NOT WIN32) append_filelist("libtorch_cuda_distributed_extra_sources" Caffe2_HIP_SRCS) + set_source_files_properties( + ${TORCH_SRC_DIR}/csrc/distributed/c10d/intra_node_comm.cpp + PROPERTIES COMPILE_FLAGS "-DPYTORCH_C10_DRIVER_API_SUPPORTED=1" + ) endif() endif() # caffe2_nvrtc's stubs to driver APIs are useful for HIP. diff --git a/torch/csrc/distributed/c10d/intra_node_comm.cpp b/torch/csrc/distributed/c10d/intra_node_comm.cpp index 9d7ba5abf951d..d556ea9ab82cd 100644 --- a/torch/csrc/distributed/c10d/intra_node_comm.cpp +++ b/torch/csrc/distributed/c10d/intra_node_comm.cpp @@ -18,6 +18,8 @@ #if !defined(USE_ROCM) && defined(PYTORCH_C10_DRIVER_API_SUPPORTED) #include #include +#else +#include #endif #include @@ -146,7 +148,26 @@ static NvlMesh getNvlMesh(const std::vector& rankToBusId) { } return nvlMesh; #else - return {}; + NvlMesh nvlMesh = {}; + const auto worldSize = rankToBusId.size(); + // For each device, loop over devices connected to it + for (size_t idx = 0; idx < worldSize; ++idx) { + for (size_t link = 0; link < kMaxDevices; ++link) { + if(idx == link) continue; + + bool conn = false; + auto ret = rsmi_is_P2P_accessible(idx, link, &conn); + if (ret != RSMI_STATUS_SUCCESS){ + LOG(ERROR) << "IntraNodeComm: getNvlMesh: rsmi_is_P2P_accessible returned error ret=" << ret; + return {}; + } + + if (conn){ + nvlMesh[idx][link] += 1; + } + } + } + return nvlMesh; #endif } @@ -272,7 +293,6 @@ bool IntraNodeComm::rendezvous() { if (isInitialized_) { return true; } -#if !defined(USE_ROCM) && defined(PYTORCH_C10_DRIVER_API_SUPPORTED) if (!isIntraNodeCommSupported() || worldSize_ < 2 || worldSize_ > kMaxDevices) { return false; @@ -289,12 +309,28 @@ bool IntraNodeComm::rendezvous() { DevInfo devInfo{}; gethostname(devInfo.hostname, sizeof(devInfo.hostname)); + +#if defined(USE_ROCM) && defined(PYTORCH_C10_DRIVER_API_SUPPORTED) + auto ret = rsmi_init(0); + if (ret != RSMI_STATUS_SUCCESS) { + LOG(ERROR) << "IntraNodeComm:: rendezvous failed in rsmi_init, ret=" << ret; + return false; + } +#endif + cudaDeviceProp prop{}; AT_CUDA_CHECK(cudaGetDeviceProperties(&prop, deviceIdx)); + +#if defined(USE_ROCM) && defined(PYTORCH_C10_DRIVER_API_SUPPORTED) + auto pci_format = "%08X:%02X:%02X.0"; +#else + auto pci_format = NVML_DEVICE_PCI_BUS_ID_FMT; +#endif + snprintf( devInfo.busId, sizeof(devInfo.busId), - NVML_DEVICE_PCI_BUS_ID_FMT, + pci_format, prop.pciDomainID, prop.pciBusID, prop.pciDeviceID); @@ -344,8 +380,6 @@ bool IntraNodeComm::rendezvous() { buffersDev_ = symmetricMemory_->get_buffer_ptrs_dev(); topoInfo_ = topoInfo; return true; -#endif - return false; } } // namespace c10d::intra_node_comm diff --git a/torch/csrc/distributed/c10d/intra_node_comm.cu b/torch/csrc/distributed/c10d/intra_node_comm.cu index ac751ff7be1e0..9995dab0edbc8 100644 --- a/torch/csrc/distributed/c10d/intra_node_comm.cu +++ b/torch/csrc/distributed/c10d/intra_node_comm.cu @@ -4,6 +4,12 @@ #include #include +#if defined(USE_ROCM) +#include +#include +#include +#endif + namespace c10d { namespace intra_node_comm { @@ -17,7 +23,7 @@ static constexpr size_t kOneShotThreshBytes = 256 * 1024; static constexpr size_t kTwoShotThreshBytes = 10 * 1024 * 1024; #if defined(USE_ROCM) -using __nv_bfloat162 = uint32_t; +using __nv_bfloat162 = __hip_bfloat162; #endif struct __align__(16) bf16x8 { @@ -28,10 +34,7 @@ struct __align__(16) bf16x8 { DEVICE_INLINE __nv_bfloat162 bf16hadd2(const __nv_bfloat162 x, const __nv_bfloat162 y) { -#if defined(USE_ROCM) - CUDA_KERNEL_ASSERT(false); - return 0; -#elif (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) +#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) CUDA_KERNEL_ASSERT(false); __nv_bfloat162 res; return res; @@ -70,8 +73,12 @@ DEVICE_INLINE bf16x8 add_bf16x8(bf16x8 a, bf16x8 b) { */ template DEVICE_INLINE void streamLoad128(bf16x8& val, const T* addr) { -#if defined(USE_ROCM) || (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) +#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) CUDA_KERNEL_ASSERT(false); +#elif defined(USE_ROCM) + ulonglong2 l_val = __ldg(reinterpret_cast(addr)); + reinterpret_cast(&val)[0] = l_val.data[0]; + reinterpret_cast(&val)[1] = l_val.data[1]; #else unsigned long long int low, high; asm("ld.global.nc.v2.u64 {%0, %1}, [%2];" @@ -83,8 +90,13 @@ DEVICE_INLINE void streamLoad128(bf16x8& val, const T* addr) { } __device__ inline void streamStore128(at::BFloat16* addr, const bf16x8& val) { -#if defined(USE_ROCM) || (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) +#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) CUDA_KERNEL_ASSERT(false); +#elif defined(USE_ROCM) + for (int i = 0; i < 8; i++) + { + addr[i] = reinterpret_cast(&val)[i]; + } #else unsigned long long int low, high; low = reinterpret_cast(&val)[0]; @@ -104,15 +116,16 @@ DEVICE_INLINE void store128(T* addr, const bf16x8& val) { } DEVICE_INLINE void releaseSignal(uint32_t* addr) { -#if defined(USE_ROCM) || (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) +#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) CUDA_KERNEL_ASSERT(false); #else atomicAdd_system(addr, 1); + __threadfence_system(); #endif } DEVICE_INLINE void acquireSignal(uint32_t* addr) { -#if defined(USE_ROCM) || (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) +#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) CUDA_KERNEL_ASSERT(false); #else volatile uint32_t* signal = addr; @@ -473,7 +486,7 @@ static void getLaunchConfig( } bool isIntraNodeCommSupported() { -#if defined(USE_ROCM) || (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) +#if (defined(__CUDA_ARCH__) && (__CUDA_ARCH__ < 800)) return false; #else return true; From 012c13b966916f8879227dfd04371cb219d822e2 Mon Sep 17 00:00:00 2001 From: Jack Taylor <108682042+jataylo@users.noreply.github.com> Date: Tue, 18 Jun 2024 17:06:39 +0100 Subject: [PATCH 49/57] Scale XBLOCK in triton reduction configs to avoid hitting max grid (#1434) --- torch/_inductor/runtime/triton_heuristics.py | 21 ++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/torch/_inductor/runtime/triton_heuristics.py b/torch/_inductor/runtime/triton_heuristics.py index 5396ccf3e70d5..90d0873328130 100644 --- a/torch/_inductor/runtime/triton_heuristics.py +++ b/torch/_inductor/runtime/triton_heuristics.py @@ -1324,14 +1324,31 @@ def triton_config_reduction(size_hints, x, r, num_stages=1, num_warps=None) -> C while r < size_hints[1] and conditional_product(x, r) < target: r *= 2 - cfg = {"XBLOCK": x, "RBLOCK": r} if num_warps is None: num_warps = conditional_product(x, r) // 128 # On AMD GPU each warp has 64 lanes which is double the size on NV GPU, - # therefore using half the number of warps here correspondingly. + # therefore using half the number of warps here correspondingly.i default_num_warps = 4 if torch.version.hip else 8 min_num_warps = 1 if torch.version.hip else 2 num_warps = next_power_of_2(min(max(num_warps, min_num_warps), default_num_warps)) + + # Check if maxGridSize is exceeded - if so then must scale XBLOCK further + max_grid_x = 4294967295 if torch.version.hip else 2147483647 + warp_size = 64 if torch.version.hip else 32 + num_blocks = int((size_hints[0] + x - 1) // x) + while(num_blocks * num_warps * warp_size) > max_grid_x: + if (x >= TRITON_MAX_BLOCK["X"]): + if num_warps == 1: + break # If no more scaling possible then break + num_warps = int(num_warps / 2) # If max XBLOCK then scale down warps as last resort + x *= 2 # Scale up XBLOCK if grid exceeds limits + num_blocks = int(num_blocks / 2) + while conditional_product(x, r) > target: + r = int(r / 2) + if r == 1: + break + + cfg = {"XBLOCK": x, "RBLOCK": r} check_config(cfg, xnumel=size_hints[0]) assert r <= TRITON_MAX_BLOCK["R"], f"increase TRITON_MAX_BLOCK['r'] to {r}" return Config(cfg, num_warps=num_warps, num_stages=num_stages) From 6e45ab1cebd47e1504c1f73049f462e25907c9b0 Mon Sep 17 00:00:00 2001 From: Dmitry Nikolaev Date: Thu, 20 Jun 2024 20:01:18 +0000 Subject: [PATCH 50/57] rocm6.3 related_commits --- related_commits | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 related_commits diff --git a/related_commits b/related_commits new file mode 100644 index 0000000000000..1ae893a29ee9a --- /dev/null +++ b/related_commits @@ -0,0 +1,10 @@ +ubuntu|pytorch|apex|master|a4d9af3e08152db491057f9a59a017c37b985694|https://github.com/ROCm/apex +centos|pytorch|apex|master|a4d9af3e08152db491057f9a59a017c37b985694|https://github.com/ROCm/apex +ubuntu|pytorch|torchvision|main|bf01bab6125c5f1152e4f336b470399e52a8559d|https://github.com/pytorch/vision +centos|pytorch|torchvision|main|bf01bab6125c5f1152e4f336b470399e52a8559d|https://github.com/pytorch/vision +ubuntu|pytorch|torchtext|main|09e2690791add5ddfa10f186919f731f61516b3a|https://github.com/pytorch/text +centos|pytorch|torchtext|main|09e2690791add5ddfa10f186919f731f61516b3a|https://github.com/pytorch/text +ubuntu|pytorch|torchdata|main|958eeb055f414e2ec8e744d2fc9439a000a6c6fb|https://github.com/pytorch/data +centos|pytorch|torchdata|main|958eeb055f414e2ec8e744d2fc9439a000a6c6fb|https://github.com/pytorch/data +ubuntu|pytorch|torchaudio|main|b829e936f7cc61b48149f5f957a451a38bf2a178|https://github.com/pytorch/audio +centos|pytorch|torchaudio|main|b829e936f7cc61b48149f5f957a451a38bf2a178|https://github.com/pytorch/audio From 3aa060d3ee0b29758df50f46502c3b851f107666 Mon Sep 17 00:00:00 2001 From: Dmitry Nikolaev Date: Thu, 20 Jun 2024 20:07:38 +0000 Subject: [PATCH 51/57] caching test_times --- .additional_ci_files/test-class-times.json | 1 + .additional_ci_files/test-times.json | 1 + .gitignore | 1 - 3 files changed, 2 insertions(+), 1 deletion(-) create mode 100644 .additional_ci_files/test-class-times.json create mode 100644 .additional_ci_files/test-times.json diff --git a/.additional_ci_files/test-class-times.json b/.additional_ci_files/test-class-times.json new file mode 100644 index 0000000000000..aa472e1a4882a --- /dev/null +++ b/.additional_ci_files/test-class-times.json @@ -0,0 +1 @@ +{"cuda12.1-py3.10-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 3.51}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 3.5413333333333328, "TestFullyShardCollectiveOps": 88.8275, "TestFullyShardCommunication": 7.2170000000000005, "TestFullyShardPrefetch": 10.7735, "TestFullyShardUnshardMultiProcess": 3.558, "TestFullyShardUnshardMultiThread": 0.0155}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 10.389499999999998}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 7.05}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 3.569, "TestFullyShard1DTrainingCore": 3.6189999999999998, "TestFullyShard2DTraining": 7.238, "TestFullyShardGradientAccumulation": 3.619, "TestFullyShardHSDPTraining": 3.619}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 8.443499999999998, "TestDTensorCompileE2E": 14.095499999999998}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 10.125}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 19.664, "TestNew2dParallelTraining": 14.296500000000002}, "distributed/test_c10d_functional_native": {"CompileTest": 115.20450000000002, "TestWithNCCL": 31.985}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.9205, "TestMultiProc": 82.503, "TestSingleProc": 12.8595}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.9195, "TestCollectivesMultiProc": 51.1495}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 671.3829999999999, "AOTInductorTestABICompatibleCpuWithStackAllocation": 467.4564999999993, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 205.78599999999983, "AOTInductorTestABICompatibleCuda": 1277.0019999999997, "AOTInductorTestNonABICompatibleCpu": 1386.4064999999991, "AOTInductorTestNonABICompatibleCuda": 2121.0955000000004}, "inductor/test_torchinductor": {"CpuTests": 1340.8664999999996, "CudaTests": 332.17833333333334, "GPUTests": 793.0875000000005, "NanCheckerTest": 0.766, "RNNTest": 0.028, "SweepInputsCpuTest": 112.93049999999997, "SweepInputsCudaTest": 12.351000000000004, "SweepInputsGPUTest": 23.299999999999997, "TestFull": 10.0095, "TritonCodeGenTests": 24.400000000000002}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 8049.36599999999}, "test_modules": {"TestModuleCUDA": 564.5784999999856}, "test_ops": {"TestCommonCUDA": 685.5544999998714, "TestCompositeComplianceCUDA": 706.9264999999983, "TestFakeTensorCUDA": 694.8514999999949, "TestMathBitsCUDA": 78.93050000000041, "TestSelfKwarg": 1.333, "TestTagsCUDA": 2.1909999999999767}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1375.356499999892}, "test_torch": {"TestBasicVitalSigns": 0.192, "TestDevicePrecisionCUDA": 29.4365, "TestTorch": 192.58999999999963, "TestTorchDeviceTypeCUDA": 1355.074999999997, "TestVitalSignsCudaCUDA": 0.0155}}, "inductor_cpp_wrapper_abi_compatible": {"inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 378.2260000000001, "TestCppWrapper": 368.59500000000014}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 456.87649999999996, "TestCudaWrapper": 428.40399999999994}}, "inductor_distributed": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 10.721499999999999}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 16.128, "TestFullyShardCollectiveOps": 89.5205, "TestFullyShardCommunication": 10.626999999999999, "TestFullyShardPrefetch": 25.903, "TestFullyShardUnshardMultiProcess": 4.3095, "TestFullyShardUnshardMultiThread": 0.016}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 25.994999999999997}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 17.564}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 39.721000000000004, "TestFullyShard1DTrainingCore": 55.908, "TestFullyShard2DTraining": 26.770000000000003, "TestFullyShardGradientAccumulation": 28.759999999999998, "TestFullyShardHSDPTraining": 14.337}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 9.1675, "TestDTensorCompileE2E": 23.610499999999995}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 24.756}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 39.5415, "TestNew2dParallelTraining": 26.564}, "distributed/test_c10d_functional_native": {"CompileTest": 114.44049999999999, "TestWithNCCL": 50.257000000000005}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.220000000000002, "TestMultiProc": 188.86450000000002, "TestSingleProc": 12.945}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.9150000000000005, "TestCollectivesMultiProc": 86.64550000000001}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.008, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.008, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.008, "AOTInductorTestABICompatibleCuda": 17.9375, "AOTInductorTestNonABICompatibleCpu": 0.007, "AOTInductorTestNonABICompatibleCuda": 33.767500000000005}, "inductor/test_torchinductor": {"CpuTests": 3.9495, "GPUTests": 2.6719999999999997}}}, "cuda12.1-py3.10-gcc9-sm86-periodic-dynamo-benchmarks": {"aot_eager_huggingface": {"backends/xeon/test_launch": {"TestTorchrun": 2.085}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.1359999999999997}, "distributions/test_distributions": {"TestAgainstScipy": 1.065, "TestConstraints": 0.124, "TestDistributionShapes": 0.11200000000000006, "TestDistributions": 43.657999999999994, "TestFunctors": 0.008, "TestJit": 19.249999999999996, "TestKL": 2.537, "TestLazyLogitsInitialization": 0.011, "TestNumericalStability": 0.06000000000000001, "TestRsample": 0.611, "TestValidation": 0.31700000000000006}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.102}, "dynamo/test_after_aot": {"TestAfterAot": 4.797}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.072000000000001}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9560000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.439999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.034, "TestCustomBackendAPI": 1.689, "TestExplainWithBackend": 8.437, "TestOptimizations": 1.7579999999999998}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 11.816}, "dynamo/test_base_output": {"TestBaseOutput": 0.002}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.347, "BytecodeTests": 0.444}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.543, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.556}, "dynamo/test_config": {"ConfigTests": 0.546}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.108999999999999}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.3859999999999997}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.331}, "dynamo/test_decorators": {"DecoratorTests": 0.6820000000000002}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.003, "TestDeviceGuard": 0.019000000000000003}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 23.362, "DynamicShapesCtxManagerTests": 4.175, "DynamicShapesExportTests": 1291.209999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 95.98100000000004, "DynamicShapesFunctionTests": 16.462000000000007, "DynamicShapesHigherOrderOpTests": 15.227000000000006, "DynamicShapesMiscTests": 44.573000000000036, "DynamicShapesNNModuleTests": 2.6739999999999995, "DynamicShapesReproTests": 25.567000000000007, "DynamicShapesSubGraphTests": 7.870000000000001, "DynamicShapesTestSDPA": 0.313}, "dynamo/test_exc": {"ExcTests": 1.7949999999999997}, "dynamo/test_export": {"ExportTests": 13.932000000000002}, "dynamo/test_export_mutations": {"MutationExportTests": 0.53}, "dynamo/test_frame_init": {"FrameInitTests": 0.204}, "dynamo/test_functions": {"DefaultsTests": 0.7180000000000003, "FunctionTests": 20.060000000000024}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.162}, "dynamo/test_global": {"TestGlobals": 0.515}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.232}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.175000000000001, "FuncTorchHigherOrderOpTests": 9.797000000000002, "HigherOrderOpTests": 6.872999999999999, "HigherOrderOpVmapGuardTests": 3.636}, "dynamo/test_hooks": {"HooksTests": 23.098999999999997}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.5040000000000004}, "dynamo/test_interop": {"InteropTests": 0.5469999999999999}, "dynamo/test_logging": {"LoggingTests": 18.500999999999998}, "dynamo/test_minifier": {"MinifierTests": 2.0469999999999997}, "dynamo/test_misc": {"MiscTests": 47.021000000000086, "TestTracer": 0.054}, "dynamo/test_model_output": {"TestHFPretrained": 0.412, "TestModelOutput": 0.22100000000000003}, "dynamo/test_modules": {"NNModuleTests": 2.5939999999999976, "OptimizedModuleTest": 7.912}, "dynamo/test_nops": {"NopTests": 0.299}, "dynamo/test_optimizers": {"End2EndTests": 0.618}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.466}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.269}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.625}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.8030000000000002}, "dynamo/test_recompiles": {"RecompileTests": 0.799}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.504}, "dynamo/test_repros": {"ReproTests": 29.47400000000001}, "dynamo/test_resume": {"ResumeFunctionTests": 0.421}, "dynamo/test_sdpa": {"TestSDPA": 0.467}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.603}, "dynamo/test_sources": {"SourceTests": 0.47600000000000003}, "dynamo/test_structured_trace": {"StructuredTraceTest": 13.992}, "dynamo/test_subclasses": {"SubclassTests": 2.6849999999999987, "TestNestedTensor": 12.829999999999998}, "dynamo/test_subgraphs": {"SubGraphTests": 1.951999999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.096, "TraceRuleTests": 1.158}, "dynamo/test_unspec": {"UnspecTests": 10.329999999999998}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.562}, "export/test_converter": {"TestConverter": 0.281}, "export/test_db": {"ExampleTests": 2.798}, "export/test_experimental": {"TestExperiment": 0.915}, "export/test_export": {"TestDynamismExpression": 0.447, "TestExport": 23.66599999999999, "TestExportCustomClass": 0.058, "TestOneOffModelExportResult": 1.201}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.364, "NonStrictExportTestExport": 20.36399999999999}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.636}, "export/test_hop": {"TestHOPCUDA": 1.654, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.08}, "export/test_pass_infra": {"TestPassInfra": 0.8280000000000002}, "export/test_passes": {"TestPasses": 10.901}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.7429999999999999, "RetraceExportTestExport": 34.69300000000002}, "export/test_schema": {"TestSchema": 0.23800000000000002}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.498, "SerDesExportTestExport": 23.548999999999992}, "export/test_serialize": {"TestDeserialize": 7.118999999999998, "TestSaveLoad": 0.275, "TestSchemaVersioning": 0.029, "TestSerialize": 0.9840000000000002, "TestSerializeCustomClass": 0.082}, "export/test_sparse": {"TestSparseProp": 52.72899999999987}, "export/test_tools": {"TestExportTools": 0.543}, "export/test_torchbind": {"TestCompileTorchbind": 0.449, "TestExportTorchbind": 1.9839999999999993, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.213}, "export/test_unflatten": {"TestUnflatten": 2.8360000000000007}, "export/test_verifier": {"TestVerifier": 0.8520000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.833000000000004, "TestAOTDispatch": 0.439, "TestAOTExport": 1.985, "TestAOTModuleSimplified": 0.558, "TestPartitioning": 3.165}, "functorch/test_control_flow": {"TestControlFlow": 0.7640000000000002, "TestControlFlowTraced": 109.29800000000017}, "functorch/test_dims": {"TestMin": 13.152999999999999, "TestMinFunctorchOnly": 12.476999999999999}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.08600000000000003, "TestAutogradFunctionVmapAPICUDA": 0.017, "TestCompileTransformsCUDA": 4.471, "TestComposabilityCUDA": 0.12900000000000006, "TestExamplesCorrectnessCUDA": 2.0799999999999996, "TestFunctionalizeCUDA": 0.09800000000000003, "TestGradTransformCUDA": 0.9059999999999999, "TestHelpersCUDA": 0.01, "TestHessianCUDA": 0.056, "TestHigherOrderOperatorInteractionCUDA": 0.021000000000000005, "TestJacCUDA": 0.7370000000000002, "TestJvpCUDA": 0.048000000000000015, "TestLinearizeCUDA": 0.23999999999999996, "TestMakeFunctional": 0.06200000000000001, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.627}, "functorch/test_logging": {"TestAOTLogging": 0.24}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.28500000000000003, "RandomOpTestCase": 0.071, "ReduceTestCase": 0.064, "TestMemoryEfficientOpAuthoring": 7.156000000000001}, "functorch/test_minifier": {"TestMinifier": 0.3770000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 4169.963999999979}, "functorch/test_parsing": {"TestAnonymousAxis": 0.651, "TestParsedExpression": 0.004, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.6980000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6940000000000005, "TestTransformFailureCUDA": 0.092, "TestVmapAPI": 0.809, "TestVmapBatchedGradientCUDA": 0.22000000000000008, "TestVmapDeviceTypeCUDA": 0.018000000000000002, "TestVmapNestedTensorCUDA": 0.031000000000000003, "TestVmapOperators": 2.3079999999999963, "TestVmapOperatorsOpInfoCUDA": 269.89999999999924}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.4029999999998584}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.847000000000001}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 668.6869999999997, "AOTInductorTestABICompatibleCpuWithStackAllocation": 450.81799999999936, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 191.87099999999995, "AOTInductorTestABICompatibleCuda": 1271.3609999999994, "AOTInductorTestNonABICompatibleCpu": 1366.6040000000005, "AOTInductorTestNonABICompatibleCuda": 2048.7379999999994}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.664, "BenchmarkFusionCudaTest": 78.98, "BenchmarkMultiTemplateFusionCudaTest": 14.490000000000002}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.305, "FreezingCudaTests": 4.7490000000000006}, "inductor/test_codecache": {"TestFxGraphCache": 116.36, "TestFxGraphCacheHashing": 0.776, "TestUtils": 3.359, "test_codecache": 2.928}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.215}, "inductor/test_compile_worker": {"TestCompileWorker": 5.032}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 202.72200000000078, "TestCompiledAutograd": 154.92800000000003, "TestCustomOpWithCompiledAutograd": 0.3230000000000002}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 650.7410000000001, "CompiledOptimizerTests": 1362.7400000000005}, "inductor/test_config": {"TestInductorConfig": 5.279000000000002}, "inductor/test_control_flow": {"CondTests": 84.621, "WhileLoopTests": 35.25599999999999}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.265}, "inductor/test_cpu_repro": {"CPUReproTests": 635.313}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1008.768, "TestCudaWrapper": 960.4829999999996}, "inductor/test_cuda_repro": {"CudaReproTests": 78.10499999999999}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 65.05899999999997}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.502}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 9.978}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 127.25400000000002}, "inductor/test_debug_trace": {"TestDebugTrace": 13.651}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.289}, "inductor/test_dependencies": {"TestDependencies": 0.21000000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 33.81099999999999}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 181.199, "EfficientConvBNEvalCudaTests": 118.544}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.923}, "inductor/test_flex_attention": {"TestFlexAttention": 407.2029999999997}, "inductor/test_foreach": {"ForeachTests": 296.3810000000001}, "inductor/test_fp8": {"TestFP8Types": 0.010000000000000002}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 72.55900000000001, "SDPAPatternRewriterCpuTests": 68.257, "SDPAPatternRewriterCudaDynamicTests": 42.925000000000004, "SDPAPatternRewriterCudaTests": 33.782}, "inductor/test_fx_fusion": {"TestFxFusion": 0.177}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023, "TestGroupBatchFusion": 105.054, "TestPostGradBatchLinearFusion": 1.927}, "inductor/test_indexing": {"ExprPrinterTests": 0.049000000000000016, "TestIndexingSimplification": 0.529}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 47.695, "FreezingCudaTests": 33.028000000000006}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 6.975}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 124.56300000000002}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.487999999999998}, "inductor/test_max_autotune": {"TestMaxAutotune": 231.04600000000005, "TestTuningProcess": 10.095}, "inductor/test_memory_planning": {"TestMemoryPlanning": 29.028}, "inductor/test_metrics": {"TestMetrics": 3.798000000000001}, "inductor/test_minifier": {"MinifierTests": 28.125000000000004}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 90.581}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 79.61099999999999, "TestPatternMatcher": 403.4259999999997}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.134999999999998}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.784}, "inductor/test_multi_kernel": {"MultiKernelTest": 72.816}, "inductor/test_pad_mm": {"PadMMTest": 127.444}, "inductor/test_padding": {"PaddingTest": 14.293000000000003, "PerfTestBetweenGoodAndBadShape": 0.002, "PerfTestWithAndWithoutPadding": 4.333}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 90.64599999999999}, "inductor/test_perf": {"FusionTests": 13.384, "InplacingTests": 5.815, "MinCutPartitioningTests": 10.542, "NoopTests": 0.8970000000000001, "NumBytesMetricTests": 24.460000000000004, "SchedulerFusionTests": 8.504, "TilingTests": 2.1550000000000002}, "inductor/test_profiler": {"DynamoProfilerTests": 7.9079999999999995}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 113.91600000000001}, "inductor/test_smoke": {"SmokeTest": 6.072}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.802, "MemoryBoundedTests": 3.1129999999999995, "TestCommAnalysis": 6.563000000000001, "UnsupportedTests": 0.318}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 98.208}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.065}, "inductor/test_torchbind": {"TestTorchbind": 6.262}, "inductor/test_torchinductor": {"CpuTests": 0.001, "GPUTests": 17.668}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 0.001, "DynamicShapesCodegenGPUTests": 15.528}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 0.001, "DynamicShapesGPUTests": 9.071}, "nn/test_convolution": {"TestConvolutionNN": 20.985, "TestConvolutionNNDeviceTypeCUDA": 50.60499999999952}, "nn/test_pooling": {"TestAvgPool": 0.7410000000000001, "TestPoolingNN": 0.647, "TestPoolingNNDeviceTypeCUDA": 4.524999999999997}, "profiler/test_profiler": {"TestProfiler": 0.7080000000000001}, "test_autocast": {"TestAutocastCPU": 1.9169999999999998, "TestAutocastGPU": 0.20400000000000001, "TestTorchAutocast": 0.003}, "test_autograd_fallback": {"TestAutogradFallback": 0.7290000000000001}, "test_cpp_api_parity": {"TestCppApiParity": 8.696999999999981}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.687, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.659, "TestMAIATensor": 0.006, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.046}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 166.06700000000004}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.426}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.656}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.419}, "test_cuda": {"TestCuda": 14.392000000000001}, "test_cuda_expandable_segments": {"TestCuda": 16.103}, "test_cuda_multigpu": {"TestCudaMultiGPU": 0.857}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.767, "TestVisibleDeviceParses": 1.27}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.261}, "test_cuda_trace": {"TestCudaTrace": 6.696}, "test_dispatch": {"TestDispatch": 32.942000000000014, "TestPythonDispatcher": 0.031}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.018000000000000002, "FakeTensorDispatchCache": 0.06300000000000001, "FakeTensorOpInfoTestCUDA": 0.07400000000000001, "FakeTensorOperatorInvariants": 0.44800000000000006, "FakeTensorPropTest": 0.055999999999999994, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.559, "PropagateRealTensorsFakeTensorConstHandling": 0.069, "PropagateRealTensorsFakeTensorConverterTest": 0.016, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.154, "PropagateRealTensorsFakeTensorPropTest": 0.04, "PropagateRealTensorsFakeTensorTest": 10.053000000000013}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.21400000000000002, "TestCommonPass": 0.14300000000000004, "TestConstFold": 0.12200000000000004, "TestConstParamShapeInControlFlow": 0.030000000000000002, "TestDCE": 0.020999999999999998, "TestFX": 2.2079999999999975, "TestFXAPIBackwardCompatibility": 0.021, "TestFunctionalTracing": 0.2460000000000002, "TestMatcher": 0.31900000000000006, "TestOperatorSignaturesCUDA": 0.6800000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.9680000000000001, "TestSubgraphRewriter": 0.2240000000000001, "TestVisionTracing": 211.73600000000002, "TypeCheckerTest": 1.555999999999998}, "test_indexing": {"TestIndexingCUDA": 0.564}, "test_jit_disabled": {"TestJitDisabled": 0.7260000000000001}, "test_linalg": {"TestLinalgCUDA": 13.14}, "test_mobile_optimizer": {"TestOptimizer": 2.5330000000000004}, "test_multiprocessing": {"TestMultiprocessing": 86.09200000000003}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.542, "SpawnTest": 19.083}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.942}, "test_native_mha": {"TestMHADeviceTypeCUDA": 1.042}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.256, "TestFusionUtils": 0.004, "TestNN": 45.26900000000011, "TestNNDeviceTypeCUDA": 120.98800000000418, "TestUtils": 0.003}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.017, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.006, "TestResolveName": 0.095, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 2.130999999999891, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.023, "TestPythonDispatch": 0.19600000000000006, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2449999999999994, "TestWrapperSubclassAliasingCUDA": 0.10700000000000004}, "test_reductions": {"TestReductionsCUDA": 132.13600000000284}, "test_serialization": {"TestSerialization": 5.803}, "test_show_pickle": {"TestShowPickle": 0.643}, "test_sort_and_select": {"TestSortAndSelectCUDA": 4.068999999999995}, "test_spectral_ops": {"TestFFTCUDA": 18.79299999999997}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4230000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.12600000000000003, "TestTensorCreationCUDA": 78.1420000000003}, "test_tensorexpr": {"TestTensorExprFuser": 114.01900000000002}, "test_torch": {"TestBasicVitalSigns": 0.024, "TestDevicePrecisionCUDA": 0.05300000000000002, "TestTorch": 4.628999999999989, "TestTorchDeviceTypeCUDA": 81.717, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.053, "TestBottleneck": 9.754, "TestCheckpoint": 0.30100000000000005, "TestCollectEnv": 0.977, "TestCppExtensionUtils": 0.029, "TestDataLoaderUtils": 0.266, "TestDeviceUtilsCUDA": 11.735000000000575, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.005, "TestONNXUtils": 0.003, "TestRenderUtils": 0.011, "TestStandaloneCPPJIT": 2.243, "TestTraceback": 0.005}}, "aot_eager_timm": {"backends/xeon/test_launch": {"TestTorchrun": 2.04}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.1299999999999994}, "distributions/test_distributions": {"TestAgainstScipy": 1.1019999999999999, "TestConstraints": 0.12, "TestDistributionShapes": 0.10300000000000006, "TestDistributions": 43.52000000000001, "TestFunctors": 0.008, "TestJit": 18.952, "TestKL": 2.536, "TestLazyLogitsInitialization": 0.009000000000000001, "TestNumericalStability": 0.05700000000000001, "TestRsample": 0.61, "TestValidation": 0.28800000000000003}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.426}, "dynamo/test_after_aot": {"TestAfterAot": 4.752}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.092000000000002}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.932}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.31}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.031, "TestCustomBackendAPI": 1.738, "TestExplainWithBackend": 9.982, "TestOptimizations": 1.7339999999999998}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.613000000000001}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 7.212, "BytecodeTests": 0.446}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.508, "PublicTorchCompilerTests": 0.003}, "dynamo/test_comptime": {"ComptimeTests": 0.5650000000000001}, "dynamo/test_config": {"ConfigTests": 0.534}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.0439999999999996}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.293}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.303}, "dynamo/test_decorators": {"DecoratorTests": 0.6410000000000001}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.013}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 23.185, "DynamicShapesCtxManagerTests": 4.069, "DynamicShapesExportTests": 1289.131, "DynamicShapesFuncTorchHigherOrderOpTests": 96.24400000000001, "DynamicShapesFunctionTests": 16.264999999999993, "DynamicShapesHigherOrderOpTests": 14.959000000000001, "DynamicShapesMiscTests": 44.45600000000001, "DynamicShapesNNModuleTests": 2.5810000000000004, "DynamicShapesReproTests": 25.616000000000007, "DynamicShapesSubGraphTests": 7.925999999999997, "DynamicShapesTestSDPA": 0.344}, "dynamo/test_exc": {"ExcTests": 1.817}, "dynamo/test_export": {"ExportTests": 13.615000000000004}, "dynamo/test_export_mutations": {"MutationExportTests": 0.52}, "dynamo/test_frame_init": {"FrameInitTests": 0.2}, "dynamo/test_functions": {"DefaultsTests": 0.7030000000000002, "FunctionTests": 20.110000000000003}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.137}, "dynamo/test_global": {"TestGlobals": 0.507}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.22200000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.316, "FuncTorchHigherOrderOpTests": 9.705, "HigherOrderOpTests": 6.628, "HigherOrderOpVmapGuardTests": 3.643}, "dynamo/test_hooks": {"HooksTests": 23.15500000000001}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.454}, "dynamo/test_interop": {"InteropTests": 0.5449999999999999}, "dynamo/test_logging": {"LoggingTests": 18.373}, "dynamo/test_minifier": {"MinifierTests": 2.069}, "dynamo/test_misc": {"MiscTests": 47.06900000000004, "TestTracer": 0.05}, "dynamo/test_model_output": {"TestHFPretrained": 0.42, "TestModelOutput": 0.22400000000000003}, "dynamo/test_modules": {"NNModuleTests": 2.5749999999999984, "OptimizedModuleTest": 7.849}, "dynamo/test_nops": {"NopTests": 0.279}, "dynamo/test_optimizers": {"End2EndTests": 0.615}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.47100000000000003}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.244}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.603}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.7920000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.7910000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.5}, "dynamo/test_repros": {"ReproTests": 29.129}, "dynamo/test_resume": {"ResumeFunctionTests": 0.42}, "dynamo/test_sdpa": {"TestSDPA": 0.461}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.5820000000000001}, "dynamo/test_sources": {"SourceTests": 0.454}, "dynamo/test_structured_trace": {"StructuredTraceTest": 13.898}, "dynamo/test_subclasses": {"SubclassTests": 2.6239999999999983, "TestNestedTensor": 12.869000000000002}, "dynamo/test_subgraphs": {"SubGraphTests": 1.9889999999999992}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.096, "TraceRuleTests": 1.126}, "dynamo/test_unspec": {"UnspecTests": 10.323999999999996}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.555}, "export/test_converter": {"TestConverter": 0.275}, "export/test_db": {"ExampleTests": 2.7359999999999993}, "export/test_experimental": {"TestExperiment": 0.899}, "export/test_export": {"TestDynamismExpression": 0.424, "TestExport": 23.469000000000012, "TestExportCustomClass": 0.059000000000000004, "TestOneOffModelExportResult": 1.216}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.352, "NonStrictExportTestExport": 20.556999999999988}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.624}, "export/test_hop": {"TestHOPCUDA": 1.6539999999999995, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.082}, "export/test_pass_infra": {"TestPassInfra": 0.8250000000000002}, "export/test_passes": {"TestPasses": 10.911999999999999}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.7509999999999999, "RetraceExportTestExport": 34.99599999999999}, "export/test_schema": {"TestSchema": 0.23900000000000002}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.504, "SerDesExportTestExport": 23.06200000000001}, "export/test_serialize": {"TestDeserialize": 6.854, "TestSaveLoad": 0.26, "TestSchemaVersioning": 0.027, "TestSerialize": 0.9850000000000003, "TestSerializeCustomClass": 0.076}, "export/test_sparse": {"TestSparseProp": 52.302999999999884}, "export/test_tools": {"TestExportTools": 0.515}, "export/test_torchbind": {"TestCompileTorchbind": 0.433, "TestExportTorchbind": 1.8789999999999991, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.197}, "export/test_unflatten": {"TestUnflatten": 2.742}, "export/test_verifier": {"TestVerifier": 0.8370000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.523999999999996, "TestAOTDispatch": 0.423, "TestAOTExport": 1.882, "TestAOTModuleSimplified": 0.543, "TestPartitioning": 3.080999999999999}, "functorch/test_control_flow": {"TestControlFlow": 0.7620000000000002, "TestControlFlowTraced": 107.4300000000001}, "functorch/test_dims": {"TestMin": 13.015999999999998, "TestMinFunctorchOnly": 12.361999999999998}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.07300000000000004, "TestAutogradFunctionVmapAPICUDA": 0.017, "TestCompileTransformsCUDA": 4.3870000000000005, "TestComposabilityCUDA": 0.14300000000000002, "TestExamplesCorrectnessCUDA": 2.0569999999999995, "TestFunctionalizeCUDA": 0.09200000000000003, "TestGradTransformCUDA": 0.8930000000000002, "TestHelpersCUDA": 0.01, "TestHessianCUDA": 0.057, "TestHigherOrderOperatorInteractionCUDA": 0.021000000000000005, "TestJacCUDA": 0.7440000000000002, "TestJvpCUDA": 0.048000000000000015, "TestLinearizeCUDA": 0.23799999999999996, "TestMakeFunctional": 0.06100000000000001, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.6100000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.241}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.28400000000000003, "RandomOpTestCase": 0.074, "ReduceTestCase": 0.064, "TestMemoryEfficientOpAuthoring": 7.207}, "functorch/test_minifier": {"TestMinifier": 0.3770000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 4144.264999999986}, "functorch/test_parsing": {"TestAnonymousAxis": 0.641, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.679}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.7190000000000005, "TestTransformFailureCUDA": 0.095, "TestVmapAPI": 0.801, "TestVmapBatchedGradientCUDA": 0.19800000000000006, "TestVmapDeviceTypeCUDA": 0.018000000000000002, "TestVmapNestedTensorCUDA": 0.035, "TestVmapOperators": 2.3579999999999965, "TestVmapOperatorsOpInfoCUDA": 280.1039999999991}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.429999999999855}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.716}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 669.9599999999996, "AOTInductorTestABICompatibleCpuWithStackAllocation": 450.16399999999965, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 191.87300000000005, "AOTInductorTestABICompatibleCuda": 1274.886, "AOTInductorTestNonABICompatibleCpu": 1365.6839999999993, "AOTInductorTestNonABICompatibleCuda": 2057.5109999999995}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.74, "BenchmarkFusionCudaTest": 78.87, "BenchmarkMultiTemplateFusionCudaTest": 14.545}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.465999999999998, "FreezingCudaTests": 4.859}, "inductor/test_codecache": {"TestFxGraphCache": 118.32300000000002, "TestFxGraphCacheHashing": 0.7789999999999999, "TestUtils": 3.306, "test_codecache": 3.577}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.224}, "inductor/test_compile_worker": {"TestCompileWorker": 4.920999999999999}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 205.46900000000073, "TestCompiledAutograd": 156.26299999999995, "TestCustomOpWithCompiledAutograd": 0.3350000000000002}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 653.056, "CompiledOptimizerTests": 1354.5460000000007}, "inductor/test_config": {"TestInductorConfig": 5.259}, "inductor/test_control_flow": {"CondTests": 84.99799999999999, "WhileLoopTests": 35.72}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.0800000000000005}, "inductor/test_cpu_repro": {"CPUReproTests": 639.409}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1008.958, "TestCudaWrapper": 962.0869999999999}, "inductor/test_cuda_repro": {"CudaReproTests": 78.537}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 65.142}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.5460000000000003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.231}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 127.06800000000004}, "inductor/test_debug_trace": {"TestDebugTrace": 13.325}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.345}, "inductor/test_dependencies": {"TestDependencies": 0.21200000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 33.939}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 180.774, "EfficientConvBNEvalCudaTests": 118.718}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.671}, "inductor/test_flex_attention": {"TestFlexAttention": 406.94799999999987}, "inductor/test_foreach": {"ForeachTests": 294.35800000000006}, "inductor/test_fp8": {"TestFP8Types": 0.008}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 73.26200000000001, "SDPAPatternRewriterCpuTests": 70.96100000000001, "SDPAPatternRewriterCudaDynamicTests": 40.787, "SDPAPatternRewriterCudaTests": 32.72400000000001}, "inductor/test_fx_fusion": {"TestFxFusion": 0.173}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023, "TestGroupBatchFusion": 104.797, "TestPostGradBatchLinearFusion": 1.915}, "inductor/test_indexing": {"ExprPrinterTests": 0.049000000000000016, "TestIndexingSimplification": 0.52}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 48.162, "FreezingCudaTests": 33.29699999999999}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 6.901999999999999}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 123.97799999999998}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.371999999999998}, "inductor/test_max_autotune": {"TestMaxAutotune": 229.99900000000005, "TestTuningProcess": 9.786000000000001}, "inductor/test_memory_planning": {"TestMemoryPlanning": 28.86}, "inductor/test_metrics": {"TestMetrics": 3.7650000000000006}, "inductor/test_minifier": {"MinifierTests": 28.123}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 89.435}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 80.691, "TestPatternMatcher": 393.47699999999975}, "inductor/test_mmdecomp": {"TestDecompCUDA": 8.962999999999997}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.693000000000001}, "inductor/test_multi_kernel": {"MultiKernelTest": 71.05499999999999}, "inductor/test_pad_mm": {"PadMMTest": 126.084}, "inductor/test_padding": {"PaddingTest": 14.296000000000001, "PerfTestBetweenGoodAndBadShape": 0.003, "PerfTestWithAndWithoutPadding": 4.293}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 91.666}, "inductor/test_perf": {"FusionTests": 13.628, "InplacingTests": 5.643999999999999, "MinCutPartitioningTests": 10.71, "NoopTests": 0.9200000000000002, "NumBytesMetricTests": 24.934, "SchedulerFusionTests": 8.503, "TilingTests": 1.908}, "inductor/test_profiler": {"DynamoProfilerTests": 7.6370000000000005}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 114.45300000000003}, "inductor/test_smoke": {"SmokeTest": 5.96}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.6499999999999995, "MemoryBoundedTests": 3.152, "TestCommAnalysis": 6.303000000000001, "UnsupportedTests": 0.309}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 98.04599999999999}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.16}, "inductor/test_torchbind": {"TestTorchbind": 6.176}, "inductor/test_torchinductor": {"CpuTests": 1503.3869999999993, "GPUTests": 875.7269999999996, "NanCheckerTest": 0.873, "RNNTest": 0.019, "SweepInputsCpuTest": 112.33300000000001, "SweepInputsGPUTest": 28.608, "TestFull": 10.019, "TritonCodeGenTests": 176.767}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1621.7750000000003, "DynamicShapesCodegenGPUTests": 986.2730000000001}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1721.5529999999997, "DynamicShapesGPUTests": 1319.0949999999996, "TestInductorDynamicCUDA": 42.080999999999996}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1639.4039999999968}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.522}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.005}, "inductor/test_triton_kernels": {"KernelTests": 93.46700000000001, "MutationTests": 0.30800000000000016}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 6.97}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 19.034000000000002}, "inductor/test_utils": {"TestUtils": 0.204}, "lazy/test_debug_util": {"DebugUtilTest": 0.685}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.7120000000000001}, "lazy/test_generator": {"LazyGeneratorTest": 0.682}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.8280000000000001}, "lazy/test_step_closures": {"ClosuresTest": 2.632}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.171, "TestLazyTensor": 0.535}, "nn/test_convolution": {"TestConvolutionNN": 20.835000000000004, "TestConvolutionNNDeviceTypeCUDA": 51.251999999999484}, "nn/test_dropout": {"TestDropoutNN": 0.545, "TestDropoutNNDeviceTypeCUDA": 0.45299999999999996}, "nn/test_embedding": {"TestEmbeddingNN": 0.533, "TestEmbeddingNNDeviceTypeCUDA": 10.251000000000003}, "nn/test_init": {"TestNNInit": 3.9319999999999986}, "nn/test_lazy_modules": {"TestLazyModules": 0.8170000000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.9930000000000001, "TestLoadStateDictSwap": 0.043}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.019000000000000003, "TestModuleHookNN": 0.051000000000000004, "TestModuleHooks": 0.608, "TestStateDictHooks": 0.013}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 4.616000000000001, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.2750000000000001}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.7359999999999995}, "nn/test_parametrization": {"TestNNParametrization": 1.1069999999999993, "TestNNParametrizationDeviceCUDA": 0.134}, "nn/test_pooling": {"TestAvgPool": 0.65, "TestPoolingNN": 0.646, "TestPoolingNNDeviceTypeCUDA": 4.470999999999997}, "nn/test_pruning": {"TestPruningNN": 0.49900000000000005}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.235}, "profiler/test_memory_profiler": {"TestDataFlow": 1.0270000000000001, "TestIdentifyGradients": 0.275, "TestMemoryProfiler": 0.644, "TestMemoryProfilerE2E": 2.5429999999999993}, "profiler/test_profiler": {"TestExperimentalUtils": 3.937999999999999, "TestProfiler": 18.608999999999998, "TestProfilerCUDA": 5.584, "TestProfilerITT": 0.002}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.686}, "profiler/test_record_function": {"TestRecordFunction": 0.672}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.696999999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.049, "TestBaseDataScheduler": 0.02, "TestBaseDataSparsifier": 0.051000000000000004, "TestBaseSparsifier": 0.022, "TestBaseStructuredSparsifier": 3.0849999999999995, "TestComposability": 1.5139999999999998, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.061, "TestFakeSparsity": 0.059000000000000004, "TestFxComposability": 1.4009999999999998, "TestNearlyDiagonalSparsifier": 0.669, "TestNormDataSparsifiers": 0.6869999999999999, "TestQuantizationUtils": 0.015, "TestQuantizedSparseKernels": 0.408, "TestQuantizedSparseLayers": 0.33299999999999996, "TestSaliencyPruner": 0.02, "TestScheduler": 0.011000000000000001, "TestSparsityUtilFunctions": 0.026000000000000002, "TestWeightNormSparsifier": 0.376}, "test_autocast": {"TestAutocastCPU": 1.9459999999999997, "TestAutocastGPU": 0.212, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.021000000000000005, "TestAutograd": 15.123999999999981, "TestAutogradComplex": 0.004, "TestAutogradDeviceTypeCUDA": 2.3939999999999984, "TestAutogradForwardMode": 0.04900000000000002, "TestAutogradForwardModeBatchedGrad": 0.013000000000000001, "TestAutogradFunctional": 8.584, "TestAutogradInferenceMode": 0.024000000000000007, "TestAutogradLogging": 0.011, "TestAutogradMultipleDispatchCUDA": 0.017000000000000005, "TestMultithreadAutograd": 0.17800000000000005, "TestNestedCheckpoint": 0.3370000000000001}, "test_autograd_fallback": {"TestAutogradFallback": 0.7300000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 189.847999999996}, "test_bundled_inputs": {"TestBundledInputs": 1.3209999999999995}, "test_comparison_utils": {"TestComparisonUtils": 0.635}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.507}, "test_content_store": {"TestContentStoreCUDA": 2.566}, "test_cpp_api_parity": {"TestCppApiParity": 8.663999999999989}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.6940000000000001, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.043}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.672, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.045}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 164.21699999999996}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.422}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.570000000000002}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.42}, "test_cuda": {"TestBlockStateAbsorption": 5.386, "TestCuda": 106.35100000000004, "TestCudaMallocAsync": 9.954000000000002, "TestCudaOptimsCUDA": 0.065}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.321000000000001, "TestCuda": 100.04699999999998, "TestCudaMallocAsync": 13.384, "TestCudaOptimsCUDA": 0.21500000000000005}, "test_cuda_multigpu": {"TestCudaComm": 0.023000000000000007, "TestCudaMultiGPU": 1.289}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.7670000000000003, "TestVisibleDeviceParses": 1.267}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.257}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.6950000000000001, "TestEventHandler": 0.02100000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 6.704}, "test_custom_ops": {"MiniOpTest": 0.5750000000000002, "MiniOpTestOther": 0.04400000000000001, "TestCustomOp": 2.2009999999999934, "TestCustomOpAPI": 0.10000000000000003, "TestCustomOpTestingCUDA": 1.778, "TestGenerateOpcheckTests": 2.801}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 85.233, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.026, "TestCustomPinFn": 0.094, "TestDataLoader": 73.29200000000003, "TestDataLoaderDeviceTypeCUDA": 11.957999999999998, "TestDataLoaderPersistentWorkers": 108.00200000000001, "TestDatasetRandomSplit": 0.442, "TestDictDataLoader": 0.033, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.003, "TestSetAffinity": 0.037, "TestStackDataset": 0.020000000000000004, "TestStringDataLoader": 0.048, "TestTensorDataset": 0.015000000000000001}, "test_datapipe": {"TestCaptureDataFrame": 0.003, "TestCircularSerialization": 0.008, "TestDataChunk": 0.433, "TestDataFramesPipes": 0.405, "TestFunctionalIterDataPipe": 3.180999999999999, "TestFunctionalMapDataPipe": 0.025999999999999995, "TestGraph": 0.010000000000000002, "TestIterDataPipeCountSampleYielded": 0.008, "TestIterDataPipeGraphFastForward": 0.042, "TestIterDataPipeSingletonConstraint": 0.016, "TestIterableDataPipeBasic": 0.024, "TestSerialization": 5.2170000000000005, "TestSharding": 0.21600000000000003, "TestStreamWrapper": 0.20500000000000002, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.032, "HasDecompTest": 0.128, "TestDecompCUDA": 12716.55400000004}, "test_deploy": {"TestFreezer": 0.635}, "test_dispatch": {"TestDispatch": 32.40700000000002, "TestPythonDispatcher": 0.028999999999999998}, "test_dlpack": {"TestTorchDlPackCUDA": 0.7390000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 1.848, "TestFloorDiv": 0.046000000000000006, "TestPySymInt": 1.2089999999999996, "TestSymNumberMagicMethods": 1.0759999999999992}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 2.4659999999999966, "TestExpandedWeightHelperFunctionCUDA": 0.447, "TestExpandedWeightModuleCUDA": 8.965000000000003}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.019, "FakeTensorDispatchCache": 0.06300000000000001, "FakeTensorOpInfoTestCUDA": 0.07300000000000001, "FakeTensorOperatorInvariants": 0.45100000000000007, "FakeTensorPropTest": 0.055999999999999994, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.5719999999999965, "PropagateRealTensorsFakeTensorConstHandling": 0.07, "PropagateRealTensorsFakeTensorConverterTest": 0.017, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.154, "PropagateRealTensorsFakeTensorPropTest": 0.042, "PropagateRealTensorsFakeTensorTest": 10.090000000000014}, "test_flop_counter": {"TestFlopCounter": 0.601}, "test_foreach": {"TestForeachCUDA": 400.1350000000087}, "test_function_schema": {"TestFunctionSchema": 0.881}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 16.348000000000003}, "test_functional_optim": {"TestFunctionalOptimParity": 0.29000000000000004}, "test_functionalization": {"TestCrossRefFunctionalization": 1.7089999999999987, "TestFunctionalization": 2.2489999999999983}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.309}, "test_futures": {"TestFuture": 1.25}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.20800000000000005, "TestCommonPass": 0.14200000000000007, "TestConstFold": 0.12100000000000004, "TestConstParamShapeInControlFlow": 0.031000000000000003, "TestDCE": 0.020999999999999998, "TestFX": 2.162999999999997, "TestFXAPIBackwardCompatibility": 0.02, "TestFunctionalTracing": 0.23000000000000018, "TestMatcher": 0.31900000000000006, "TestOperatorSignaturesCUDA": 0.6740000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.986, "TestSubgraphRewriter": 0.21600000000000008, "TestVisionTracing": 211.55100000000007, "TypeCheckerTest": 1.582999999999998}, "test_fx_experimental": {"TestFXExperimental": 11.343, "TestNormalizeOperatorsCUDA": 1.3150000000000008, "TestTranslationValidation": 0.11399999999999999}, "test_fx_passes": {"TestFXGraphPasses": 0.9310000000000002, "TestFXMatcherUtils": 0.06800000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.7670000000000001}, "test_import_stats": {"TestImportTime": 3.6020000000000003}, "test_indexing": {"NumpyTestsCUDA": 0.11300000000000002, "TestIndexingCUDA": 2.3829999999999933}, "test_itt": {"TestItt": 0.639}, "test_jit": {"TestAliasAnalysis": 0.262, "TestAsync": 0.24500000000000005, "TestAtenPow": 0.006, "TestAutodiffJit": 0.047, "TestAutodiffSubgraphSlicing": 0.20200000000000007, "TestAwait": 0.14700000000000002, "TestBackends": 0.502, "TestBackendsWithCompiler": 0.106, "TestBatchMM": 0.061000000000000006, "TestBuiltins": 0.042, "TestCUDA": 0.5720000000000001, "TestClassType": 1.8349999999999997, "TestComplex": 0.5930000000000001, "TestCustomOperators": 0.023000000000000007, "TestDCE": 0.013999999999999999, "TestDataParallel": 0.001, "TestDataclasses": 3.3899999999999997, "TestDeviceAnalysis": 3.07, "TestDict": 0.28600000000000014, "TestDtypeAnalysis": 0.11699999999999998, "TestEnum": 0.15100000000000002, "TestFreezing": 1.7670000000000001, "TestFrontend": 0.319, "TestFrozenOptimizations": 8.095999999999997, "TestFunctionalBlocks": 0.005, "TestFunctionalToInplaceActivation": 1.613, "TestGenerator": 0.047, "TestGetDefaultAttr": 0.012, "TestGraphRewritePasses": 0.029, "TestHash": 0.056, "TestHooks": 0.5040000000000002, "TestIgnorableArgs": 0.007, "TestIgnoreContextManager": 0.03, "TestInplaceToFunctionalActivation": 1.4869999999999999, "TestIsinstance": 0.14900000000000008, "TestJit": 4.157999999999998, "TestJitGeneratedModule": 8.028000000000016, "TestJitProfiler": 0.001, "TestJitUtils": 0.011000000000000003, "TestList": 0.8700000000000003, "TestLogging": 0.034, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.38800000000000007, "TestMixTracingScripting": 0.921, "TestModels": 4.268999999999999, "TestModuleAPIs": 0.094, "TestModuleContainers": 0.8720000000000003, "TestModuleInterface": 0.3690000000000001, "TestModules": 0.01, "TestNamedTuple": 0.04600000000000001, "TestNnapiBackend": 8.727, "TestOpDecompositions": 0.012, "TestOptimizeForMobilePreserveDebugInfo": 0.119, "TestParametrization": 0.062, "TestPeephole": 0.3330000000000002, "TestProducerVersion": 0.001, "TestProfiler": 0.443, "TestPythonBindings": 0.021, "TestPythonBuiltinOP": 0.264, "TestPythonIr": 0.016, "TestRecursiveScript": 0.49500000000000016, "TestRemoveMutation": 0.09100000000000001, "TestSaveLoad": 0.34600000000000003, "TestSaveLoadFlatbuffer": 0.41300000000000003, "TestSaveLoadForOpVersion": 1.8949999999999998, "TestScript": 30.946000000000048, "TestScriptDict": 0.017, "TestScriptList": 0.024, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.13200000000000006, "TestScriptProfile": 0.251, "TestSlice": 0.10600000000000002, "TestSparse": 0.033999999999999996, "TestStringFormatting": 0.08200000000000005, "TestSymbolicShapeAnalysis": 0.9150000000000001, "TestTensorBuiltins": 0.069, "TestTensorCreationOps": 0.036, "TestTensorMethods": 0.009000000000000001, "TestTorchbind": 0.12700000000000006, "TestTracer": 3.6519999999999944, "TestTypeSharing": 0.32800000000000007, "TestTypesAndAnnotation": 0.08800000000000001, "TestTyping": 0.27100000000000013, "TestUnion": 0.3190000000000002, "TestUnsupportedOps": 0.019, "TestUpgraders": 0.048, "TestWarn": 0.034999999999999996, "TestWith": 0.24299999999999997}, "test_jit_autocast": {"TestAutocast": 1.1339999999999997, "TestJitTraceAutocast": 25.412}, "test_jit_disabled": {"TestJitDisabled": 0.7230000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.116, "TestNNCOpInfoCUDA": 12.51300000000083, "TestTEFuserDynamic": 546.825, "TestTEFuserStatic": 493.7349999999999}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.056, "TestFusionPatternCUDA": 0.0, "TestModel": 0.004, "TestOpCUDA": 0.001}, "test_jiterator": {"TestPythonJiteratorCUDA": 19.481000000000027}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2759999999999985, "TestVmapBatchedGradientLegacyCUDA": 0.3560000000000001, "TestVmapOperatorsLegacy": 0.6830000000000002}, "test_license": {"TestLicense": 0.64}, "test_linalg": {"TestLinalgCUDA": 1507.6299999999896}, "test_logging": {"LoggingTest": 2.682}, "test_masked": {"TestMaskedCUDA": 31.925000000000033}, "test_maskedtensor": {"TestBasicsCUDA": 0.14800000000000002, "TestBinary": 0.2520000000000001, "TestOperatorsCUDA": 6.128999999999882, "TestReductions": 0.05600000000000001, "TestUnary": 0.6510000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.005, "TestMatmulCudaCUDA": 87.11300000000001, "TestMixedDtypesLinearCudaCUDA": 0.808}, "test_meta": {"TestMetaCUDA": 1620.4969999996022, "TestMetaConverter": 0.8300000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 3.686}, "test_mkldnn_fusion": {"TestMkldnnFusion": 33.125}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.532}, "test_mobile_optimizer": {"TestOptimizer": 2.643}, "test_model_dump": {"TestModelDump": 1.23}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.203}, "test_module_tracker": {"TestModuleTracker": 0.623}, "test_modules": {"TestModuleCUDA": 2515.2050000000236}, "test_monitor": {"TestMonitor": 0.642, "TestMonitorTensorboard": 0.342}, "test_multiprocessing": {"TestMultiprocessing": 85.909}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.523, "SpawnTest": 18.957}, "test_namedtensor": {"TestNamedTensor": 1.1049999999999998}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.982}, "test_native_functions": {"TestNativeFunctions": 0.7370000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.9540000000000004}, "test_nestedtensor": {"TestNestedTensor": 0.09400000000000004, "TestNestedTensorAutogradCUDA": 1.138, "TestNestedTensorDeviceTypeCUDA": 1.2929999999999964, "TestNestedTensorSubclassCUDA": 6.545999999999996}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.253, "TestFusionUtils": 0.004, "TestNN": 45.384000000000114, "TestNNDeviceTypeCUDA": 121.34700000000421, "TestUtils": 0.003}, "test_numba_integration": {"TestNumbaIntegration": 0.532}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.5880000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 3.9059999999999997}, "test_ops": {"TestCommonCUDA": 1732.3729999999955, "TestCompositeComplianceCUDA": 696.8039999999971, "TestFakeTensorCUDA": 529.5719999999988, "TestMathBitsCUDA": 54.26700000000007, "TestSelfKwarg": 0.376, "TestTagsCUDA": 1.5950000000000009}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 513.8009999999987}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1797.2929999998946}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.017, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.003, "TestResolveName": 0.096, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 2.1329999999998908, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.021, "TestPythonDispatch": 0.19400000000000006, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2589999999999997, "TestWrapperSubclassAliasingCUDA": 0.10500000000000004}, "test_reductions": {"TestReductionsCUDA": 131.65800000000232}, "test_serialization": {"TestSerialization": 5.851}, "test_show_pickle": {"TestShowPickle": 0.64}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.978999999999995}, "test_spectral_ops": {"TestFFTCUDA": 18.755999999999954}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4230000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.13000000000000003, "TestTensorCreationCUDA": 80.61100000000027}, "test_tensorexpr": {"TestTensorExprFuser": 112.79300000000006}, "test_torch": {"TestBasicVitalSigns": 0.020999999999999998, "TestDevicePrecisionCUDA": 0.056000000000000015, "TestTorch": 4.650999999999989, "TestTorchDeviceTypeCUDA": 82.386, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.052, "TestBottleneck": 9.913, "TestCheckpoint": 0.30200000000000005, "TestCollectEnv": 0.968, "TestCppExtensionUtils": 0.03, "TestDataLoaderUtils": 0.27, "TestDeviceUtilsCUDA": 11.739000000000578, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.005, "TestONNXUtils": 0.003, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.218, "TestTraceback": 0.006}}, "aot_eager_torchbench": {"backends/xeon/test_launch": {"TestTorchrun": 2.1109999999999998}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.151}, "distributions/test_distributions": {"TestAgainstScipy": 1.0379999999999998, "TestConstraints": 0.126, "TestDistributionShapes": 0.10700000000000005, "TestDistributions": 43.753, "TestFunctors": 0.007, "TestJit": 19.299, "TestKL": 2.582, "TestLazyLogitsInitialization": 0.011, "TestNumericalStability": 0.05900000000000001, "TestRsample": 0.609, "TestValidation": 0.31300000000000006}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.375999999999994}, "dynamo/test_after_aot": {"TestAfterAot": 4.739999999999999}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 12.959999999999999}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9730000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.285999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.031, "TestCustomBackendAPI": 1.6579999999999997, "TestExplainWithBackend": 9.787, "TestOptimizations": 1.7369999999999999}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.513}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 5.858, "BytecodeTests": 0.453}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.54, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.5670000000000001}, "dynamo/test_config": {"ConfigTests": 0.548}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.0500000000000003}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.363}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.299}, "dynamo/test_decorators": {"DecoratorTests": 0.6350000000000001}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.013}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 23.795000000000005, "DynamicShapesCtxManagerTests": 4.135, "DynamicShapesExportTests": 1288.693, "DynamicShapesFuncTorchHigherOrderOpTests": 96.21499999999997, "DynamicShapesFunctionTests": 16.406000000000002, "DynamicShapesHigherOrderOpTests": 14.990999999999998, "DynamicShapesMiscTests": 44.32100000000001, "DynamicShapesNNModuleTests": 2.6550000000000007, "DynamicShapesReproTests": 25.61, "DynamicShapesSubGraphTests": 8.865999999999996, "DynamicShapesTestSDPA": 0.32}, "dynamo/test_exc": {"ExcTests": 1.8259999999999998}, "dynamo/test_export": {"ExportTests": 13.653999999999998}, "dynamo/test_export_mutations": {"MutationExportTests": 0.525}, "dynamo/test_frame_init": {"FrameInitTests": 0.201}, "dynamo/test_functions": {"DefaultsTests": 0.6680000000000001, "FunctionTests": 19.680999999999997}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.126}, "dynamo/test_global": {"TestGlobals": 0.4930000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.232}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.204000000000001, "FuncTorchHigherOrderOpTests": 9.528999999999996, "HigherOrderOpTests": 6.860000000000001, "HigherOrderOpVmapGuardTests": 3.5920000000000005}, "dynamo/test_hooks": {"HooksTests": 22.988000000000003}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.4239999999999995}, "dynamo/test_interop": {"InteropTests": 0.5459999999999999}, "dynamo/test_logging": {"LoggingTests": 18.322}, "dynamo/test_minifier": {"MinifierTests": 2.067}, "dynamo/test_misc": {"MiscTests": 46.84300000000007, "TestTracer": 0.048}, "dynamo/test_model_output": {"TestHFPretrained": 0.429, "TestModelOutput": 0.23000000000000004}, "dynamo/test_modules": {"NNModuleTests": 2.5769999999999986, "OptimizedModuleTest": 7.764999999999997}, "dynamo/test_nops": {"NopTests": 0.28600000000000003}, "dynamo/test_optimizers": {"End2EndTests": 0.611}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.47300000000000003}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.2299999999999998}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.615}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.8060000000000002}, "dynamo/test_recompiles": {"RecompileTests": 0.7850000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.526}, "dynamo/test_repros": {"ReproTests": 29.281000000000006}, "dynamo/test_resume": {"ResumeFunctionTests": 0.444}, "dynamo/test_sdpa": {"TestSDPA": 0.452}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.5850000000000001}, "dynamo/test_sources": {"SourceTests": 0.474}, "dynamo/test_structured_trace": {"StructuredTraceTest": 14.020000000000001}, "dynamo/test_subclasses": {"SubclassTests": 2.6669999999999994, "TestNestedTensor": 12.775000000000004}, "dynamo/test_subgraphs": {"SubGraphTests": 1.959999999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.097, "TraceRuleTests": 1.142}, "dynamo/test_unspec": {"UnspecTests": 10.358999999999996}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.552}, "export/test_converter": {"TestConverter": 0.282}, "export/test_db": {"ExampleTests": 2.698}, "export/test_experimental": {"TestExperiment": 0.891}, "export/test_export": {"TestDynamismExpression": 0.454, "TestExport": 23.571999999999996, "TestExportCustomClass": 0.060000000000000005, "TestOneOffModelExportResult": 1.194}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.36199999999999993, "NonStrictExportTestExport": 20.189999999999998}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.656}, "export/test_hop": {"TestHOPCUDA": 1.636, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.079}, "export/test_pass_infra": {"TestPassInfra": 0.8220000000000002}, "export/test_passes": {"TestPasses": 10.800999999999998}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.7489999999999999, "RetraceExportTestExport": 34.87800000000001}, "export/test_schema": {"TestSchema": 0.23700000000000002}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.493, "SerDesExportTestExport": 23.06200000000001}, "export/test_serialize": {"TestDeserialize": 6.831000000000003, "TestSaveLoad": 0.255, "TestSchemaVersioning": 0.026, "TestSerialize": 0.9890000000000001, "TestSerializeCustomClass": 0.075}, "export/test_sparse": {"TestSparseProp": 51.943999999999875}, "export/test_tools": {"TestExportTools": 0.535}, "export/test_torchbind": {"TestCompileTorchbind": 0.462, "TestExportTorchbind": 2.0049999999999994, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.207}, "export/test_unflatten": {"TestUnflatten": 2.9090000000000003}, "export/test_verifier": {"TestVerifier": 0.9000000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.496999999999996, "TestAOTDispatch": 0.44, "TestAOTExport": 1.8920000000000001, "TestAOTModuleSimplified": 0.5630000000000001, "TestPartitioning": 3.1559999999999997}, "functorch/test_control_flow": {"TestControlFlow": 0.7420000000000002, "TestControlFlowTraced": 108.54000000000012}, "functorch/test_dims": {"TestMin": 12.960999999999997, "TestMinFunctorchOnly": 12.395}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.07300000000000004, "TestAutogradFunctionVmapAPICUDA": 0.016, "TestCompileTransformsCUDA": 4.379, "TestComposabilityCUDA": 0.13800000000000004, "TestExamplesCorrectnessCUDA": 2.0519999999999996, "TestFunctionalizeCUDA": 0.09500000000000003, "TestGradTransformCUDA": 0.8740000000000001, "TestHelpersCUDA": 0.009000000000000001, "TestHessianCUDA": 0.056, "TestHigherOrderOperatorInteractionCUDA": 0.021000000000000005, "TestJacCUDA": 0.7190000000000002, "TestJvpCUDA": 0.04600000000000001, "TestLinearizeCUDA": 0.23699999999999996, "TestMakeFunctional": 0.06100000000000001, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.6000000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.241}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.279, "RandomOpTestCase": 0.07, "ReduceTestCase": 0.064, "TestMemoryEfficientOpAuthoring": 7.207000000000001}, "functorch/test_minifier": {"TestMinifier": 0.3750000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 4098.133999999959}, "functorch/test_parsing": {"TestAnonymousAxis": 0.61, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.647}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6880000000000005, "TestTransformFailureCUDA": 0.092, "TestVmapAPI": 0.759, "TestVmapBatchedGradientCUDA": 0.17300000000000007, "TestVmapDeviceTypeCUDA": 0.018000000000000002, "TestVmapNestedTensorCUDA": 0.034, "TestVmapOperators": 2.2229999999999968, "TestVmapOperatorsOpInfoCUDA": 265.7999999999994}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.422999999999857}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.790000000000001}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 671.8869999999996, "AOTInductorTestABICompatibleCpuWithStackAllocation": 452.6049999999998, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 193.24600000000004, "AOTInductorTestABICompatibleCuda": 1281.288, "AOTInductorTestNonABICompatibleCpu": 1374.5149999999996, "AOTInductorTestNonABICompatibleCuda": 2064.2209999999995}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.729, "BenchmarkFusionCudaTest": 79.013, "BenchmarkMultiTemplateFusionCudaTest": 14.515}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.855, "FreezingCudaTests": 4.867}, "inductor/test_codecache": {"TestFxGraphCache": 119.11499999999998, "TestFxGraphCacheHashing": 0.761, "TestUtils": 3.369, "test_codecache": 3.646}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.209}, "inductor/test_compile_worker": {"TestCompileWorker": 5.074}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 207.84100000000083, "TestCompiledAutograd": 157.82900000000006, "TestCustomOpWithCompiledAutograd": 0.3290000000000002}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 646.989, "CompiledOptimizerTests": 1352.7049999999988}, "inductor/test_config": {"TestInductorConfig": 5.281000000000001}, "inductor/test_control_flow": {"CondTests": 84.43200000000002, "WhileLoopTests": 34.936}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.097}, "inductor/test_cpu_repro": {"CPUReproTests": 634.4519999999997}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1029.6299999999999, "TestCudaWrapper": 978.8380000000002}, "inductor/test_cuda_repro": {"CudaReproTests": 79.04399999999998}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 69.221}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.5309999999999997}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.284}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 127.94600000000001}, "inductor/test_debug_trace": {"TestDebugTrace": 13.411999999999999}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.55799999999999}, "inductor/test_dependencies": {"TestDependencies": 0.21100000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.141}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 184.648, "EfficientConvBNEvalCudaTests": 119.044}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.721}, "inductor/test_flex_attention": {"TestFlexAttention": 407.5859999999999}, "inductor/test_foreach": {"ForeachTests": 294.94500000000005}, "inductor/test_fp8": {"TestFP8Types": 0.009000000000000001}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 74.61, "SDPAPatternRewriterCpuTests": 67.805, "SDPAPatternRewriterCudaDynamicTests": 40.459, "SDPAPatternRewriterCudaTests": 32.667}, "inductor/test_fx_fusion": {"TestFxFusion": 0.16999999999999998}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023, "TestGroupBatchFusion": 105.10300000000001, "TestPostGradBatchLinearFusion": 1.914}, "inductor/test_indexing": {"ExprPrinterTests": 0.049000000000000016, "TestIndexingSimplification": 0.521}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 47.679, "FreezingCudaTests": 33.351}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 6.901999999999999}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 123.53500000000001}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.370000000000001}, "inductor/test_max_autotune": {"TestMaxAutotune": 231.59300000000005, "TestTuningProcess": 9.876}, "inductor/test_memory_planning": {"TestMemoryPlanning": 28.843}, "inductor/test_metrics": {"TestMetrics": 3.7310000000000003}, "inductor/test_minifier": {"MinifierTests": 27.743000000000002}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 89.477}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 80.14499999999998, "TestPatternMatcher": 391.7189999999999}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.152999999999999}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.815}, "inductor/test_multi_kernel": {"MultiKernelTest": 72.303}, "inductor/test_pad_mm": {"PadMMTest": 125.19800000000002}, "inductor/test_padding": {"PaddingTest": 14.432000000000002, "PerfTestBetweenGoodAndBadShape": 0.004, "PerfTestWithAndWithoutPadding": 4.479}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 92.172}, "inductor/test_perf": {"FusionTests": 13.812000000000001, "InplacingTests": 5.811999999999999, "MinCutPartitioningTests": 10.806, "NoopTests": 0.932, "NumBytesMetricTests": 25.239, "SchedulerFusionTests": 8.591000000000001, "TilingTests": 1.927}, "inductor/test_profiler": {"DynamoProfilerTests": 7.7909999999999995}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 113.89200000000001}, "inductor/test_smoke": {"SmokeTest": 6.015}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.785, "MemoryBoundedTests": 3.1189999999999998, "TestCommAnalysis": 6.468000000000001, "UnsupportedTests": 0.314}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 98.97900000000001}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.533}, "inductor/test_torchbind": {"TestTorchbind": 6.302}, "inductor/test_torchinductor": {"CpuTests": 1495.638, "GPUTests": 876.7949999999998, "NanCheckerTest": 0.875, "RNNTest": 0.017, "SweepInputsCpuTest": 111.87900000000002, "SweepInputsGPUTest": 28.955999999999996, "TestFull": 10.124, "TritonCodeGenTests": 177.36599999999999}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1622.9139999999993, "DynamicShapesCodegenGPUTests": 989.0759999999991}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1714.3149999999998, "DynamicShapesGPUTests": 1325.7119999999995, "TestInductorDynamicCUDA": 42.036}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1644.9859999999999}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.521}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.005}, "inductor/test_triton_kernels": {"KernelTests": 93.85299999999998, "MutationTests": 0.3080000000000001}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 7.126}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 19.222}, "inductor/test_utils": {"TestUtils": 0.206}, "lazy/test_debug_util": {"DebugUtilTest": 0.672}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.705}, "lazy/test_generator": {"LazyGeneratorTest": 0.701}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.8220000000000001}, "lazy/test_step_closures": {"ClosuresTest": 2.642}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.171, "TestLazyTensor": 0.539}, "nn/test_convolution": {"TestConvolutionNN": 20.689, "TestConvolutionNNDeviceTypeCUDA": 51.31799999999948}, "nn/test_dropout": {"TestDropoutNN": 0.541, "TestDropoutNNDeviceTypeCUDA": 0.526}, "nn/test_embedding": {"TestEmbeddingNN": 0.537, "TestEmbeddingNNDeviceTypeCUDA": 10.239000000000006}, "nn/test_init": {"TestNNInit": 3.9079999999999986}, "nn/test_lazy_modules": {"TestLazyModules": 0.8040000000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.013, "TestLoadStateDictSwap": 0.044}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.015, "TestModuleHookNN": 0.04700000000000001, "TestModuleHooks": 0.556, "TestStateDictHooks": 0.011000000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 5.081000000000001, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.23000000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.112}, "nn/test_parametrization": {"TestNNParametrization": 1.194999999999999, "TestNNParametrizationDeviceCUDA": 0.138}, "nn/test_pooling": {"TestAvgPool": 0.666, "TestPoolingNN": 0.67, "TestPoolingNNDeviceTypeCUDA": 4.507999999999998}, "nn/test_pruning": {"TestPruningNN": 0.502}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.213}, "profiler/test_memory_profiler": {"TestDataFlow": 1.031, "TestIdentifyGradients": 0.24200000000000005, "TestMemoryProfiler": 0.638, "TestMemoryProfilerE2E": 2.5569999999999995}, "profiler/test_profiler": {"TestExperimentalUtils": 3.8649999999999998, "TestProfiler": 18.549999999999997, "TestProfilerCUDA": 5.618, "TestProfilerITT": 0.002}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.708}, "profiler/test_record_function": {"TestRecordFunction": 0.682}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.7299999999999995}, "test_ao_sparsity": {"TestActivationSparsifier": 0.056, "TestBaseDataScheduler": 0.026000000000000002, "TestBaseDataSparsifier": 0.056, "TestBaseSparsifier": 0.020000000000000004, "TestBaseStructuredSparsifier": 2.5659999999999994, "TestComposability": 1.868, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.061, "TestFakeSparsity": 0.057, "TestFxComposability": 1.372, "TestNearlyDiagonalSparsifier": 0.644, "TestNormDataSparsifiers": 0.732, "TestQuantizationUtils": 0.015, "TestQuantizedSparseKernels": 0.329, "TestQuantizedSparseLayers": 0.29000000000000004, "TestSaliencyPruner": 0.03, "TestScheduler": 0.01, "TestSparsityUtilFunctions": 0.027999999999999997, "TestWeightNormSparsifier": 0.23800000000000002}, "test_autocast": {"TestAutocastCPU": 1.9489999999999996, "TestAutocastGPU": 0.196, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.021000000000000005, "TestAutograd": 15.397999999999987, "TestAutogradComplex": 0.004, "TestAutogradDeviceTypeCUDA": 2.3989999999999987, "TestAutogradForwardMode": 0.04800000000000002, "TestAutogradForwardModeBatchedGrad": 0.012, "TestAutogradFunctional": 8.63, "TestAutogradInferenceMode": 0.021000000000000008, "TestAutogradLogging": 0.012, "TestAutogradMultipleDispatchCUDA": 0.017000000000000005, "TestMultithreadAutograd": 0.17300000000000004, "TestNestedCheckpoint": 0.3510000000000001}, "test_autograd_fallback": {"TestAutogradFallback": 0.752}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 192.9829999999896}, "test_bundled_inputs": {"TestBundledInputs": 1.4449999999999996}, "test_comparison_utils": {"TestComparisonUtils": 0.646}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.51}, "test_content_store": {"TestContentStoreCUDA": 2.5349999999999997}, "test_cpp_api_parity": {"TestCppApiParity": 8.48799999999999}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.7010000000000001, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.043}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.664, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.046}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 167.20499999999998}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.43}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.548000000000002}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.429}, "test_cuda": {"TestBlockStateAbsorption": 5.402, "TestCuda": 105.67700000000008, "TestCudaMallocAsync": 10.203000000000001, "TestCudaOptimsCUDA": 0.065}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.51, "TestCuda": 100.126, "TestCudaMallocAsync": 13.478999999999997, "TestCudaOptimsCUDA": 0.114}, "test_cuda_multigpu": {"TestCudaComm": 0.022000000000000006, "TestCudaMultiGPU": 1.288}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.8059999999999996, "TestVisibleDeviceParses": 1.286}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.281}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.672, "TestEventHandler": 0.02000000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 6.864}, "test_custom_ops": {"MiniOpTest": 0.5750000000000002, "MiniOpTestOther": 0.04400000000000001, "TestCustomOp": 2.198999999999993, "TestCustomOpAPI": 0.10200000000000004, "TestCustomOpTestingCUDA": 1.8270000000000002, "TestGenerateOpcheckTests": 2.9219999999999997}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 84.867, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.027, "TestCustomPinFn": 0.098, "TestDataLoader": 78.56600000000003, "TestDataLoaderDeviceTypeCUDA": 12.029, "TestDataLoaderPersistentWorkers": 98.71200000000002, "TestDatasetRandomSplit": 0.48000000000000004, "TestDictDataLoader": 0.032, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.003, "TestSetAffinity": 0.038, "TestStackDataset": 0.021000000000000005, "TestStringDataLoader": 0.047, "TestTensorDataset": 0.016}, "test_datapipe": {"TestCaptureDataFrame": 0.003, "TestCircularSerialization": 0.007, "TestDataChunk": 0.453, "TestDataFramesPipes": 0.4, "TestFunctionalIterDataPipe": 3.3409999999999993, "TestFunctionalMapDataPipe": 0.026999999999999996, "TestGraph": 0.012000000000000002, "TestIterDataPipeCountSampleYielded": 0.006, "TestIterDataPipeGraphFastForward": 0.036000000000000004, "TestIterDataPipeSingletonConstraint": 0.018000000000000002, "TestIterableDataPipeBasic": 0.022, "TestSerialization": 5.2010000000000005, "TestSharding": 0.19, "TestStreamWrapper": 0.20700000000000002, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.032, "HasDecompTest": 0.129, "TestDecompCUDA": 12470.114000000038}, "test_deploy": {"TestFreezer": 0.649}, "test_dispatch": {"TestDispatch": 32.46400000000001, "TestPythonDispatcher": 0.028999999999999998}, "test_dlpack": {"TestTorchDlPackCUDA": 0.7740000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 1.795, "TestFloorDiv": 0.046000000000000006, "TestPySymInt": 1.1929999999999996, "TestSymNumberMagicMethods": 1.080999999999999}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 2.5479999999999974, "TestExpandedWeightHelperFunctionCUDA": 0.46, "TestExpandedWeightModuleCUDA": 9.064}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.018, "FakeTensorDispatchCache": 0.06300000000000001, "FakeTensorOpInfoTestCUDA": 0.07300000000000001, "FakeTensorOperatorInvariants": 0.457, "FakeTensorPropTest": 0.05499999999999999, "FakeTensorSerialization": 0.004, "FakeTensorTest": 8.796000000000005, "PropagateRealTensorsFakeTensorConstHandling": 0.068, "PropagateRealTensorsFakeTensorConverterTest": 0.017, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.154, "PropagateRealTensorsFakeTensorPropTest": 0.041, "PropagateRealTensorsFakeTensorTest": 10.004000000000012}, "test_flop_counter": {"TestFlopCounter": 0.603}, "test_foreach": {"TestForeachCUDA": 398.033000000008}, "test_function_schema": {"TestFunctionSchema": 0.904}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 16.931}, "test_functional_optim": {"TestFunctionalOptimParity": 0.30000000000000004}, "test_functionalization": {"TestCrossRefFunctionalization": 1.762999999999999, "TestFunctionalization": 2.2749999999999986}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.317}, "test_futures": {"TestFuture": 1.281}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.20200000000000004, "TestCommonPass": 0.14400000000000004, "TestConstFold": 0.12100000000000004, "TestConstParamShapeInControlFlow": 0.031000000000000003, "TestDCE": 0.020999999999999998, "TestFX": 2.255999999999998, "TestFXAPIBackwardCompatibility": 0.02, "TestFunctionalTracing": 0.2420000000000002, "TestMatcher": 0.31600000000000006, "TestOperatorSignaturesCUDA": 0.6760000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.962, "TestSubgraphRewriter": 0.2220000000000001, "TestVisionTracing": 213.5499999999999, "TypeCheckerTest": 1.5749999999999977}, "test_fx_experimental": {"TestFXExperimental": 11.744000000000002, "TestNormalizeOperatorsCUDA": 1.3090000000000008, "TestTranslationValidation": 0.11099999999999999}, "test_fx_passes": {"TestFXGraphPasses": 0.9210000000000002, "TestFXMatcherUtils": 0.06500000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.7990000000000002}, "test_import_stats": {"TestImportTime": 3.727}, "test_indexing": {"NumpyTestsCUDA": 0.125, "TestIndexingCUDA": 2.482999999999997}, "test_itt": {"TestItt": 0.653}, "test_jit": {"TestAliasAnalysis": 0.256, "TestAsync": 0.24600000000000005, "TestAtenPow": 0.006, "TestAutodiffJit": 0.048, "TestAutodiffSubgraphSlicing": 0.20800000000000007, "TestAwait": 0.15100000000000002, "TestBackends": 0.51, "TestBackendsWithCompiler": 0.107, "TestBatchMM": 0.059000000000000004, "TestBuiltins": 0.042, "TestCUDA": 0.632, "TestClassType": 1.9069999999999996, "TestComplex": 0.5880000000000001, "TestCustomOperators": 0.026000000000000006, "TestDCE": 0.013000000000000001, "TestDataParallel": 0.001, "TestDataclasses": 3.2800000000000002, "TestDeviceAnalysis": 2.976, "TestDict": 0.29000000000000015, "TestDtypeAnalysis": 0.111, "TestEnum": 0.13700000000000004, "TestFreezing": 1.8400000000000005, "TestFrontend": 0.342, "TestFrozenOptimizations": 8.125999999999998, "TestFunctionalBlocks": 0.005, "TestFunctionalToInplaceActivation": 1.6600000000000001, "TestGenerator": 0.046, "TestGetDefaultAttr": 0.012, "TestGraphRewritePasses": 0.03, "TestHash": 0.051, "TestHooks": 0.4840000000000002, "TestIgnorableArgs": 0.007, "TestIgnoreContextManager": 0.031, "TestInplaceToFunctionalActivation": 1.553, "TestIsinstance": 0.14400000000000007, "TestJit": 4.099999999999994, "TestJitGeneratedModule": 8.170999999999987, "TestJitProfiler": 0.001, "TestJitUtils": 0.010000000000000002, "TestList": 0.9180000000000004, "TestLogging": 0.036, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.37600000000000006, "TestMixTracingScripting": 0.9420000000000001, "TestModels": 4.3629999999999995, "TestModuleAPIs": 0.09, "TestModuleContainers": 0.8510000000000001, "TestModuleInterface": 0.35100000000000015, "TestModules": 0.01, "TestNamedTuple": 0.047000000000000014, "TestNnapiBackend": 8.840999999999998, "TestOpDecompositions": 0.012, "TestOptimizeForMobilePreserveDebugInfo": 0.124, "TestParametrization": 0.065, "TestPeephole": 0.3170000000000001, "TestProducerVersion": 0.001, "TestProfiler": 0.435, "TestPythonBindings": 0.02, "TestPythonBuiltinOP": 0.259, "TestPythonIr": 0.015, "TestRecursiveScript": 0.5130000000000001, "TestRemoveMutation": 0.08900000000000001, "TestSaveLoad": 0.339, "TestSaveLoadFlatbuffer": 0.41100000000000003, "TestSaveLoadForOpVersion": 1.7919999999999998, "TestScript": 32.48400000000002, "TestScriptDict": 0.014000000000000002, "TestScriptList": 0.023, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.13000000000000006, "TestScriptProfile": 0.252, "TestSlice": 0.10800000000000003, "TestSparse": 0.03, "TestStringFormatting": 0.08000000000000004, "TestSymbolicShapeAnalysis": 0.9400000000000002, "TestTensorBuiltins": 0.07300000000000001, "TestTensorCreationOps": 0.032, "TestTensorMethods": 0.008, "TestTorchbind": 0.13500000000000006, "TestTracer": 3.5509999999999944, "TestTypeSharing": 0.3440000000000001, "TestTypesAndAnnotation": 0.08600000000000001, "TestTyping": 0.26600000000000007, "TestUnion": 0.29600000000000015, "TestUnsupportedOps": 0.02, "TestUpgraders": 0.047, "TestWarn": 0.034, "TestWith": 0.22999999999999998}, "test_jit_autocast": {"TestAutocast": 1.14, "TestJitTraceAutocast": 26.116}, "test_jit_disabled": {"TestJitDisabled": 0.7390000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.113, "TestNNCOpInfoCUDA": 12.498000000000834, "TestTEFuserDynamic": 544.3759999999999, "TestTEFuserStatic": 489.8809999999999}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.057, "TestFusionPatternCUDA": 0.0, "TestModel": 0.004, "TestOpCUDA": 0.0}, "test_jiterator": {"TestPythonJiteratorCUDA": 19.549999999999997}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2969999999999984, "TestVmapBatchedGradientLegacyCUDA": 0.3580000000000001, "TestVmapOperatorsLegacy": 0.7080000000000001}, "test_license": {"TestLicense": 0.649}, "test_linalg": {"TestLinalgCUDA": 1512.4719999999895}, "test_logging": {"LoggingTest": 2.696}, "test_masked": {"TestMaskedCUDA": 38.443000000000005}, "test_maskedtensor": {"TestBasicsCUDA": 0.17400000000000002, "TestBinary": 0.24900000000000014, "TestOperatorsCUDA": 5.867999999999924, "TestReductions": 0.05500000000000001, "TestUnary": 0.6240000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.006, "TestMatmulCudaCUDA": 86.70899999999999, "TestMixedDtypesLinearCudaCUDA": 0.772}, "test_meta": {"TestMetaCUDA": 1644.9849999996343, "TestMetaConverter": 0.8410000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 4.4190000000000005}, "test_mkldnn_fusion": {"TestMkldnnFusion": 33.129000000000005}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.7199999999999998}, "test_mobile_optimizer": {"TestOptimizer": 2.521}, "test_model_dump": {"TestModelDump": 1.2149999999999999}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.211}, "test_module_tracker": {"TestModuleTracker": 0.65}, "test_modules": {"TestModuleCUDA": 2585.7570000000205}, "test_monitor": {"TestMonitor": 0.663, "TestMonitorTensorboard": 0.403}, "test_multiprocessing": {"TestMultiprocessing": 86.254}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.489, "SpawnTest": 19.105000000000004}, "test_namedtensor": {"TestNamedTensor": 1.139999999999998}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.0020000000000002}, "test_native_functions": {"TestNativeFunctions": 0.7700000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.9570000000000004}, "test_nestedtensor": {"TestNestedTensor": 0.11600000000000006, "TestNestedTensorAutogradCUDA": 1.118, "TestNestedTensorDeviceTypeCUDA": 1.312999999999997, "TestNestedTensorSubclassCUDA": 6.746999999999995}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.257, "TestFusionUtils": 0.004, "TestNN": 45.42300000000008, "TestNNDeviceTypeCUDA": 123.1680000000042, "TestUtils": 0.003}, "test_numba_integration": {"TestNumbaIntegration": 0.562}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.5840000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 3.948}, "test_ops": {"TestCommonCUDA": 1717.2999999999886, "TestCompositeComplianceCUDA": 679.0329999999979, "TestFakeTensorCUDA": 528.3329999999983, "TestMathBitsCUDA": 46.26100000000007, "TestSelfKwarg": 0.394, "TestTagsCUDA": 1.6090000000000009}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 512.1880000000031}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1761.9459999998987}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.016, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.006, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.003, "TestResolveName": 0.093, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 2.15099999999989, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.024, "TestPythonDispatch": 0.18400000000000008, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.255, "TestWrapperSubclassAliasingCUDA": 0.10400000000000004}, "test_reductions": {"TestReductionsCUDA": 135.2930000000027}, "test_serialization": {"TestSerialization": 5.867}, "test_show_pickle": {"TestShowPickle": 0.66}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.915999999999996}, "test_spectral_ops": {"TestFFTCUDA": 18.66199999999997}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4210000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.12900000000000003, "TestTensorCreationCUDA": 76.8540000000003}, "test_tensorexpr": {"TestTensorExprFuser": 114.18600000000002}, "test_torch": {"TestBasicVitalSigns": 0.022, "TestDevicePrecisionCUDA": 0.05400000000000002, "TestTorch": 4.809999999999989, "TestTorchDeviceTypeCUDA": 83.43900000000005, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.051000000000000004, "TestBottleneck": 9.789, "TestCheckpoint": 0.30000000000000004, "TestCollectEnv": 0.983, "TestCppExtensionUtils": 0.027999999999999997, "TestDataLoaderUtils": 0.29200000000000004, "TestDeviceUtilsCUDA": 11.756000000000586, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.005, "TestONNXUtils": 0.003, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.217, "TestTraceback": 0.006}}, "dynamic_aot_eager_huggingface": {"backends/xeon/test_launch": {"TestTorchrun": 2.041}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.254}, "distributions/test_distributions": {"TestAgainstScipy": 1.046, "TestConstraints": 0.12, "TestDistributionShapes": 0.10600000000000007, "TestDistributions": 43.53, "TestFunctors": 0.007, "TestJit": 18.971, "TestKL": 2.5529999999999995, "TestLazyLogitsInitialization": 0.009000000000000001, "TestNumericalStability": 0.05700000000000001, "TestRsample": 0.601, "TestValidation": 0.28900000000000003}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.144000000000005}, "dynamo/test_after_aot": {"TestAfterAot": 4.873}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.240000000000006}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9520000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.595}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.032, "TestCustomBackendAPI": 1.6949999999999998, "TestExplainWithBackend": 8.57, "TestOptimizations": 1.7689999999999995}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 11.807}, "dynamo/test_base_output": {"TestBaseOutput": 0.002}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.407, "BytecodeTests": 0.439}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.566, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.5730000000000001}, "dynamo/test_config": {"ConfigTests": 0.589}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.0699999999999994}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.6839999999999997}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.315}, "dynamo/test_decorators": {"DecoratorTests": 0.7330000000000002}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.014}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 23.181, "DynamicShapesCtxManagerTests": 4.156, "DynamicShapesExportTests": 1287.7799999999997, "DynamicShapesFuncTorchHigherOrderOpTests": 96.44499999999995, "DynamicShapesFunctionTests": 16.48099999999999, "DynamicShapesHigherOrderOpTests": 15.090999999999989, "DynamicShapesMiscTests": 45.104999999999976, "DynamicShapesNNModuleTests": 2.708, "DynamicShapesReproTests": 25.817999999999998, "DynamicShapesSubGraphTests": 8.934999999999999, "DynamicShapesTestSDPA": 0.323}, "dynamo/test_exc": {"ExcTests": 1.7979999999999998}, "dynamo/test_export": {"ExportTests": 13.903999999999995}, "dynamo/test_export_mutations": {"MutationExportTests": 0.543}, "dynamo/test_frame_init": {"FrameInitTests": 0.205}, "dynamo/test_functions": {"DefaultsTests": 0.6780000000000002, "FunctionTests": 19.83100000000002}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.153}, "dynamo/test_global": {"TestGlobals": 0.522}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.23900000000000002}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.4300000000000015, "FuncTorchHigherOrderOpTests": 9.665000000000001, "HigherOrderOpTests": 6.877, "HigherOrderOpVmapGuardTests": 3.594}, "dynamo/test_hooks": {"HooksTests": 23.534000000000002}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.452999999999999}, "dynamo/test_interop": {"InteropTests": 0.5469999999999999}, "dynamo/test_logging": {"LoggingTests": 18.686000000000003}, "dynamo/test_minifier": {"MinifierTests": 2.064}, "dynamo/test_misc": {"MiscTests": 47.67700000000011, "TestTracer": 0.049}, "dynamo/test_model_output": {"TestHFPretrained": 0.423, "TestModelOutput": 0.22600000000000003}, "dynamo/test_modules": {"NNModuleTests": 2.6349999999999976, "OptimizedModuleTest": 7.890999999999998}, "dynamo/test_nops": {"NopTests": 0.294}, "dynamo/test_optimizers": {"End2EndTests": 0.634}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.47600000000000003}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.268}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.6100000000000001}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.8520000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.8580000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.521}, "dynamo/test_repros": {"ReproTests": 29.562000000000037}, "dynamo/test_resume": {"ResumeFunctionTests": 0.42}, "dynamo/test_sdpa": {"TestSDPA": 0.47800000000000004}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.6}, "dynamo/test_sources": {"SourceTests": 0.48}, "dynamo/test_structured_trace": {"StructuredTraceTest": 14.29}, "dynamo/test_subclasses": {"SubclassTests": 2.723999999999999, "TestNestedTensor": 13.017000000000001}, "dynamo/test_subgraphs": {"SubGraphTests": 1.9799999999999993}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.098, "TraceRuleTests": 1.178}, "dynamo/test_unspec": {"UnspecTests": 10.607000000000001}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.5650000000000001}, "export/test_converter": {"TestConverter": 0.306}, "export/test_db": {"ExampleTests": 2.7099999999999995}, "export/test_experimental": {"TestExperiment": 0.89}, "export/test_export": {"TestDynamismExpression": 0.425, "TestExport": 23.517999999999997, "TestExportCustomClass": 0.057, "TestOneOffModelExportResult": 1.205}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.356, "NonStrictExportTestExport": 21.505999999999993}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.639}, "export/test_hop": {"TestHOPCUDA": 1.6509999999999998, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.079}, "export/test_pass_infra": {"TestPassInfra": 0.8220000000000002}, "export/test_passes": {"TestPasses": 11.062999999999999}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.7529999999999999, "RetraceExportTestExport": 35.228}, "export/test_schema": {"TestSchema": 0.24}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.497, "SerDesExportTestExport": 23.318999999999996}, "export/test_serialize": {"TestDeserialize": 6.796999999999999, "TestSaveLoad": 0.256, "TestSchemaVersioning": 0.027, "TestSerialize": 0.9830000000000001, "TestSerializeCustomClass": 0.075}, "export/test_sparse": {"TestSparseProp": 51.60899999999989}, "export/test_tools": {"TestExportTools": 0.553}, "export/test_torchbind": {"TestCompileTorchbind": 0.442, "TestExportTorchbind": 1.9399999999999997, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.208}, "export/test_unflatten": {"TestUnflatten": 2.8469999999999995}, "export/test_verifier": {"TestVerifier": 0.8450000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.187000000000003, "TestAOTDispatch": 0.42500000000000004, "TestAOTExport": 1.8779999999999994, "TestAOTModuleSimplified": 0.543, "TestPartitioning": 3.0959999999999996}, "functorch/test_control_flow": {"TestControlFlow": 0.7700000000000002, "TestControlFlowTraced": 109.65600000000008}, "functorch/test_dims": {"TestMin": 13.356000000000002, "TestMinFunctorchOnly": 12.668}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.06900000000000003, "TestAutogradFunctionVmapAPICUDA": 0.016, "TestCompileTransformsCUDA": 4.487, "TestComposabilityCUDA": 0.13200000000000006, "TestExamplesCorrectnessCUDA": 2.1279999999999992, "TestFunctionalizeCUDA": 0.09400000000000003, "TestGradTransformCUDA": 0.8780000000000002, "TestHelpersCUDA": 0.009000000000000001, "TestHessianCUDA": 0.057, "TestHigherOrderOperatorInteractionCUDA": 0.021000000000000005, "TestJacCUDA": 0.7250000000000002, "TestJvpCUDA": 0.048000000000000015, "TestLinearizeCUDA": 0.24199999999999997, "TestMakeFunctional": 0.06600000000000002, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.6100000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.251}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.279, "RandomOpTestCase": 0.076, "ReduceTestCase": 0.063, "TestMemoryEfficientOpAuthoring": 7.1610000000000005}, "functorch/test_minifier": {"TestMinifier": 0.38300000000000006}, "functorch/test_ops": {"TestOperatorsCUDA": 4159.657999999983}, "functorch/test_parsing": {"TestAnonymousAxis": 0.662, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.6960000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6810000000000005, "TestTransformFailureCUDA": 0.09100000000000001, "TestVmapAPI": 0.8210000000000001, "TestVmapBatchedGradientCUDA": 0.18100000000000008, "TestVmapDeviceTypeCUDA": 0.018000000000000002, "TestVmapNestedTensorCUDA": 0.031000000000000003, "TestVmapOperators": 2.3339999999999965, "TestVmapOperatorsOpInfoCUDA": 272.3749999999995}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.3919999999998596}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.662}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 674.7389999999998, "AOTInductorTestABICompatibleCpuWithStackAllocation": 454.0889999999992, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 194.96899999999997, "AOTInductorTestABICompatibleCuda": 1283.1700000000003, "AOTInductorTestNonABICompatibleCpu": 1379.6179999999993, "AOTInductorTestNonABICompatibleCuda": 2072.8610000000003}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.742, "BenchmarkFusionCudaTest": 78.95899999999999, "BenchmarkMultiTemplateFusionCudaTest": 14.497}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.763, "FreezingCudaTests": 4.797}, "inductor/test_codecache": {"TestFxGraphCache": 118.10299999999998, "TestFxGraphCacheHashing": 0.756, "TestUtils": 3.415, "test_codecache": 2.9349999999999996}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.214}, "inductor/test_compile_worker": {"TestCompileWorker": 5.04}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 205.69600000000088, "TestCompiledAutograd": 157.01799999999997, "TestCustomOpWithCompiledAutograd": 0.30500000000000016}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 647.9639999999998, "CompiledOptimizerTests": 1373.228}, "inductor/test_config": {"TestInductorConfig": 5.4220000000000015}, "inductor/test_control_flow": {"CondTests": 85.70400000000002, "WhileLoopTests": 35.912}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.148}, "inductor/test_cpu_repro": {"CPUReproTests": 642.9640000000002}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1018.4190000000003, "TestCudaWrapper": 967.8300000000002}, "inductor/test_cuda_repro": {"CudaReproTests": 78.55599999999998}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 65.939}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.517}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.283}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 127.765}, "inductor/test_debug_trace": {"TestDebugTrace": 12.181}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.321}, "inductor/test_dependencies": {"TestDependencies": 0.203}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.077999999999996}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 182.693, "EfficientConvBNEvalCudaTests": 119.234}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.838}, "inductor/test_flex_attention": {"TestFlexAttention": 407.443}, "inductor/test_foreach": {"ForeachTests": 297.1200000000002}, "inductor/test_fp8": {"TestFP8Types": 0.010000000000000002}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 73.465, "SDPAPatternRewriterCpuTests": 69.125, "SDPAPatternRewriterCudaDynamicTests": 43.268, "SDPAPatternRewriterCudaTests": 33.925}, "inductor/test_fx_fusion": {"TestFxFusion": 0.175}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023, "TestGroupBatchFusion": 105.739, "TestPostGradBatchLinearFusion": 1.962}, "inductor/test_indexing": {"ExprPrinterTests": 0.049000000000000016, "TestIndexingSimplification": 0.521}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 47.601000000000006, "FreezingCudaTests": 33.141}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 7.059999999999999}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 125.20099999999998}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.487}, "inductor/test_max_autotune": {"TestMaxAutotune": 230.90800000000002, "TestTuningProcess": 10.115}, "inductor/test_memory_planning": {"TestMemoryPlanning": 29.358999999999998}, "inductor/test_metrics": {"TestMetrics": 3.83}, "inductor/test_minifier": {"MinifierTests": 28.498}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 91.03}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 80.22700000000002, "TestPatternMatcher": 405.23099999999965}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.004999999999997}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 15.024}, "inductor/test_multi_kernel": {"MultiKernelTest": 72.86099999999999}, "inductor/test_pad_mm": {"PadMMTest": 126.505}, "inductor/test_padding": {"PaddingTest": 14.517000000000003, "PerfTestBetweenGoodAndBadShape": 0.001, "PerfTestWithAndWithoutPadding": 4.289}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 91.73200000000003}, "inductor/test_perf": {"FusionTests": 13.447000000000001, "InplacingTests": 5.847999999999999, "MinCutPartitioningTests": 10.623, "NoopTests": 0.9300000000000002, "NumBytesMetricTests": 24.727999999999998, "SchedulerFusionTests": 8.611, "TilingTests": 2.199}, "inductor/test_profiler": {"DynamoProfilerTests": 7.954}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 114.208}, "inductor/test_smoke": {"SmokeTest": 6.116}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.981, "MemoryBoundedTests": 3.1479999999999997, "TestCommAnalysis": 6.541, "UnsupportedTests": 0.333}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 99.48400000000001}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.371}, "inductor/test_torchbind": {"TestTorchbind": 6.275}, "inductor/test_torchinductor": {"CpuTests": 0.001, "GPUTests": 17.78}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 0.001, "DynamicShapesCodegenGPUTests": 15.484}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 0.001, "DynamicShapesGPUTests": 9.115}, "nn/test_convolution": {"TestConvolutionNN": 20.528999999999996, "TestConvolutionNNDeviceTypeCUDA": 51.044999999999476}, "nn/test_pooling": {"TestAvgPool": 0.7320000000000001, "TestPoolingNN": 0.661, "TestPoolingNNDeviceTypeCUDA": 4.515999999999997}, "profiler/test_profiler": {"TestProfiler": 0.7110000000000001}, "test_autocast": {"TestAutocastCPU": 1.9229999999999996, "TestAutocastGPU": 0.199, "TestTorchAutocast": 0.003}, "test_autograd_fallback": {"TestAutogradFallback": 0.7290000000000001}, "test_cpp_api_parity": {"TestCppApiParity": 8.709999999999983}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.6990000000000001, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.678, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 165.996}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.423}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.681000000000001}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.422}, "test_cuda": {"TestCuda": 15.005999999999998}, "test_cuda_expandable_segments": {"TestCuda": 16.323}, "test_cuda_multigpu": {"TestCudaMultiGPU": 0.856}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.766, "TestVisibleDeviceParses": 1.267}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.268}, "test_cuda_trace": {"TestCudaTrace": 6.728}, "test_dispatch": {"TestDispatch": 32.623000000000005, "TestPythonDispatcher": 0.027}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.018000000000000002, "FakeTensorDispatchCache": 0.064, "FakeTensorOpInfoTestCUDA": 0.07400000000000001, "FakeTensorOperatorInvariants": 0.45300000000000007, "FakeTensorPropTest": 0.056999999999999995, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.527999999999999, "PropagateRealTensorsFakeTensorConstHandling": 0.07100000000000001, "PropagateRealTensorsFakeTensorConverterTest": 0.016, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.156, "PropagateRealTensorsFakeTensorPropTest": 0.042, "PropagateRealTensorsFakeTensorTest": 10.025000000000013}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.20400000000000004, "TestCommonPass": 0.14100000000000004, "TestConstFold": 0.12400000000000004, "TestConstParamShapeInControlFlow": 0.030000000000000002, "TestDCE": 0.020999999999999998, "TestFX": 2.173999999999997, "TestFXAPIBackwardCompatibility": 0.021, "TestFunctionalTracing": 0.25300000000000017, "TestMatcher": 0.31600000000000006, "TestOperatorSignaturesCUDA": 0.6780000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.964, "TestSubgraphRewriter": 0.2240000000000001, "TestVisionTracing": 213.41499999999996, "TypeCheckerTest": 1.578999999999998}, "test_indexing": {"TestIndexingCUDA": 0.554}, "test_jit_disabled": {"TestJitDisabled": 0.7230000000000001}, "test_linalg": {"TestLinalgCUDA": 13.372}, "test_mobile_optimizer": {"TestOptimizer": 2.638}, "test_multiprocessing": {"TestMultiprocessing": 85.95200000000001}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.517, "SpawnTest": 18.971999999999998}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.9900000000000002}, "test_native_mha": {"TestMHADeviceTypeCUDA": 1.0450000000000002}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.25, "TestFusionUtils": 0.004, "TestNN": 44.85500000000004, "TestNNDeviceTypeCUDA": 121.1000000000043, "TestUtils": 0.003}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.017, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.007, "TestResolveName": 0.094, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 2.1439999999998895, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.023, "TestPythonDispatch": 0.19800000000000006, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2539999999999998, "TestWrapperSubclassAliasingCUDA": 0.22000000000000003}, "test_reductions": {"TestReductionsCUDA": 132.69500000000238}, "test_serialization": {"TestSerialization": 5.785}, "test_show_pickle": {"TestShowPickle": 0.644}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.967999999999995}, "test_spectral_ops": {"TestFFTCUDA": 18.69099999999996}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4180000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.12000000000000004, "TestTensorCreationCUDA": 76.37400000000025}, "test_tensorexpr": {"TestTensorExprFuser": 114.41000000000001}, "test_torch": {"TestBasicVitalSigns": 0.023, "TestDevicePrecisionCUDA": 0.05500000000000002, "TestTorch": 4.723999999999989, "TestTorchDeviceTypeCUDA": 82.98800000000007, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.05, "TestBottleneck": 10.046, "TestCheckpoint": 0.29900000000000004, "TestCollectEnv": 0.984, "TestCppExtensionUtils": 0.03, "TestDataLoaderUtils": 0.258, "TestDeviceUtilsCUDA": 11.744000000000574, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.005, "TestONNXUtils": 0.003, "TestRenderUtils": 0.011, "TestStandaloneCPPJIT": 2.284, "TestTraceback": 0.006}}, "dynamic_aot_eager_timm": {"backends/xeon/test_launch": {"TestTorchrun": 2.209}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.215}, "distributions/test_distributions": {"TestAgainstScipy": 1.121, "TestConstraints": 0.128, "TestDistributionShapes": 0.10600000000000005, "TestDistributions": 43.797000000000004, "TestFunctors": 0.007, "TestJit": 19.27, "TestKL": 2.5869999999999993, "TestLazyLogitsInitialization": 0.01, "TestNumericalStability": 0.06000000000000001, "TestRsample": 0.611, "TestValidation": 0.31100000000000005}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.563000000000006}, "dynamo/test_after_aot": {"TestAfterAot": 4.829000000000001}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.21}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9620000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.384}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.031, "TestCustomBackendAPI": 1.738, "TestExplainWithBackend": 9.974, "TestOptimizations": 1.7839999999999994}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.688}, "dynamo/test_base_output": {"TestBaseOutput": 0.003}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 5.627, "BytecodeTests": 0.459}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.599, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.5680000000000001}, "dynamo/test_config": {"ConfigTests": 0.565}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.0719999999999996}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.591}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.304}, "dynamo/test_decorators": {"DecoratorTests": 0.6720000000000002}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.014}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 24.22799999999999, "DynamicShapesCtxManagerTests": 4.191, "DynamicShapesExportTests": 1288.6209999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 96.201, "DynamicShapesFunctionTests": 16.783999999999992, "DynamicShapesHigherOrderOpTests": 15.478000000000003, "DynamicShapesMiscTests": 44.98899999999999, "DynamicShapesNNModuleTests": 2.7489999999999997, "DynamicShapesReproTests": 25.96400000000001, "DynamicShapesSubGraphTests": 8.111, "DynamicShapesTestSDPA": 0.318}, "dynamo/test_exc": {"ExcTests": 1.8800000000000001}, "dynamo/test_export": {"ExportTests": 13.794999999999993}, "dynamo/test_export_mutations": {"MutationExportTests": 0.525}, "dynamo/test_frame_init": {"FrameInitTests": 0.204}, "dynamo/test_functions": {"DefaultsTests": 0.7120000000000003, "FunctionTests": 20.243999999999982}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.186}, "dynamo/test_global": {"TestGlobals": 0.514}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.22500000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.308000000000001, "FuncTorchHigherOrderOpTests": 9.906000000000004, "HigherOrderOpTests": 6.934999999999997, "HigherOrderOpVmapGuardTests": 3.7569999999999997}, "dynamo/test_hooks": {"HooksTests": 23.360000000000014}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.532}, "dynamo/test_interop": {"InteropTests": 0.5549999999999999}, "dynamo/test_logging": {"LoggingTests": 18.564999999999998}, "dynamo/test_minifier": {"MinifierTests": 2.072}, "dynamo/test_misc": {"MiscTests": 47.68600000000007, "TestTracer": 0.052}, "dynamo/test_model_output": {"TestHFPretrained": 0.421, "TestModelOutput": 0.21800000000000003}, "dynamo/test_modules": {"NNModuleTests": 2.7059999999999977, "OptimizedModuleTest": 7.9929999999999986}, "dynamo/test_nops": {"NopTests": 0.299}, "dynamo/test_optimizers": {"End2EndTests": 0.627}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.47700000000000004}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.2829999999999997}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.632}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.8120000000000002}, "dynamo/test_recompiles": {"RecompileTests": 0.799}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.503}, "dynamo/test_repros": {"ReproTests": 29.776999999999997}, "dynamo/test_resume": {"ResumeFunctionTests": 0.48}, "dynamo/test_sdpa": {"TestSDPA": 0.465}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.5800000000000001}, "dynamo/test_sources": {"SourceTests": 0.466}, "dynamo/test_structured_trace": {"StructuredTraceTest": 14.24}, "dynamo/test_subclasses": {"SubclassTests": 2.643999999999999, "TestNestedTensor": 13.129}, "dynamo/test_subgraphs": {"SubGraphTests": 2.0399999999999996}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.096, "TraceRuleTests": 1.15}, "dynamo/test_unspec": {"UnspecTests": 10.407}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.5650000000000001}, "export/test_converter": {"TestConverter": 0.303}, "export/test_db": {"ExampleTests": 2.7199999999999993}, "export/test_experimental": {"TestExperiment": 0.9}, "export/test_export": {"TestDynamismExpression": 0.46, "TestExport": 23.520999999999997, "TestExportCustomClass": 0.058, "TestOneOffModelExportResult": 1.2060000000000002}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.36299999999999993, "NonStrictExportTestExport": 20.215999999999994}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.638}, "export/test_hop": {"TestHOPCUDA": 1.6599999999999997, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.079}, "export/test_pass_infra": {"TestPassInfra": 0.8240000000000002}, "export/test_passes": {"TestPasses": 10.775}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.7469999999999999, "RetraceExportTestExport": 35.26200000000001}, "export/test_schema": {"TestSchema": 0.245}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.501, "SerDesExportTestExport": 23.578999999999994}, "export/test_serialize": {"TestDeserialize": 7.092999999999997, "TestSaveLoad": 0.272, "TestSchemaVersioning": 0.028, "TestSerialize": 1.0090000000000003, "TestSerializeCustomClass": 0.08}, "export/test_sparse": {"TestSparseProp": 52.9679999999999}, "export/test_tools": {"TestExportTools": 0.529}, "export/test_torchbind": {"TestCompileTorchbind": 0.45, "TestExportTorchbind": 1.9489999999999992, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.209}, "export/test_unflatten": {"TestUnflatten": 3.029}, "export/test_verifier": {"TestVerifier": 0.8770000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.813000000000006, "TestAOTDispatch": 0.445, "TestAOTExport": 1.9600000000000002, "TestAOTModuleSimplified": 0.5650000000000001, "TestPartitioning": 3.1739999999999995}, "functorch/test_control_flow": {"TestControlFlow": 0.7750000000000001, "TestControlFlowTraced": 112.36800000000004}, "functorch/test_dims": {"TestMin": 13.563999999999998, "TestMinFunctorchOnly": 12.812}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.07600000000000004, "TestAutogradFunctionVmapAPICUDA": 0.017, "TestCompileTransformsCUDA": 4.471, "TestComposabilityCUDA": 0.13800000000000004, "TestExamplesCorrectnessCUDA": 1.9999999999999998, "TestFunctionalizeCUDA": 0.10000000000000003, "TestGradTransformCUDA": 0.8700000000000001, "TestHelpersCUDA": 0.009000000000000001, "TestHessianCUDA": 0.053, "TestHigherOrderOperatorInteractionCUDA": 0.023, "TestJacCUDA": 0.7170000000000002, "TestJvpCUDA": 0.048000000000000015, "TestLinearizeCUDA": 0.23999999999999996, "TestMakeFunctional": 0.06200000000000001, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.5910000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.246}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.281, "RandomOpTestCase": 0.07, "ReduceTestCase": 0.063, "TestMemoryEfficientOpAuthoring": 7.187999999999999}, "functorch/test_minifier": {"TestMinifier": 0.3820000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 4079.956999999955}, "functorch/test_parsing": {"TestAnonymousAxis": 0.665, "TestParsedExpression": 0.005, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.7080000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6750000000000005, "TestTransformFailureCUDA": 0.093, "TestVmapAPI": 0.8300000000000001, "TestVmapBatchedGradientCUDA": 0.17700000000000007, "TestVmapDeviceTypeCUDA": 0.017, "TestVmapNestedTensorCUDA": 0.031000000000000003, "TestVmapOperators": 2.3099999999999965, "TestVmapOperatorsOpInfoCUDA": 253.07599999999957}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.4229999999998575}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.831}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 672.3149999999995, "AOTInductorTestABICompatibleCpuWithStackAllocation": 454.96799999999973, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 193.229, "AOTInductorTestABICompatibleCuda": 1288.2109999999998, "AOTInductorTestNonABICompatibleCpu": 1380.4460000000001, "AOTInductorTestNonABICompatibleCuda": 2074.5579999999995}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.715, "BenchmarkFusionCudaTest": 78.828, "BenchmarkMultiTemplateFusionCudaTest": 14.518}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.723, "FreezingCudaTests": 4.821}, "inductor/test_codecache": {"TestFxGraphCache": 118.48400000000004, "TestFxGraphCacheHashing": 0.77, "TestUtils": 3.402, "test_codecache": 3.606}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.21}, "inductor/test_compile_worker": {"TestCompileWorker": 5.036}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 206.8950000000008, "TestCompiledAutograd": 156.64100000000002, "TestCustomOpWithCompiledAutograd": 0.30900000000000016}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 660.6139999999999, "CompiledOptimizerTests": 1382.5530000000006}, "inductor/test_config": {"TestInductorConfig": 5.430000000000001}, "inductor/test_control_flow": {"CondTests": 86.024, "WhileLoopTests": 35.73800000000001}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.18}, "inductor/test_cpu_repro": {"CPUReproTests": 643.1419999999997}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1013.9969999999997, "TestCudaWrapper": 968.5540000000002}, "inductor/test_cuda_repro": {"CudaReproTests": 78.24300000000001}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 66.418}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.584}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.109}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 127.39500000000004}, "inductor/test_debug_trace": {"TestDebugTrace": 13.453000000000001}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.589}, "inductor/test_dependencies": {"TestDependencies": 0.21100000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.006}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 182.566, "EfficientConvBNEvalCudaTests": 118.706}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.884}, "inductor/test_flex_attention": {"TestFlexAttention": 406.83299999999974}, "inductor/test_foreach": {"ForeachTests": 294.5940000000001}, "inductor/test_fp8": {"TestFP8Types": 0.008}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 74.52499999999999, "SDPAPatternRewriterCpuTests": 68.89, "SDPAPatternRewriterCudaDynamicTests": 41.233000000000004, "SDPAPatternRewriterCudaTests": 33.201}, "inductor/test_fx_fusion": {"TestFxFusion": 0.18}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023, "TestGroupBatchFusion": 106.13, "TestPostGradBatchLinearFusion": 1.935}, "inductor/test_indexing": {"ExprPrinterTests": 0.05000000000000001, "TestIndexingSimplification": 0.525}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 47.995000000000005, "FreezingCudaTests": 33.897}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 7.0249999999999995}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 125.64299999999997}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.676}, "inductor/test_max_autotune": {"TestMaxAutotune": 230.62000000000006, "TestTuningProcess": 9.775}, "inductor/test_memory_planning": {"TestMemoryPlanning": 29.487}, "inductor/test_metrics": {"TestMetrics": 3.814000000000001}, "inductor/test_minifier": {"MinifierTests": 28.287}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 91.53999999999999}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 81.253, "TestPatternMatcher": 396.31399999999996}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.021999999999998}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.790000000000001}, "inductor/test_multi_kernel": {"MultiKernelTest": 71.87799999999999}, "inductor/test_pad_mm": {"PadMMTest": 126.95899999999999}, "inductor/test_padding": {"PaddingTest": 14.520999999999999, "PerfTestBetweenGoodAndBadShape": 0.004, "PerfTestWithAndWithoutPadding": 4.601}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 92.15199999999999}, "inductor/test_perf": {"FusionTests": 13.836, "InplacingTests": 5.6240000000000006, "MinCutPartitioningTests": 10.819, "NoopTests": 0.933, "NumBytesMetricTests": 25.137, "SchedulerFusionTests": 8.482, "TilingTests": 1.9120000000000001}, "inductor/test_profiler": {"DynamoProfilerTests": 7.667}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 115.85300000000001}, "inductor/test_smoke": {"SmokeTest": 6.145}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.682, "MemoryBoundedTests": 3.126, "TestCommAnalysis": 6.4430000000000005, "UnsupportedTests": 0.315}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 98.422}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.233}, "inductor/test_torchbind": {"TestTorchbind": 6.186}, "inductor/test_torchinductor": {"CpuTests": 1512.2729999999992, "GPUTests": 881.5759999999998, "NanCheckerTest": 0.871, "RNNTest": 0.018, "SweepInputsCpuTest": 112.49, "SweepInputsGPUTest": 29.086999999999996, "TestFull": 10.122, "TritonCodeGenTests": 181.35999999999999}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1627.369, "DynamicShapesCodegenGPUTests": 990.2879999999989}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1731.1600000000008, "DynamicShapesGPUTests": 1321.6479999999997, "TestInductorDynamicCUDA": 41.43900000000001}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1646.414999999999}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.541}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.007}, "inductor/test_triton_kernels": {"KernelTests": 94.65400000000001, "MutationTests": 0.3140000000000001}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 7.103}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 19.179}, "inductor/test_utils": {"TestUtils": 0.21}, "lazy/test_debug_util": {"DebugUtilTest": 0.69}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.7230000000000001}, "lazy/test_generator": {"LazyGeneratorTest": 0.697}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.848}, "lazy/test_step_closures": {"ClosuresTest": 2.6479999999999997}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.171, "TestLazyTensor": 0.54}, "nn/test_convolution": {"TestConvolutionNN": 21.379, "TestConvolutionNNDeviceTypeCUDA": 51.25099999999949}, "nn/test_dropout": {"TestDropoutNN": 0.5710000000000001, "TestDropoutNNDeviceTypeCUDA": 0.443}, "nn/test_embedding": {"TestEmbeddingNN": 0.54, "TestEmbeddingNNDeviceTypeCUDA": 9.267999999999994}, "nn/test_init": {"TestNNInit": 3.994999999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.8350000000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.0669999999999995, "TestLoadStateDictSwap": 0.041999999999999996}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.015, "TestModuleHookNN": 0.045000000000000005, "TestModuleHooks": 0.5750000000000001, "TestStateDictHooks": 0.011000000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 5.187999999999999, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.24700000000000005}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.2499999999999998}, "nn/test_parametrization": {"TestNNParametrization": 1.202999999999999, "TestNNParametrizationDeviceCUDA": 0.137}, "nn/test_pooling": {"TestAvgPool": 0.651, "TestPoolingNN": 0.659, "TestPoolingNNDeviceTypeCUDA": 4.525999999999997}, "nn/test_pruning": {"TestPruningNN": 0.508}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.357}, "profiler/test_memory_profiler": {"TestDataFlow": 1.1049999999999998, "TestIdentifyGradients": 0.251, "TestMemoryProfiler": 0.678, "TestMemoryProfilerE2E": 2.5699999999999994}, "profiler/test_profiler": {"TestExperimentalUtils": 4.020999999999999, "TestProfiler": 18.697000000000003, "TestProfilerCUDA": 5.786, "TestProfilerITT": 0.002}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.706}, "profiler/test_record_function": {"TestRecordFunction": 0.675}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.9699999999999993}, "test_ao_sparsity": {"TestActivationSparsifier": 0.052, "TestBaseDataScheduler": 0.023, "TestBaseDataSparsifier": 0.05500000000000001, "TestBaseSparsifier": 0.023, "TestBaseStructuredSparsifier": 3.5459999999999994, "TestComposability": 1.529, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.061, "TestFakeSparsity": 0.05800000000000001, "TestFxComposability": 1.429, "TestNearlyDiagonalSparsifier": 0.666, "TestNormDataSparsifiers": 0.685, "TestQuantizationUtils": 0.019, "TestQuantizedSparseKernels": 0.331, "TestQuantizedSparseLayers": 0.32899999999999996, "TestSaliencyPruner": 0.019, "TestScheduler": 0.012, "TestSparsityUtilFunctions": 0.033, "TestWeightNormSparsifier": 0.26}, "test_autocast": {"TestAutocastCPU": 1.9229999999999996, "TestAutocastGPU": 0.20400000000000001, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.021000000000000005, "TestAutograd": 16.107999999999983, "TestAutogradComplex": 0.004, "TestAutogradDeviceTypeCUDA": 2.073999999999999, "TestAutogradForwardMode": 0.04900000000000002, "TestAutogradForwardModeBatchedGrad": 0.014000000000000002, "TestAutogradFunctional": 8.54, "TestAutogradInferenceMode": 0.02000000000000001, "TestAutogradLogging": 0.011, "TestAutogradMultipleDispatchCUDA": 0.017000000000000005, "TestMultithreadAutograd": 0.17900000000000005, "TestNestedCheckpoint": 0.3450000000000001}, "test_autograd_fallback": {"TestAutogradFallback": 0.7310000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 190.51799999999622}, "test_bundled_inputs": {"TestBundledInputs": 1.329}, "test_comparison_utils": {"TestComparisonUtils": 0.654}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.52}, "test_content_store": {"TestContentStoreCUDA": 2.659}, "test_cpp_api_parity": {"TestCppApiParity": 8.475999999999994}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.6930000000000001, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.657, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.046}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 165.30100000000002}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.42}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.511000000000003}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.42}, "test_cuda": {"TestBlockStateAbsorption": 5.860999999999999, "TestCuda": 106.48, "TestCudaMallocAsync": 9.983999999999998, "TestCudaOptimsCUDA": 0.07500000000000001}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.8100000000000005, "TestCuda": 101.50600000000001, "TestCudaMallocAsync": 14.757999999999997, "TestCudaOptimsCUDA": 0.09199999999999997}, "test_cuda_multigpu": {"TestCudaComm": 0.022000000000000006, "TestCudaMultiGPU": 1.312}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.768, "TestVisibleDeviceParses": 1.275}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.256}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.6990000000000001, "TestEventHandler": 0.022000000000000013, "TestMessages": 0.004}, "test_cuda_trace": {"TestCudaTrace": 6.662000000000001}, "test_custom_ops": {"MiniOpTest": 0.6170000000000002, "MiniOpTestOther": 0.04600000000000001, "TestCustomOp": 2.401999999999994, "TestCustomOpAPI": 0.11000000000000003, "TestCustomOpTestingCUDA": 1.778, "TestGenerateOpcheckTests": 2.8680000000000003}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 86.625, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.047, "TestCustomPinFn": 0.10300000000000001, "TestDataLoader": 80.15100000000001, "TestDataLoaderDeviceTypeCUDA": 12.311, "TestDataLoaderPersistentWorkers": 100.09000000000003, "TestDatasetRandomSplit": 0.493, "TestDictDataLoader": 0.034, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.003, "TestSetAffinity": 0.04, "TestStackDataset": 0.031000000000000003, "TestStringDataLoader": 0.048, "TestTensorDataset": 0.016}, "test_datapipe": {"TestCaptureDataFrame": 0.003, "TestCircularSerialization": 0.006, "TestDataChunk": 0.533, "TestDataFramesPipes": 0.41000000000000003, "TestFunctionalIterDataPipe": 3.3829999999999987, "TestFunctionalMapDataPipe": 0.025999999999999995, "TestGraph": 0.010000000000000002, "TestIterDataPipeCountSampleYielded": 0.006, "TestIterDataPipeGraphFastForward": 0.034, "TestIterDataPipeSingletonConstraint": 0.016, "TestIterableDataPipeBasic": 0.022, "TestSerialization": 5.696, "TestSharding": 0.17500000000000002, "TestStreamWrapper": 0.217, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.032, "HasDecompTest": 0.13, "TestDecompCUDA": 12680.775000000054}, "test_deploy": {"TestFreezer": 0.624}, "test_dispatch": {"TestDispatch": 32.21700000000001, "TestPythonDispatcher": 0.027000000000000003}, "test_dlpack": {"TestTorchDlPackCUDA": 0.7450000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 1.833, "TestFloorDiv": 0.04700000000000001, "TestPySymInt": 1.1939999999999997, "TestSymNumberMagicMethods": 1.0949999999999986}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 2.538999999999997, "TestExpandedWeightHelperFunctionCUDA": 0.453, "TestExpandedWeightModuleCUDA": 9.05}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.018, "FakeTensorDispatchCache": 0.06300000000000001, "FakeTensorOpInfoTestCUDA": 0.07300000000000001, "FakeTensorOperatorInvariants": 0.45300000000000007, "FakeTensorPropTest": 0.056999999999999995, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.551999999999996, "PropagateRealTensorsFakeTensorConstHandling": 0.068, "PropagateRealTensorsFakeTensorConverterTest": 0.016, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.155, "PropagateRealTensorsFakeTensorPropTest": 0.041, "PropagateRealTensorsFakeTensorTest": 10.058000000000014}, "test_flop_counter": {"TestFlopCounter": 0.609}, "test_foreach": {"TestForeachCUDA": 402.69200000000814}, "test_function_schema": {"TestFunctionSchema": 0.901}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 16.672}, "test_functional_optim": {"TestFunctionalOptimParity": 0.29400000000000004}, "test_functionalization": {"TestCrossRefFunctionalization": 1.7429999999999992, "TestFunctionalization": 2.284999999999999}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.305}, "test_futures": {"TestFuture": 1.261}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.20100000000000004, "TestCommonPass": 0.14200000000000007, "TestConstFold": 0.12300000000000004, "TestConstParamShapeInControlFlow": 0.030000000000000002, "TestDCE": 0.020999999999999998, "TestFX": 2.168999999999998, "TestFXAPIBackwardCompatibility": 0.021, "TestFunctionalTracing": 0.2470000000000002, "TestMatcher": 0.31500000000000006, "TestOperatorSignaturesCUDA": 0.6780000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.967, "TestSubgraphRewriter": 0.21800000000000008, "TestVisionTracing": 212.07499999999993, "TypeCheckerTest": 1.5719999999999974}, "test_fx_experimental": {"TestFXExperimental": 11.605999999999998, "TestNormalizeOperatorsCUDA": 1.3160000000000007, "TestTranslationValidation": 0.11199999999999999}, "test_fx_passes": {"TestFXGraphPasses": 0.9260000000000002, "TestFXMatcherUtils": 0.06900000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.7820000000000001}, "test_import_stats": {"TestImportTime": 3.7059999999999995}, "test_indexing": {"NumpyTestsCUDA": 0.12800000000000003, "TestIndexingCUDA": 2.6379999999999937}, "test_itt": {"TestItt": 0.628}, "test_jit": {"TestAliasAnalysis": 0.256, "TestAsync": 0.24900000000000005, "TestAtenPow": 0.006, "TestAutodiffJit": 0.046, "TestAutodiffSubgraphSlicing": 0.20600000000000007, "TestAwait": 0.15000000000000002, "TestBackends": 0.511, "TestBackendsWithCompiler": 0.107, "TestBatchMM": 0.068, "TestBuiltins": 0.042, "TestCUDA": 0.577, "TestClassType": 1.8529999999999995, "TestComplex": 0.5960000000000001, "TestCustomOperators": 0.024000000000000007, "TestDCE": 0.013999999999999999, "TestDataParallel": 0.001, "TestDataclasses": 3.3719999999999994, "TestDeviceAnalysis": 3.0479999999999996, "TestDict": 0.29400000000000015, "TestDtypeAnalysis": 0.11299999999999998, "TestEnum": 0.14700000000000002, "TestFreezing": 1.7620000000000005, "TestFrontend": 0.322, "TestFrozenOptimizations": 8.403999999999996, "TestFunctionalBlocks": 0.005, "TestFunctionalToInplaceActivation": 1.705, "TestGenerator": 0.047, "TestGetDefaultAttr": 0.012, "TestGraphRewritePasses": 0.03, "TestHash": 0.051, "TestHooks": 0.4940000000000002, "TestIgnorableArgs": 0.007, "TestIgnoreContextManager": 0.03, "TestInplaceToFunctionalActivation": 1.5539999999999998, "TestIsinstance": 0.14500000000000007, "TestJit": 4.136999999999997, "TestJitGeneratedModule": 8.222999999999987, "TestJitProfiler": 0.001, "TestJitUtils": 0.012000000000000004, "TestList": 0.9150000000000003, "TestLogging": 0.036, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.37600000000000006, "TestMixTracingScripting": 0.9289999999999999, "TestModels": 4.239999999999999, "TestModuleAPIs": 0.092, "TestModuleContainers": 0.8590000000000002, "TestModuleInterface": 0.35700000000000015, "TestModules": 0.01, "TestNamedTuple": 0.04600000000000001, "TestNnapiBackend": 8.793999999999999, "TestOpDecompositions": 0.012, "TestOptimizeForMobilePreserveDebugInfo": 0.119, "TestParametrization": 0.061, "TestPeephole": 0.3080000000000001, "TestProducerVersion": 0.001, "TestProfiler": 0.441, "TestPythonBindings": 0.02, "TestPythonBuiltinOP": 0.257, "TestPythonIr": 0.016, "TestRecursiveScript": 0.5070000000000001, "TestRemoveMutation": 0.08700000000000001, "TestSaveLoad": 0.334, "TestSaveLoadFlatbuffer": 0.395, "TestSaveLoadForOpVersion": 1.7999999999999996, "TestScript": 31.477000000000054, "TestScriptDict": 0.015000000000000003, "TestScriptList": 0.023, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.13700000000000007, "TestScriptProfile": 0.268, "TestSlice": 0.10600000000000002, "TestSparse": 0.036000000000000004, "TestStringFormatting": 0.08100000000000004, "TestSymbolicShapeAnalysis": 0.9130000000000001, "TestTensorBuiltins": 0.068, "TestTensorCreationOps": 0.036, "TestTensorMethods": 0.008, "TestTorchbind": 0.13000000000000006, "TestTracer": 3.5709999999999917, "TestTypeSharing": 0.3450000000000001, "TestTypesAndAnnotation": 0.08600000000000001, "TestTyping": 0.26100000000000007, "TestUnion": 0.31600000000000017, "TestUnsupportedOps": 0.019, "TestUpgraders": 0.048, "TestWarn": 0.034999999999999996, "TestWith": 0.23299999999999998}, "test_jit_autocast": {"TestAutocast": 1.1239999999999997, "TestJitTraceAutocast": 25.293}, "test_jit_disabled": {"TestJitDisabled": 0.7240000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.114, "TestNNCOpInfoCUDA": 12.51700000000085, "TestTEFuserDynamic": 542.2769999999998, "TestTEFuserStatic": 486.482}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.056, "TestFusionPatternCUDA": 0.0, "TestModel": 0.003, "TestOpCUDA": 0.0}, "test_jiterator": {"TestPythonJiteratorCUDA": 19.51000000000001}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2659999999999985, "TestVmapBatchedGradientLegacyCUDA": 0.3800000000000001, "TestVmapOperatorsLegacy": 0.7190000000000001}, "test_license": {"TestLicense": 0.622}, "test_linalg": {"TestLinalgCUDA": 1512.0079999999914}, "test_logging": {"LoggingTest": 2.716}, "test_masked": {"TestMaskedCUDA": 40.00299999999997}, "test_maskedtensor": {"TestBasicsCUDA": 0.18100000000000002, "TestBinary": 0.24500000000000013, "TestOperatorsCUDA": 5.882999999999923, "TestReductions": 0.05200000000000001, "TestUnary": 0.6190000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.003, "TestMatmulCudaCUDA": 88.946, "TestMixedDtypesLinearCudaCUDA": 0.715}, "test_meta": {"TestMetaCUDA": 1646.7249999997136, "TestMetaConverter": 1.0099999999999998}, "test_mkl_verbose": {"TestMKLVerbose": 3.774}, "test_mkldnn_fusion": {"TestMkldnnFusion": 34.058}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.567}, "test_mobile_optimizer": {"TestOptimizer": 2.566}, "test_model_dump": {"TestModelDump": 1.238}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.204}, "test_module_tracker": {"TestModuleTracker": 0.636}, "test_modules": {"TestModuleCUDA": 2532.230000000023}, "test_monitor": {"TestMonitor": 0.622, "TestMonitorTensorboard": 0.244}, "test_multiprocessing": {"TestMultiprocessing": 85.61100000000003}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.503, "SpawnTest": 18.904}, "test_namedtensor": {"TestNamedTensor": 1.1549999999999978}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.983}, "test_native_functions": {"TestNativeFunctions": 0.7430000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.9500000000000004}, "test_nestedtensor": {"TestNestedTensor": 0.17600000000000002, "TestNestedTensorAutogradCUDA": 1.1779999999999997, "TestNestedTensorDeviceTypeCUDA": 1.247999999999997, "TestNestedTensorSubclassCUDA": 6.609999999999993}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.251, "TestFusionUtils": 0.004, "TestNN": 45.791000000000096, "TestNNDeviceTypeCUDA": 121.52500000000425, "TestUtils": 0.003}, "test_numba_integration": {"TestNumbaIntegration": 0.521}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.5930000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 4.021}, "test_ops": {"TestCommonCUDA": 1781.8799999999892, "TestCompositeComplianceCUDA": 697.9609999999974, "TestFakeTensorCUDA": 528.0629999999983, "TestMathBitsCUDA": 47.162000000000035, "TestSelfKwarg": 0.403, "TestTagsCUDA": 1.5950000000000013}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 512.3580000000035}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1806.3319999998796}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.017, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.005, "TestResolveName": 0.094, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 2.1399999999998895, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.022, "TestPythonDispatch": 0.18100000000000008, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2539999999999998, "TestWrapperSubclassAliasingCUDA": 0.10600000000000004}, "test_reductions": {"TestReductionsCUDA": 134.5689999999989}, "test_serialization": {"TestSerialization": 5.793}, "test_show_pickle": {"TestShowPickle": 0.641}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.857999999999995}, "test_spectral_ops": {"TestFFTCUDA": 18.65399999999996}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4250000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.12900000000000003, "TestTensorCreationCUDA": 79.5970000000003}, "test_tensorexpr": {"TestTensorExprFuser": 114.13600000000001}, "test_torch": {"TestBasicVitalSigns": 0.022, "TestDevicePrecisionCUDA": 0.05400000000000001, "TestTorch": 4.698999999999989, "TestTorchDeviceTypeCUDA": 82.92000000000004, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.051000000000000004, "TestBottleneck": 9.74, "TestCheckpoint": 0.29800000000000004, "TestCollectEnv": 0.978, "TestCppExtensionUtils": 0.026, "TestDataLoaderUtils": 0.272, "TestDeviceUtilsCUDA": 11.747000000000579, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.005, "TestONNXUtils": 0.003, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.248, "TestTraceback": 0.006}}, "dynamic_aot_eager_torchbench": {"backends/xeon/test_launch": {"TestTorchrun": 2.1919999999999997}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.1889999999999996}, "distributions/test_distributions": {"TestAgainstScipy": 1.021, "TestConstraints": 0.122, "TestDistributionShapes": 0.10300000000000005, "TestDistributions": 43.233000000000004, "TestFunctors": 0.007, "TestJit": 19.209999999999997, "TestKL": 2.5839999999999996, "TestLazyLogitsInitialization": 0.01, "TestNumericalStability": 0.05900000000000001, "TestRsample": 0.603, "TestValidation": 0.31000000000000005}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.409}, "dynamo/test_after_aot": {"TestAfterAot": 4.800999999999999}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.158000000000003}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9380000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.3469999999999995}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.03, "TestCustomBackendAPI": 1.7179999999999997, "TestExplainWithBackend": 8.532, "TestOptimizations": 1.7759999999999996}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 12.034}, "dynamo/test_base_output": {"TestBaseOutput": 0.002}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 7.107, "BytecodeTests": 0.443}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.497, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.56}, "dynamo/test_config": {"ConfigTests": 0.572}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.0179999999999993}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.3970000000000002}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.318}, "dynamo/test_decorators": {"DecoratorTests": 0.6850000000000002}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.013}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 23.372999999999998, "DynamicShapesCtxManagerTests": 4.189, "DynamicShapesExportTests": 1289.3410000000001, "DynamicShapesFuncTorchHigherOrderOpTests": 96.10399999999998, "DynamicShapesFunctionTests": 16.506999999999998, "DynamicShapesHigherOrderOpTests": 15.247000000000002, "DynamicShapesMiscTests": 44.818000000000005, "DynamicShapesNNModuleTests": 2.707, "DynamicShapesReproTests": 25.607000000000003, "DynamicShapesSubGraphTests": 7.874999999999998, "DynamicShapesTestSDPA": 0.318}, "dynamo/test_exc": {"ExcTests": 1.7689999999999997}, "dynamo/test_export": {"ExportTests": 13.825000000000005}, "dynamo/test_export_mutations": {"MutationExportTests": 0.524}, "dynamo/test_frame_init": {"FrameInitTests": 0.205}, "dynamo/test_functions": {"DefaultsTests": 0.6750000000000002, "FunctionTests": 20.007000000000016}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.124}, "dynamo/test_global": {"TestGlobals": 0.504}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.22500000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.439000000000001, "FuncTorchHigherOrderOpTests": 9.814000000000002, "HigherOrderOpTests": 6.837, "HigherOrderOpVmapGuardTests": 3.658}, "dynamo/test_hooks": {"HooksTests": 23.29300000000001}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.536999999999999}, "dynamo/test_interop": {"InteropTests": 0.5409999999999999}, "dynamo/test_logging": {"LoggingTests": 18.595}, "dynamo/test_minifier": {"MinifierTests": 2.056}, "dynamo/test_misc": {"MiscTests": 47.44100000000008, "TestTracer": 0.048}, "dynamo/test_model_output": {"TestHFPretrained": 0.41, "TestModelOutput": 0.21600000000000003}, "dynamo/test_modules": {"NNModuleTests": 2.6039999999999974, "OptimizedModuleTest": 7.844999999999996}, "dynamo/test_nops": {"NopTests": 0.292}, "dynamo/test_optimizers": {"End2EndTests": 0.609}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.47500000000000003}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.274}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.611}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.7900000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.8210000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.506}, "dynamo/test_repros": {"ReproTests": 29.606}, "dynamo/test_resume": {"ResumeFunctionTests": 0.423}, "dynamo/test_sdpa": {"TestSDPA": 0.49300000000000005}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.5850000000000001}, "dynamo/test_sources": {"SourceTests": 0.47}, "dynamo/test_structured_trace": {"StructuredTraceTest": 14.150999999999998}, "dynamo/test_subclasses": {"SubclassTests": 2.6809999999999983, "TestNestedTensor": 13.068}, "dynamo/test_subgraphs": {"SubGraphTests": 1.979999999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.096, "TraceRuleTests": 1.13}, "dynamo/test_unspec": {"UnspecTests": 10.423999999999998}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.556}, "export/test_converter": {"TestConverter": 0.278}, "export/test_db": {"ExampleTests": 2.7529999999999992}, "export/test_experimental": {"TestExperiment": 0.914}, "export/test_export": {"TestDynamismExpression": 0.449, "TestExport": 23.739999999999988, "TestExportCustomClass": 0.057, "TestOneOffModelExportResult": 1.2049999999999998}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.363, "NonStrictExportTestExport": 20.442999999999994}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.638}, "export/test_hop": {"TestHOPCUDA": 1.6649999999999996, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.081}, "export/test_pass_infra": {"TestPassInfra": 0.8260000000000002}, "export/test_passes": {"TestPasses": 10.71}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.744, "RetraceExportTestExport": 35.153}, "export/test_schema": {"TestSchema": 0.23700000000000002}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.5, "SerDesExportTestExport": 23.735999999999997}, "export/test_serialize": {"TestDeserialize": 6.881, "TestSaveLoad": 0.257, "TestSchemaVersioning": 0.027, "TestSerialize": 1.016, "TestSerializeCustomClass": 0.076}, "export/test_sparse": {"TestSparseProp": 52.24199999999989}, "export/test_tools": {"TestExportTools": 0.533}, "export/test_torchbind": {"TestCompileTorchbind": 0.446, "TestExportTorchbind": 1.9399999999999995, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.207}, "export/test_unflatten": {"TestUnflatten": 2.951}, "export/test_verifier": {"TestVerifier": 0.8630000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.550999999999998, "TestAOTDispatch": 0.43600000000000005, "TestAOTExport": 1.919999999999999, "TestAOTModuleSimplified": 0.5640000000000001, "TestPartitioning": 3.095}, "functorch/test_control_flow": {"TestControlFlow": 0.7540000000000002, "TestControlFlowTraced": 109.92500000000008}, "functorch/test_dims": {"TestMin": 13.262000000000002, "TestMinFunctorchOnly": 12.609}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.08600000000000003, "TestAutogradFunctionVmapAPICUDA": 0.017, "TestCompileTransformsCUDA": 4.402, "TestComposabilityCUDA": 0.139, "TestExamplesCorrectnessCUDA": 2.074, "TestFunctionalizeCUDA": 0.10200000000000004, "TestGradTransformCUDA": 0.9220000000000002, "TestHelpersCUDA": 0.01, "TestHessianCUDA": 0.058, "TestHigherOrderOperatorInteractionCUDA": 0.023, "TestJacCUDA": 0.7330000000000002, "TestJvpCUDA": 0.05500000000000002, "TestLinearizeCUDA": 0.24899999999999997, "TestMakeFunctional": 0.07100000000000001, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.6180000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.246}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.276, "RandomOpTestCase": 0.068, "ReduceTestCase": 0.062, "TestMemoryEfficientOpAuthoring": 7.155}, "functorch/test_minifier": {"TestMinifier": 0.384}, "functorch/test_ops": {"TestOperatorsCUDA": 4112.096999999984}, "functorch/test_parsing": {"TestAnonymousAxis": 0.654, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.6920000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6990000000000005, "TestTransformFailureCUDA": 0.093, "TestVmapAPI": 0.8160000000000001, "TestVmapBatchedGradientCUDA": 0.18400000000000008, "TestVmapDeviceTypeCUDA": 0.018000000000000002, "TestVmapNestedTensorCUDA": 0.031000000000000003, "TestVmapOperators": 2.350999999999996, "TestVmapOperatorsOpInfoCUDA": 273.21799999999905}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.4109999999998584}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.879}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 673.4349999999995, "AOTInductorTestABICompatibleCpuWithStackAllocation": 454.46899999999994, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 193.55099999999993, "AOTInductorTestABICompatibleCuda": 1283.4989999999998, "AOTInductorTestNonABICompatibleCpu": 1378.402, "AOTInductorTestNonABICompatibleCuda": 2075.627}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.689, "BenchmarkFusionCudaTest": 78.62700000000001, "BenchmarkMultiTemplateFusionCudaTest": 14.46}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.192999999999998, "FreezingCudaTests": 4.821999999999999}, "inductor/test_codecache": {"TestFxGraphCache": 117.67099999999998, "TestFxGraphCacheHashing": 0.769, "TestUtils": 3.377, "test_codecache": 3.591}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.212}, "inductor/test_compile_worker": {"TestCompileWorker": 5.0280000000000005}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 205.8950000000008, "TestCompiledAutograd": 156.713, "TestCustomOpWithCompiledAutograd": 0.3260000000000002}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 660.9429999999999, "CompiledOptimizerTests": 1372.9099999999996}, "inductor/test_config": {"TestInductorConfig": 5.399000000000001}, "inductor/test_control_flow": {"CondTests": 85.51600000000002, "WhileLoopTests": 36.269}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.0820000000000003}, "inductor/test_cpu_repro": {"CPUReproTests": 645.5740000000001}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1015.8320000000001, "TestCudaWrapper": 966.8050000000002}, "inductor/test_cuda_repro": {"CudaReproTests": 77.55200000000002}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 65.89399999999996}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.535}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.031}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 127.491}, "inductor/test_debug_trace": {"TestDebugTrace": 13.498}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.498}, "inductor/test_dependencies": {"TestDependencies": 0.20800000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 33.849}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 182.473, "EfficientConvBNEvalCudaTests": 118.711}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.645}, "inductor/test_flex_attention": {"TestFlexAttention": 406.47399999999993}, "inductor/test_foreach": {"ForeachTests": 293.38199999999995}, "inductor/test_fp8": {"TestFP8Types": 0.007}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 75.00999999999999, "SDPAPatternRewriterCpuTests": 70.08999999999999, "SDPAPatternRewriterCudaDynamicTests": 40.724000000000004, "SDPAPatternRewriterCudaTests": 32.958}, "inductor/test_fx_fusion": {"TestFxFusion": 0.174}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023, "TestGroupBatchFusion": 105.93799999999999, "TestPostGradBatchLinearFusion": 1.928}, "inductor/test_indexing": {"ExprPrinterTests": 0.049000000000000016, "TestIndexingSimplification": 0.52}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 48.284, "FreezingCudaTests": 33.56}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 6.9670000000000005}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 125.846}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.601000000000003}, "inductor/test_max_autotune": {"TestMaxAutotune": 230.70300000000003, "TestTuningProcess": 9.774000000000001}, "inductor/test_memory_planning": {"TestMemoryPlanning": 29.348}, "inductor/test_metrics": {"TestMetrics": 3.846}, "inductor/test_minifier": {"MinifierTests": 28.157000000000004}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 91.065}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 81.472, "TestPatternMatcher": 394.5429999999998}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.098999999999998}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.668}, "inductor/test_multi_kernel": {"MultiKernelTest": 71.37299999999999}, "inductor/test_pad_mm": {"PadMMTest": 122.96899999999998}, "inductor/test_padding": {"PaddingTest": 14.439000000000002, "PerfTestBetweenGoodAndBadShape": 0.002, "PerfTestWithAndWithoutPadding": 4.372}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 91.66800000000002}, "inductor/test_perf": {"FusionTests": 13.808999999999997, "InplacingTests": 5.690999999999999, "MinCutPartitioningTests": 10.891, "NoopTests": 0.9420000000000002, "NumBytesMetricTests": 25.086, "SchedulerFusionTests": 8.493, "TilingTests": 1.958}, "inductor/test_profiler": {"DynamoProfilerTests": 7.691000000000001}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 114.99699999999999}, "inductor/test_smoke": {"SmokeTest": 5.955}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.664, "MemoryBoundedTests": 3.1390000000000002, "TestCommAnalysis": 6.327, "UnsupportedTests": 0.317}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 98.03899999999999}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.154}, "inductor/test_torchbind": {"TestTorchbind": 6.235}, "inductor/test_torchinductor": {"CpuTests": 1513.6520000000005, "GPUTests": 879.6239999999998, "NanCheckerTest": 0.882, "RNNTest": 0.016, "SweepInputsCpuTest": 113.02899999999998, "SweepInputsGPUTest": 28.633000000000003, "TestFull": 9.982, "TritonCodeGenTests": 179.992}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1622.6760000000004, "DynamicShapesCodegenGPUTests": 985.6289999999995}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1729.6979999999999, "DynamicShapesGPUTests": 1316.9360000000001, "TestInductorDynamicCUDA": 42.031000000000006}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1643.2669999999985}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.533}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.005}, "inductor/test_triton_kernels": {"KernelTests": 93.89999999999993, "MutationTests": 0.2880000000000001}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 7.267}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 19.183}, "inductor/test_utils": {"TestUtils": 0.211}, "lazy/test_debug_util": {"DebugUtilTest": 0.674}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.6960000000000001}, "lazy/test_generator": {"LazyGeneratorTest": 0.717}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.8400000000000001}, "lazy/test_step_closures": {"ClosuresTest": 2.6569999999999996}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.176, "TestLazyTensor": 0.543}, "nn/test_convolution": {"TestConvolutionNN": 20.222, "TestConvolutionNNDeviceTypeCUDA": 51.24799999999944}, "nn/test_dropout": {"TestDropoutNN": 0.556, "TestDropoutNNDeviceTypeCUDA": 0.467}, "nn/test_embedding": {"TestEmbeddingNN": 0.5820000000000001, "TestEmbeddingNNDeviceTypeCUDA": 9.822000000000005}, "nn/test_init": {"TestNNInit": 3.941999999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.7970000000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.0279999999999994, "TestLoadStateDictSwap": 0.044}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.016, "TestModuleHookNN": 0.054000000000000006, "TestModuleHooks": 0.6, "TestStateDictHooks": 0.011000000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 4.697000000000001, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.265}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.9229999999999994}, "nn/test_parametrization": {"TestNNParametrization": 1.149999999999999, "TestNNParametrizationDeviceCUDA": 0.137}, "nn/test_pooling": {"TestAvgPool": 0.673, "TestPoolingNN": 0.65, "TestPoolingNNDeviceTypeCUDA": 4.524999999999996}, "nn/test_pruning": {"TestPruningNN": 0.49700000000000005}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.235}, "profiler/test_memory_profiler": {"TestDataFlow": 1.1, "TestIdentifyGradients": 0.279, "TestMemoryProfiler": 0.666, "TestMemoryProfilerE2E": 2.5489999999999995}, "profiler/test_profiler": {"TestExperimentalUtils": 3.9609999999999994, "TestProfiler": 18.601999999999993, "TestProfilerCUDA": 5.6690000000000005, "TestProfilerITT": 0.002}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.7030000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.673}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.8229999999999995}, "test_ao_sparsity": {"TestActivationSparsifier": 0.058, "TestBaseDataScheduler": 0.024, "TestBaseDataSparsifier": 0.05500000000000001, "TestBaseSparsifier": 0.020999999999999998, "TestBaseStructuredSparsifier": 2.960999999999999, "TestComposability": 1.5199999999999998, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.062, "TestFakeSparsity": 0.05700000000000001, "TestFxComposability": 1.412, "TestNearlyDiagonalSparsifier": 0.67, "TestNormDataSparsifiers": 0.724, "TestQuantizationUtils": 0.013000000000000001, "TestQuantizedSparseKernels": 0.379, "TestQuantizedSparseLayers": 0.33399999999999996, "TestSaliencyPruner": 0.02, "TestScheduler": 0.011000000000000001, "TestSparsityUtilFunctions": 0.026000000000000002, "TestWeightNormSparsifier": 0.28}, "test_autocast": {"TestAutocastCPU": 1.963, "TestAutocastGPU": 0.213, "TestTorchAutocast": 0.004}, "test_autograd": {"TestAllowMutationOnSaved": 0.024, "TestAutograd": 16.037999999999982, "TestAutogradComplex": 0.004, "TestAutogradDeviceTypeCUDA": 2.136999999999999, "TestAutogradForwardMode": 0.056000000000000036, "TestAutogradForwardModeBatchedGrad": 0.011, "TestAutogradFunctional": 8.456999999999999, "TestAutogradInferenceMode": 0.02600000000000001, "TestAutogradLogging": 0.012, "TestAutogradMultipleDispatchCUDA": 0.017000000000000005, "TestMultithreadAutograd": 0.18400000000000005, "TestNestedCheckpoint": 0.3530000000000001}, "test_autograd_fallback": {"TestAutogradFallback": 0.7280000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 192.01099999999084}, "test_bundled_inputs": {"TestBundledInputs": 1.3269999999999995}, "test_comparison_utils": {"TestComparisonUtils": 0.64}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.528}, "test_content_store": {"TestContentStoreCUDA": 2.5949999999999998}, "test_cpp_api_parity": {"TestCppApiParity": 8.555999999999987}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.6880000000000001, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.657, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.045}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 165.61800000000002}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.42}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.662000000000003}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.419}, "test_cuda": {"TestBlockStateAbsorption": 5.684, "TestCuda": 106.77000000000005, "TestCudaMallocAsync": 10.338000000000001, "TestCudaOptimsCUDA": 0.07}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.635, "TestCuda": 101.769, "TestCudaMallocAsync": 13.82, "TestCudaOptimsCUDA": 0.139}, "test_cuda_multigpu": {"TestCudaComm": 0.023000000000000007, "TestCudaMultiGPU": 1.2999999999999994}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.7620000000000005, "TestVisibleDeviceParses": 1.268}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.248}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.7060000000000001, "TestEventHandler": 0.02000000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 6.628000000000001}, "test_custom_ops": {"MiniOpTest": 0.5860000000000002, "MiniOpTestOther": 0.04400000000000001, "TestCustomOp": 2.1579999999999924, "TestCustomOpAPI": 0.10500000000000004, "TestCustomOpTestingCUDA": 1.763, "TestGenerateOpcheckTests": 2.972}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 86.788, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.047, "TestCustomPinFn": 0.111, "TestDataLoader": 80.06900000000002, "TestDataLoaderDeviceTypeCUDA": 12.055, "TestDataLoaderPersistentWorkers": 109.25500000000002, "TestDatasetRandomSplit": 0.446, "TestDictDataLoader": 0.033, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004, "TestSetAffinity": 0.041, "TestStackDataset": 0.021000000000000005, "TestStringDataLoader": 0.051, "TestTensorDataset": 0.016}, "test_datapipe": {"TestCaptureDataFrame": 0.003, "TestCircularSerialization": 0.006, "TestDataChunk": 0.442, "TestDataFramesPipes": 0.458, "TestFunctionalIterDataPipe": 3.351999999999999, "TestFunctionalMapDataPipe": 0.025999999999999995, "TestGraph": 0.010000000000000002, "TestIterDataPipeCountSampleYielded": 0.006, "TestIterDataPipeGraphFastForward": 0.034, "TestIterDataPipeSingletonConstraint": 0.016, "TestIterableDataPipeBasic": 0.023, "TestSerialization": 5.109999999999999, "TestSharding": 0.18900000000000003, "TestStreamWrapper": 0.212, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.030000000000000006, "HasDecompTest": 0.13, "TestDecompCUDA": 12520.615000000023}, "test_deploy": {"TestFreezer": 0.638}, "test_dispatch": {"TestDispatch": 32.45700000000001, "TestPythonDispatcher": 0.029}, "test_dlpack": {"TestTorchDlPackCUDA": 0.7640000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 1.8, "TestFloorDiv": 0.046000000000000006, "TestPySymInt": 1.1989999999999996, "TestSymNumberMagicMethods": 1.0879999999999992}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 2.5659999999999985, "TestExpandedWeightHelperFunctionCUDA": 0.461, "TestExpandedWeightModuleCUDA": 9.040000000000003}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04300000000000001, "FakeTensorConverterTest": 0.018, "FakeTensorDispatchCache": 0.06200000000000001, "FakeTensorOpInfoTestCUDA": 0.07300000000000001, "FakeTensorOperatorInvariants": 0.45500000000000007, "FakeTensorPropTest": 0.055999999999999994, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.533999999999998, "PropagateRealTensorsFakeTensorConstHandling": 0.069, "PropagateRealTensorsFakeTensorConverterTest": 0.016, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.152, "PropagateRealTensorsFakeTensorPropTest": 0.041, "PropagateRealTensorsFakeTensorTest": 10.077000000000018}, "test_flop_counter": {"TestFlopCounter": 0.611}, "test_foreach": {"TestForeachCUDA": 387.1130000000071}, "test_function_schema": {"TestFunctionSchema": 0.883}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 16.306}, "test_functional_optim": {"TestFunctionalOptimParity": 0.28800000000000003}, "test_functionalization": {"TestCrossRefFunctionalization": 1.697999999999999, "TestFunctionalization": 2.2299999999999986}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.298}, "test_futures": {"TestFuture": 1.257}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.19800000000000004, "TestCommonPass": 0.14100000000000007, "TestConstFold": 0.12500000000000003, "TestConstParamShapeInControlFlow": 0.030000000000000002, "TestDCE": 0.020999999999999998, "TestFX": 2.2379999999999978, "TestFXAPIBackwardCompatibility": 0.02, "TestFunctionalTracing": 0.23200000000000018, "TestMatcher": 0.31400000000000006, "TestOperatorSignaturesCUDA": 0.6730000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.9430000000000001, "TestSubgraphRewriter": 0.21800000000000008, "TestVisionTracing": 209.85700000000003, "TypeCheckerTest": 1.566999999999998}, "test_fx_experimental": {"TestFXExperimental": 11.437000000000003, "TestNormalizeOperatorsCUDA": 1.3090000000000008, "TestTranslationValidation": 0.10899999999999999}, "test_fx_passes": {"TestFXGraphPasses": 0.9310000000000002, "TestFXMatcherUtils": 0.06900000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.7740000000000001}, "test_import_stats": {"TestImportTime": 3.6559999999999997}, "test_indexing": {"NumpyTestsCUDA": 0.12200000000000003, "TestIndexingCUDA": 2.408999999999993}, "test_itt": {"TestItt": 0.628}, "test_jit": {"TestAliasAnalysis": 0.258, "TestAsync": 0.24400000000000002, "TestAtenPow": 0.006, "TestAutodiffJit": 0.046, "TestAutodiffSubgraphSlicing": 0.20200000000000007, "TestAwait": 0.14700000000000002, "TestBackends": 0.507, "TestBackendsWithCompiler": 0.107, "TestBatchMM": 0.060000000000000005, "TestBuiltins": 0.042, "TestCUDA": 0.5700000000000001, "TestClassType": 1.8879999999999992, "TestComplex": 0.5920000000000001, "TestCustomOperators": 0.023000000000000007, "TestDCE": 0.013999999999999999, "TestDataParallel": 0.0, "TestDataclasses": 3.3379999999999996, "TestDeviceAnalysis": 3.024, "TestDict": 0.28000000000000014, "TestDtypeAnalysis": 0.11099999999999999, "TestEnum": 0.14600000000000002, "TestFreezing": 1.7320000000000002, "TestFrontend": 0.32, "TestFrozenOptimizations": 8.043, "TestFunctionalBlocks": 0.005, "TestFunctionalToInplaceActivation": 1.645, "TestGenerator": 0.047, "TestGetDefaultAttr": 0.012, "TestGraphRewritePasses": 0.028, "TestHash": 0.051, "TestHooks": 0.4770000000000002, "TestIgnorableArgs": 0.007, "TestIgnoreContextManager": 0.03, "TestInplaceToFunctionalActivation": 1.517, "TestIsinstance": 0.14400000000000007, "TestJit": 4.101999999999996, "TestJitGeneratedModule": 8.205999999999994, "TestJitProfiler": 0.001, "TestJitUtils": 0.010000000000000002, "TestList": 0.8550000000000003, "TestLogging": 0.036, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.36900000000000005, "TestMixTracingScripting": 0.9560000000000001, "TestModels": 4.313999999999999, "TestModuleAPIs": 0.091, "TestModuleContainers": 0.8550000000000002, "TestModuleInterface": 0.35100000000000015, "TestModules": 0.01, "TestNamedTuple": 0.04400000000000001, "TestNnapiBackend": 8.689999999999998, "TestOpDecompositions": 0.012, "TestOptimizeForMobilePreserveDebugInfo": 0.126, "TestParametrization": 0.06, "TestPeephole": 0.2980000000000001, "TestProducerVersion": 0.001, "TestProfiler": 0.442, "TestPythonBindings": 0.02, "TestPythonBuiltinOP": 0.254, "TestPythonIr": 0.016, "TestRecursiveScript": 0.49200000000000016, "TestRemoveMutation": 0.085, "TestSaveLoad": 0.333, "TestSaveLoadFlatbuffer": 0.39, "TestSaveLoadForOpVersion": 1.7929999999999997, "TestScript": 31.165000000000024, "TestScriptDict": 0.014000000000000002, "TestScriptList": 0.023, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.12800000000000006, "TestScriptProfile": 0.272, "TestSlice": 0.10500000000000002, "TestSparse": 0.035, "TestStringFormatting": 0.08100000000000004, "TestSymbolicShapeAnalysis": 0.9460000000000002, "TestTensorBuiltins": 0.068, "TestTensorCreationOps": 0.033, "TestTensorMethods": 0.008, "TestTorchbind": 0.13000000000000006, "TestTracer": 3.530999999999994, "TestTypeSharing": 0.3330000000000001, "TestTypesAndAnnotation": 0.081, "TestTyping": 0.25700000000000006, "TestUnion": 0.30000000000000016, "TestUnsupportedOps": 0.019, "TestUpgraders": 0.044, "TestWarn": 0.034, "TestWith": 0.23399999999999999}, "test_jit_autocast": {"TestAutocast": 1.128, "TestJitTraceAutocast": 25.788}, "test_jit_disabled": {"TestJitDisabled": 0.7170000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.115, "TestNNCOpInfoCUDA": 12.554000000000853, "TestTEFuserDynamic": 544.0439999999999, "TestTEFuserStatic": 487.26600000000013}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.057, "TestFusionPatternCUDA": 0.0, "TestModel": 0.004, "TestOpCUDA": 0.0}, "test_jiterator": {"TestPythonJiteratorCUDA": 19.580000000000016}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2819999999999985, "TestVmapBatchedGradientLegacyCUDA": 0.3550000000000001, "TestVmapOperatorsLegacy": 0.6760000000000002}, "test_license": {"TestLicense": 0.642}, "test_linalg": {"TestLinalgCUDA": 1509.3409999999892}, "test_logging": {"LoggingTest": 2.752}, "test_masked": {"TestMaskedCUDA": 39.32600000000002}, "test_maskedtensor": {"TestBasicsCUDA": 0.199, "TestBinary": 0.2560000000000001, "TestOperatorsCUDA": 6.048999999999894, "TestReductions": 0.05600000000000001, "TestUnary": 0.6640000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.004, "TestMatmulCudaCUDA": 87.03100000000002, "TestMixedDtypesLinearCudaCUDA": 0.727}, "test_meta": {"TestMetaCUDA": 1628.5289999996116, "TestMetaConverter": 0.8420000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 3.8659999999999997}, "test_mkldnn_fusion": {"TestMkldnnFusion": 34.78}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.529}, "test_mobile_optimizer": {"TestOptimizer": 2.597}, "test_model_dump": {"TestModelDump": 1.172}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.198}, "test_module_tracker": {"TestModuleTracker": 0.646}, "test_modules": {"TestModuleCUDA": 2547.987000000032}, "test_monitor": {"TestMonitor": 0.628, "TestMonitorTensorboard": 0.298}, "test_multiprocessing": {"TestMultiprocessing": 85.56800000000001}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.52, "SpawnTest": 18.813000000000002}, "test_namedtensor": {"TestNamedTensor": 1.0879999999999999}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.97}, "test_native_functions": {"TestNativeFunctions": 0.7120000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.9590000000000004}, "test_nestedtensor": {"TestNestedTensor": 0.11500000000000006, "TestNestedTensorAutogradCUDA": 1.128, "TestNestedTensorDeviceTypeCUDA": 1.2299999999999973, "TestNestedTensorSubclassCUDA": 6.484999999999993}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.249, "TestFusionUtils": 0.004, "TestNN": 45.793000000000085, "TestNNDeviceTypeCUDA": 122.03600000000422, "TestUtils": 0.003}, "test_numba_integration": {"TestNumbaIntegration": 0.529}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.5950000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 3.928}, "test_ops": {"TestCommonCUDA": 1753.0479999999875, "TestCompositeComplianceCUDA": 679.1759999999977, "TestFakeTensorCUDA": 531.570999999998, "TestMathBitsCUDA": 44.61700000000006, "TestSelfKwarg": 0.398, "TestTagsCUDA": 1.605000000000001}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 475.1170000000043}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1808.4939999998746}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.017, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.003, "TestResolveName": 0.088, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 2.133999999999891, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.022, "TestPythonDispatch": 0.18500000000000008, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2429999999999997, "TestWrapperSubclassAliasingCUDA": 0.10400000000000004}, "test_reductions": {"TestReductionsCUDA": 133.6980000000013}, "test_serialization": {"TestSerialization": 5.921}, "test_show_pickle": {"TestShowPickle": 0.646}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.7869999999999964}, "test_spectral_ops": {"TestFFTCUDA": 18.640999999999966}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4130000000000003, "TestLikeTensorCreationCUDA": 0.007, "TestRandomTensorCreationCUDA": 0.12500000000000003, "TestTensorCreationCUDA": 76.69900000000031}, "test_tensorexpr": {"TestTensorExprFuser": 114.41600000000001}, "test_torch": {"TestBasicVitalSigns": 0.024999999999999998, "TestDevicePrecisionCUDA": 0.05400000000000001, "TestTorch": 4.661999999999989, "TestTorchDeviceTypeCUDA": 82.90900000000003, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.052, "TestBottleneck": 9.895999999999999, "TestCheckpoint": 0.30600000000000005, "TestCollectEnv": 0.983, "TestCppExtensionUtils": 0.032, "TestDataLoaderUtils": 0.275, "TestDeviceUtilsCUDA": 11.751000000000577, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.006, "TestONNXUtils": 0.003, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.331, "TestTraceback": 0.006}}, "dynamo_eager_huggingface": {"backends/xeon/test_launch": {"TestTorchrun": 2.148}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.148}, "distributions/test_distributions": {"TestAgainstScipy": 1.045, "TestConstraints": 0.128, "TestDistributionShapes": 0.10600000000000005, "TestDistributions": 43.568999999999996, "TestFunctors": 0.008, "TestJit": 19.159, "TestKL": 2.5369999999999995, "TestLazyLogitsInitialization": 0.011, "TestNumericalStability": 0.05900000000000001, "TestRsample": 0.607, "TestValidation": 0.30500000000000005}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 19.008000000000003}, "dynamo/test_after_aot": {"TestAfterAot": 4.779}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 12.900999999999998}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9720000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.4030000000000005}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.032, "TestCustomBackendAPI": 1.718, "TestExplainWithBackend": 8.419, "TestOptimizations": 1.7619999999999996}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 11.874}, "dynamo/test_base_output": {"TestBaseOutput": 0.002}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.307, "BytecodeTests": 0.442}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.460000000000001, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.5860000000000001}, "dynamo/test_config": {"ConfigTests": 0.566}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.0419999999999985}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.3989999999999996}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.323}, "dynamo/test_decorators": {"DecoratorTests": 0.6480000000000001}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.015}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 23.355999999999998, "DynamicShapesCtxManagerTests": 4.223000000000001, "DynamicShapesExportTests": 1286.2280000000003, "DynamicShapesFuncTorchHigherOrderOpTests": 96.07599999999995, "DynamicShapesFunctionTests": 16.513999999999996, "DynamicShapesHigherOrderOpTests": 15.071, "DynamicShapesMiscTests": 44.85000000000001, "DynamicShapesNNModuleTests": 2.7030000000000007, "DynamicShapesReproTests": 25.663000000000004, "DynamicShapesSubGraphTests": 8.792, "DynamicShapesTestSDPA": 0.313}, "dynamo/test_exc": {"ExcTests": 1.8529999999999998}, "dynamo/test_export": {"ExportTests": 13.659}, "dynamo/test_export_mutations": {"MutationExportTests": 0.545}, "dynamo/test_frame_init": {"FrameInitTests": 0.2}, "dynamo/test_functions": {"DefaultsTests": 0.6790000000000003, "FunctionTests": 19.492000000000026}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.155}, "dynamo/test_global": {"TestGlobals": 0.507}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.22700000000000004}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.077999999999999, "FuncTorchHigherOrderOpTests": 9.529000000000003, "HigherOrderOpTests": 6.758999999999997, "HigherOrderOpVmapGuardTests": 3.5990000000000006}, "dynamo/test_hooks": {"HooksTests": 23.18900000000001}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.3889999999999985}, "dynamo/test_interop": {"InteropTests": 0.5409999999999999}, "dynamo/test_logging": {"LoggingTests": 18.495999999999995}, "dynamo/test_minifier": {"MinifierTests": 2.0810000000000004}, "dynamo/test_misc": {"MiscTests": 47.220000000000084, "TestTracer": 0.047}, "dynamo/test_model_output": {"TestHFPretrained": 0.409, "TestModelOutput": 0.21800000000000003}, "dynamo/test_modules": {"NNModuleTests": 2.6589999999999976, "OptimizedModuleTest": 7.8439999999999985}, "dynamo/test_nops": {"NopTests": 0.28900000000000003}, "dynamo/test_optimizers": {"End2EndTests": 0.624}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.468}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.2530000000000001}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.618}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.7990000000000002}, "dynamo/test_recompiles": {"RecompileTests": 0.782}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.528}, "dynamo/test_repros": {"ReproTests": 29.443000000000026}, "dynamo/test_resume": {"ResumeFunctionTests": 0.45}, "dynamo/test_sdpa": {"TestSDPA": 0.46900000000000003}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.5880000000000001}, "dynamo/test_sources": {"SourceTests": 0.476}, "dynamo/test_structured_trace": {"StructuredTraceTest": 14.097}, "dynamo/test_subclasses": {"SubclassTests": 2.6659999999999995, "TestNestedTensor": 12.967000000000004}, "dynamo/test_subgraphs": {"SubGraphTests": 2.0189999999999992}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.097, "TraceRuleTests": 1.144}, "dynamo/test_unspec": {"UnspecTests": 10.466000000000001}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.56}, "export/test_converter": {"TestConverter": 0.28}, "export/test_db": {"ExampleTests": 2.828}, "export/test_experimental": {"TestExperiment": 0.904}, "export/test_export": {"TestDynamismExpression": 0.43, "TestExport": 23.28099999999999, "TestExportCustomClass": 0.061, "TestOneOffModelExportResult": 1.239}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.359, "NonStrictExportTestExport": 20.341000000000005}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.626}, "export/test_hop": {"TestHOPCUDA": 1.648, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.079}, "export/test_pass_infra": {"TestPassInfra": 0.8200000000000002}, "export/test_passes": {"TestPasses": 10.873000000000001}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.75, "RetraceExportTestExport": 35.40999999999998}, "export/test_schema": {"TestSchema": 0.23900000000000002}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.499, "SerDesExportTestExport": 23.577999999999985}, "export/test_serialize": {"TestDeserialize": 6.761, "TestSaveLoad": 0.252, "TestSchemaVersioning": 0.026, "TestSerialize": 0.9870000000000001, "TestSerializeCustomClass": 0.074}, "export/test_sparse": {"TestSparseProp": 53.16499999999989}, "export/test_tools": {"TestExportTools": 0.536}, "export/test_torchbind": {"TestCompileTorchbind": 0.455, "TestExportTorchbind": 1.9939999999999989, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.213}, "export/test_unflatten": {"TestUnflatten": 3.004}, "export/test_verifier": {"TestVerifier": 0.8970000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.944999999999993, "TestAOTDispatch": 0.43400000000000005, "TestAOTExport": 1.975, "TestAOTModuleSimplified": 0.559, "TestPartitioning": 3.1479999999999997}, "functorch/test_control_flow": {"TestControlFlow": 0.7600000000000002, "TestControlFlowTraced": 109.53100000000009}, "functorch/test_dims": {"TestMin": 13.205000000000002, "TestMinFunctorchOnly": 12.542}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.06900000000000003, "TestAutogradFunctionVmapAPICUDA": 0.015000000000000003, "TestCompileTransformsCUDA": 4.43, "TestComposabilityCUDA": 0.13500000000000004, "TestExamplesCorrectnessCUDA": 2.012, "TestFunctionalizeCUDA": 0.09300000000000003, "TestGradTransformCUDA": 0.8730000000000001, "TestHelpersCUDA": 0.009000000000000001, "TestHessianCUDA": 0.053, "TestHigherOrderOperatorInteractionCUDA": 0.021000000000000005, "TestJacCUDA": 0.7010000000000003, "TestJvpCUDA": 0.04500000000000001, "TestLinearizeCUDA": 0.23799999999999996, "TestMakeFunctional": 0.06400000000000002, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.014000000000000002, "TestVmapOfGradCUDA": 0.5850000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.244}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.28300000000000003, "RandomOpTestCase": 0.07, "ReduceTestCase": 0.063, "TestMemoryEfficientOpAuthoring": 7.182}, "functorch/test_minifier": {"TestMinifier": 0.3760000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 4103.409999999989}, "functorch/test_parsing": {"TestAnonymousAxis": 0.64, "TestParsedExpression": 0.004, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.6880000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6840000000000005, "TestTransformFailureCUDA": 0.092, "TestVmapAPI": 0.798, "TestVmapBatchedGradientCUDA": 0.18000000000000008, "TestVmapDeviceTypeCUDA": 0.017, "TestVmapNestedTensorCUDA": 0.031000000000000003, "TestVmapOperators": 2.278999999999997, "TestVmapOperatorsOpInfoCUDA": 264.113999999999}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.4299999999998563}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.777}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 671.6129999999999, "AOTInductorTestABICompatibleCpuWithStackAllocation": 450.5639999999995, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 190.73699999999988, "AOTInductorTestABICompatibleCuda": 1272.4130000000002, "AOTInductorTestNonABICompatibleCpu": 1364.9239999999984, "AOTInductorTestNonABICompatibleCuda": 2047.9109999999994}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.66, "BenchmarkFusionCudaTest": 78.767, "BenchmarkMultiTemplateFusionCudaTest": 14.448}, "inductor/test_binary_folding": {"FreezingCpuTests": 29.240000000000002, "FreezingCudaTests": 4.807}, "inductor/test_codecache": {"TestFxGraphCache": 116.75700000000002, "TestFxGraphCacheHashing": 0.755, "TestUtils": 3.346, "test_codecache": 2.9050000000000002}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.221}, "inductor/test_compile_worker": {"TestCompileWorker": 5.032}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 203.37400000000082, "TestCompiledAutograd": 155.008, "TestCustomOpWithCompiledAutograd": 0.3280000000000002}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 643.217, "CompiledOptimizerTests": 1357.446999999999}, "inductor/test_config": {"TestInductorConfig": 5.304000000000001}, "inductor/test_control_flow": {"CondTests": 85.007, "WhileLoopTests": 35.377}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.251}, "inductor/test_cpu_repro": {"CPUReproTests": 635.4659999999997}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1003.9060000000001, "TestCudaWrapper": 959.9130000000001}, "inductor/test_cuda_repro": {"CudaReproTests": 77.79999999999997}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 65.123}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.5650000000000004}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.206}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 126.67000000000004}, "inductor/test_debug_trace": {"TestDebugTrace": 13.341}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 33.389}, "inductor/test_dependencies": {"TestDependencies": 0.198}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 33.824}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 180.619, "EfficientConvBNEvalCudaTests": 118.487}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.527}, "inductor/test_flex_attention": {"TestFlexAttention": 407.30299999999994}, "inductor/test_foreach": {"ForeachTests": 296.274}, "inductor/test_fp8": {"TestFP8Types": 0.008}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 72.28, "SDPAPatternRewriterCpuTests": 69.33199999999998, "SDPAPatternRewriterCudaDynamicTests": 41.843999999999994, "SDPAPatternRewriterCudaTests": 33.56499999999999}, "inductor/test_fx_fusion": {"TestFxFusion": 0.18}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.027, "TestGroupBatchFusion": 105.43, "TestPostGradBatchLinearFusion": 1.925}, "inductor/test_indexing": {"ExprPrinterTests": 0.049000000000000016, "TestIndexingSimplification": 0.514}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 47.39600000000001, "FreezingCudaTests": 33.17999999999999}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 6.992}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 124.23999999999998}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.485999999999999}, "inductor/test_max_autotune": {"TestMaxAutotune": 230.785, "TestTuningProcess": 10.092}, "inductor/test_memory_planning": {"TestMemoryPlanning": 29.128}, "inductor/test_metrics": {"TestMetrics": 3.795000000000001}, "inductor/test_minifier": {"MinifierTests": 28.292999999999996}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 90.013}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 79.001, "TestPatternMatcher": 400.5789999999999}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.004999999999999}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.876999999999999}, "inductor/test_multi_kernel": {"MultiKernelTest": 72.425}, "inductor/test_pad_mm": {"PadMMTest": 125.57700000000001}, "inductor/test_padding": {"PaddingTest": 14.508999999999997, "PerfTestBetweenGoodAndBadShape": 0.001, "PerfTestWithAndWithoutPadding": 4.304}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 91.27699999999999}, "inductor/test_perf": {"FusionTests": 13.456, "InplacingTests": 5.8149999999999995, "MinCutPartitioningTests": 10.884, "NoopTests": 0.9140000000000001, "NumBytesMetricTests": 24.424, "SchedulerFusionTests": 8.705, "TilingTests": 2.202}, "inductor/test_profiler": {"DynamoProfilerTests": 7.897}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 114.39500000000001}, "inductor/test_smoke": {"SmokeTest": 6.198}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 3.6770000000000005, "MemoryBoundedTests": 3.1000000000000005, "TestCommAnalysis": 6.449999999999999, "UnsupportedTests": 0.314}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 98.37}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.042}, "inductor/test_torchbind": {"TestTorchbind": 6.15}, "inductor/test_torchinductor": {"CpuTests": 0.001, "GPUTests": 17.67}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 0.001, "DynamicShapesCodegenGPUTests": 15.598}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 0.001, "DynamicShapesGPUTests": 9.139}, "nn/test_convolution": {"TestConvolutionNN": 20.523999999999997, "TestConvolutionNNDeviceTypeCUDA": 50.47399999999945}, "nn/test_pooling": {"TestAvgPool": 0.7280000000000001, "TestPoolingNN": 0.644, "TestPoolingNNDeviceTypeCUDA": 4.485999999999997}, "profiler/test_profiler": {"TestProfiler": 0.7050000000000001}, "test_autocast": {"TestAutocastCPU": 1.9289999999999998, "TestAutocastGPU": 0.199, "TestTorchAutocast": 0.003}, "test_autograd_fallback": {"TestAutogradFallback": 0.7270000000000001}, "test_cpp_api_parity": {"TestCppApiParity": 8.567999999999994}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.6890000000000001, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.655, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.045}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 164.07500000000002}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.421}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.468000000000001}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.421}, "test_cuda": {"TestCuda": 14.454}, "test_cuda_expandable_segments": {"TestCuda": 16.115}, "test_cuda_multigpu": {"TestCudaMultiGPU": 0.854}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 2.758, "TestVisibleDeviceParses": 1.268}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.259}, "test_cuda_trace": {"TestCudaTrace": 6.718000000000002}, "test_dispatch": {"TestDispatch": 32.777000000000015, "TestPythonDispatcher": 0.028999999999999998}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.017, "FakeTensorDispatchCache": 0.06300000000000001, "FakeTensorOpInfoTestCUDA": 0.07400000000000001, "FakeTensorOperatorInvariants": 0.44700000000000006, "FakeTensorPropTest": 0.055999999999999994, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.565999999999997, "PropagateRealTensorsFakeTensorConstHandling": 0.069, "PropagateRealTensorsFakeTensorConverterTest": 0.016, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.154, "PropagateRealTensorsFakeTensorPropTest": 0.04, "PropagateRealTensorsFakeTensorTest": 10.049000000000015}, "test_fx": {"AnnotationsTest": 0.011000000000000003, "TestCSEPass": 0.20400000000000004, "TestCommonPass": 0.14200000000000004, "TestConstFold": 0.12100000000000004, "TestConstParamShapeInControlFlow": 0.030000000000000002, "TestDCE": 0.020999999999999998, "TestFX": 2.200999999999998, "TestFXAPIBackwardCompatibility": 0.02, "TestFunctionalTracing": 0.23400000000000018, "TestMatcher": 0.31700000000000006, "TestOperatorSignaturesCUDA": 0.6840000000000005, "TestPassManager": 0.018000000000000002, "TestSourceMatcher": 0.965, "TestSubgraphRewriter": 0.22100000000000009, "TestVisionTracing": 211.06700000000004, "TypeCheckerTest": 1.562999999999998}, "test_indexing": {"TestIndexingCUDA": 0.563}, "test_jit_disabled": {"TestJitDisabled": 0.7160000000000001}, "test_linalg": {"TestLinalgCUDA": 13.406}, "test_mobile_optimizer": {"TestOptimizer": 2.5109999999999997}, "test_multiprocessing": {"TestMultiprocessing": 85.852}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.493, "SpawnTest": 18.933999999999997}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.964}, "test_native_mha": {"TestMHADeviceTypeCUDA": 1.0340000000000003}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.255, "TestFusionUtils": 0.004, "TestNN": 45.08700000000008, "TestNNDeviceTypeCUDA": 120.43900000000428, "TestUtils": 0.003}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.016, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.006, "TestResolveName": 0.098, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 2.1279999999998913, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.022, "TestPythonDispatch": 0.18900000000000006, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2449999999999994, "TestWrapperSubclassAliasingCUDA": 0.22000000000000003}, "test_reductions": {"TestReductionsCUDA": 131.85900000000242}, "test_serialization": {"TestSerialization": 5.829}, "test_show_pickle": {"TestShowPickle": 0.636}, "test_sort_and_select": {"TestSortAndSelectCUDA": 4.091999999999995}, "test_spectral_ops": {"TestFFTCUDA": 18.36799999999996}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4230000000000003, "TestLikeTensorCreationCUDA": 0.007, "TestRandomTensorCreationCUDA": 0.12900000000000003, "TestTensorCreationCUDA": 81.06900000000032}, "test_tensorexpr": {"TestTensorExprFuser": 113.64400000000002}, "test_torch": {"TestBasicVitalSigns": 0.022, "TestDevicePrecisionCUDA": 0.05400000000000001, "TestTorch": 4.659999999999989, "TestTorchDeviceTypeCUDA": 82.19300000000003, "TestVitalSignsCudaCUDA": 0.001}, "test_utils": {"TestAssert": 0.052, "TestBottleneck": 10.193, "TestCheckpoint": 0.30000000000000004, "TestCollectEnv": 0.986, "TestCppExtensionUtils": 0.033, "TestDataLoaderUtils": 0.24000000000000002, "TestDeviceUtilsCUDA": 11.734000000000579, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.004, "TestONNXUtils": 0.003, "TestRenderUtils": 0.011, "TestStandaloneCPPJIT": 2.216, "TestTraceback": 0.006}}, "dynamo_eager_timm": {"distributions/test_distributions": {"TestAgainstScipy": 0.0, "TestConstraints": 38.474000000000004, "TestDistributionShapes": 47.162000000000006, "TestDistributions": 0.002, "TestFunctors": 2.175, "TestJit": 182.14899999999997, "TestKL": 0.001, "TestLazyLogitsInitialization": 38.596000000000004, "TestNumericalStability": 0.0, "TestRsample": 0.0, "TestValidation": 45.501999999999995}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.20999999999999996, "RandomOpTestCase": 0.415, "ReduceTestCase": 0.5640000000000001, "TestMemoryEfficientOpAuthoring": 8.332}, "nn/test_convolution": {"TestConvolutionNN": 14.782, "TestConvolutionNNDeviceTypeCUDA": 5.566}, "profiler/test_profiler": {"TestProfiler": 15.439}, "test_cuda": {"TestCuda": 14.914}}, "dynamo_eager_torchbench": {"distributions/test_distributions": {"TestAgainstScipy": 0.0, "TestConstraints": 38.837, "TestDistributionShapes": 47.344, "TestDistributions": 0.002, "TestFunctors": 2.179, "TestJit": 184.125, "TestKL": 0.001, "TestLazyLogitsInitialization": 38.965999999999994, "TestNumericalStability": 0.0, "TestRsample": 0.0, "TestValidation": 46.004}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.21299999999999997, "RandomOpTestCase": 0.417, "ReduceTestCase": 0.569, "TestMemoryEfficientOpAuthoring": 8.378}, "nn/test_convolution": {"TestConvolutionNN": 15.157, "TestConvolutionNNDeviceTypeCUDA": 5.731999999999999}, "profiler/test_profiler": {"TestProfiler": 15.479999999999999}, "test_cuda": {"TestCuda": 14.826000000000004}}}, "cuda12.1-py3.12-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 3.318}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 3.205, "TestFullyShardCollectiveOps": 88.2, "TestFullyShardCommunication": 6.6129999999999995, "TestFullyShardPrefetch": 9.916, "TestFullyShardUnshardMultiProcess": 3.305, "TestFullyShardUnshardMultiThread": 0.014}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 9.945}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 6.665}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 3.317, "TestFullyShard1DTrainingCore": 3.3169999999999997, "TestFullyShard2DTraining": 6.635, "TestFullyShardGradientAccumulation": 3.316, "TestFullyShardHSDPTraining": 3.316}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 7.453, "TestDTensorCompileE2E": 14.066}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 9.83}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 19.151000000000003, "TestNew2dParallelTraining": 13.647000000000002}, "distributed/test_c10d_functional_native": {"CompileTest": 114.559, "TestWithNCCL": 31.777}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.836000000000002, "TestMultiProc": 78.00200000000001, "TestSingleProc": 13.376999999999999}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.838, "TestCollectivesMultiProc": 48.504999999999995}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 666.0299999999999, "AOTInductorTestABICompatibleCpuWithStackAllocation": 462.22799999999967, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 202.896, "AOTInductorTestABICompatibleCuda": 1268.512999999999, "AOTInductorTestNonABICompatibleCpu": 1376.3659999999988, "AOTInductorTestNonABICompatibleCuda": 2104.586000000001}, "inductor/test_torchinductor": {"CpuTests": 1310.4510000000016, "GPUTests": 702.4220000000005, "NanCheckerTest": 0.754, "RNNTest": 0.031, "SweepInputsCpuTest": 112.59099999999997, "SweepInputsGPUTest": 22.944000000000003, "TestFull": 10.065, "TritonCodeGenTests": 24.019}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 7722.074999999983}, "test_modules": {"TestModuleCUDA": 552.0919999999862}, "test_ops": {"TestCommonCUDA": 699.9340000000972, "TestCompositeComplianceCUDA": 698.5989999999927, "TestFakeTensorCUDA": 669.0329999999942, "TestMathBitsCUDA": 83.73500000000057, "TestSelfKwarg": 1.234, "TestTagsCUDA": 3.0590000000000055}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1386.1619999999973}, "test_torch": {"TestBasicVitalSigns": 0.366, "TestDevicePrecisionCUDA": 59.653, "TestTorch": 409.1729999999992, "TestTorchDeviceTypeCUDA": 3109.4045000000006, "TestVitalSignsCudaCUDA": 0.047}}}, "cuda12.4-py3.10-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 3.5115}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 3.5075000000000003, "TestFullyShardCollectiveOps": 90.0375, "TestFullyShardCommunication": 7.0165, "TestFullyShardUnshardMultiProcess": 3.5075000000000003, "TestFullyShardUnshardMultiThread": 0.017}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 10.143}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 7.051}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 3.5695, "TestFullyShard1DTrainingCore": 10.686, "TestFullyShard2DTraining": 7.089, "TestFullyShardGradientAccumulation": 3.5695, "TestFullyShardHSDPTraining": 3.5700000000000003}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 11.2845, "TestDTensorCompileE2E": 13.645499999999998}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 10.078}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 19.611000000000004, "TestNew2dParallelTraining": 14.251000000000001}, "distributed/test_c10d_functional_native": {"CompileTest": 119.61500000000001, "TestWithNCCL": 30.288500000000006}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.860000000000003, "TestMultiProc": 84.0025, "TestSingleProc": 16.572000000000003}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 5.3045, "TestCollectivesMultiProc": 48.569500000000005}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 677.1184999999999, "AOTInductorTestABICompatibleCpuWithStackAllocation": 466.12999999999954, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 204.9574999999998, "AOTInductorTestABICompatibleCuda": 1309.4740000000002, "AOTInductorTestNonABICompatibleCpu": 1387.4344999999998, "AOTInductorTestNonABICompatibleCuda": 2116.4754999999996}, "inductor/test_torchinductor": {"CpuTests": 1237.5550000000005, "GPUTests": 703.8330000000002, "NanCheckerTest": 0.805, "RNNTest": 0.0335, "SweepInputsCpuTest": 112.24400000000003, "SweepInputsGPUTest": 36.480000000000004, "TestFull": 10.092500000000001, "TritonCodeGenTests": 24.485500000000002}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1590.3884999999982}, "test_modules": {"TestModuleCUDA": 546.2239999999865}, "test_ops": {"TestCommonCUDA": 620.436999999911, "TestCompositeComplianceCUDA": 745.6579999999987, "TestFakeTensorCUDA": 675.2734999999971, "TestMathBitsCUDA": 82.77400000000038, "TestSelfKwarg": 1.654, "TestTagsCUDA": 2.1249999999999867}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1327.7069999999333}, "test_torch": {"TestBasicVitalSigns": 0.7424999999999999, "TestDevicePrecisionCUDA": 29.2305, "TestTorch": 208.9944999999999, "TestTorchDeviceTypeCUDA": 1370.8794999999986, "TestVitalSignsCudaCUDA": 0.018}}, "inductor_cpp_wrapper_abi_compatible": {"inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 445.217, "TestCudaWrapper": 424.369}}, "inductor_distributed": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 10.621}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 16.329, "TestFullyShardCollectiveOps": 88.70150000000001, "TestFullyShardCommunication": 10.5765, "TestFullyShardUnshardMultiProcess": 4.3095, "TestFullyShardUnshardMultiThread": 0.0175}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 25.637}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 17.3695}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 14.183, "TestFullyShard1DTrainingCore": 122.39699999999999, "TestFullyShard2DTraining": 27.069499999999998, "TestFullyShardGradientAccumulation": 25.353, "TestFullyShardHSDPTraining": 13.785}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 13.440499999999998, "TestDTensorCompileE2E": 24.8125}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 24.7505}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 39.239000000000004, "TestNew2dParallelTraining": 26.363}, "distributed/test_c10d_functional_native": {"CompileTest": 120.31049999999999, "TestWithNCCL": 42.047}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.197000000000003, "TestMultiProc": 197.89149999999998, "TestSingleProc": 17.995}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 5.3465, "TestCollectivesMultiProc": 82.686}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.008, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.006, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.006, "AOTInductorTestABICompatibleCuda": 18.353, "AOTInductorTestNonABICompatibleCpu": 0.006, "AOTInductorTestNonABICompatibleCuda": 31.676499999999997}, "inductor/test_torchinductor": {"CpuTests": 3.0759999999999996, "GPUTests": 1.045}}}, "cuda12.4-py3.12-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 3.266}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 3.205, "TestFullyShardCollectiveOps": 88.253, "TestFullyShardCommunication": 6.4625, "TestFullyShardUnshardMultiProcess": 3.205, "TestFullyShardUnshardMultiThread": 0.015}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 9.64}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 6.4625}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 3.2665, "TestFullyShard1DTrainingCore": 9.8765, "TestFullyShard2DTraining": 6.482, "TestFullyShardGradientAccumulation": 3.2665, "TestFullyShardHSDPTraining": 3.216}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 10.0495, "TestDTensorCompileE2E": 13.387}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 9.7}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 18.945999999999998, "TestNew2dParallelTraining": 13.5455}, "distributed/test_c10d_functional_native": {"CompileTest": 118.733, "TestWithNCCL": 28.945500000000003}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.4285, "TestMultiProc": 78.3005, "TestSingleProc": 16.629}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 5.183, "TestCollectivesMultiProc": 46.11449999999999}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 673.2189999999998, "AOTInductorTestABICompatibleCpuWithStackAllocation": 462.91599999999994, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 203.94049999999993, "AOTInductorTestABICompatibleCuda": 1305.3345, "AOTInductorTestNonABICompatibleCpu": 1378.755499999999, "AOTInductorTestNonABICompatibleCuda": 2111.1219999999994}, "inductor/test_torchinductor": {"CpuTests": 1224.618, "GPUTests": 680.936, "NanCheckerTest": 0.829, "RNNTest": 0.0325, "SweepInputsCpuTest": 113.50450000000002, "SweepInputsGPUTest": 36.68700000000001, "TestFull": 10.075, "TritonCodeGenTests": 24.498}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1555.4389999999933}, "test_modules": {"TestModuleCUDA": 540.7639999999853}, "test_ops": {"TestCommonCUDA": 636.7229999999756, "TestCompositeComplianceCUDA": 744.2329999999918, "TestFakeTensorCUDA": 663.6574999999962, "TestMathBitsCUDA": 82.10300000000035, "TestSelfKwarg": 0.975, "TestTagsCUDA": 3.058500000000001}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1323.751499999988}, "test_torch": {"TestBasicVitalSigns": 0.892, "TestDevicePrecisionCUDA": 29.915999999999997, "TestTorch": 214.63999999999987, "TestTorchDeviceTypeCUDA": 1572.0320000000029, "TestVitalSignsCudaCUDA": 0.026}}}, "default": {"crossref": {"backends/xeon/test_launch": {"TestTorchrun": 1.9676666666666665}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.733333333333333}, "distributions/test_constraints": {"test_constraints": 0.08583333333333339}, "distributions/test_distributions": {"TestAgainstScipy": 1.0601666666666667, "TestConstraints": 0.15666666666666665, "TestDistributionShapes": 0.15166666666666676, "TestDistributions": 27.032000000000004, "TestFunctors": 0.013, "TestJit": 21.002666666666666, "TestKL": 2.940166666666666, "TestLazyLogitsInitialization": 0.015333333333333332, "TestNumericalStability": 0.07933333333333335, "TestRsample": 0.6735, "TestValidation": 0.4016666666666667}, "export/test_converter": {"TestConverter": 8.1075}, "export/test_db": {"ExampleTests": 3.192333333333333}, "export/test_export": {"TestDynamismExpression": 0.7036666666666667, "TestExport": 32.96416666666667, "TestExportCustomClass": 0.08516666666666667, "TestOneOffModelExportResult": 1.2038333333333333}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.17566666666666667}, "export/test_hop": {"TestHOPCPU": 2.9716666666666667, "TestHOPGeneric": 0.0030000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.13583333333333333}, "export/test_pass_infra": {"TestPassInfra": 0.8623333333333334}, "export/test_passes": {"TestPasses": 13.891000000000002}, "export/test_schema": {"TestSchema": 0.25066666666666665}, "export/test_serialize": {"TestDeserialize": 7.5825, "TestSaveLoad": 0.2901666666666667, "TestSchemaVersioning": 0.03033333333333333, "TestSerialize": 1.1380000000000001, "TestSerializeCustomClass": 0.08416666666666667}, "export/test_sparse": {"TestSparseProp": 89.91583333333332}, "export/test_tools": {"TestExportTools": 0.42666666666666664}, "export/test_torchbind": {"TestCompileTorchbind": 1.4571666666666667, "TestExportTorchbind": 2.147333333333333, "TestRegisterFakeClass": 0.0035000000000000005}, "export/test_tree_utils": {"TestTreeUtils": 0.165}, "export/test_unflatten": {"TestUnflatten": 3.3728333333333333}, "export/test_verifier": {"TestVerifier": 0.945}, "functorch/test_aotdispatch": {"TestAOTAutograd": 14.500166666666665, "TestAOTAutogradWithDynamo": 18.147999999999996, "TestAOTDispatch": 0.6611666666666667, "TestAOTExport": 2.6558333333333333, "TestAOTModuleSimplified": 0.7276666666666667, "TestEagerFusionModuleInfoCPU": 969.5681666666666, "TestEagerFusionOpInfoCPU": 2425.4728333333323, "TestPartitioning": 1.3246666666666669, "TestPythonKeyCPU": 1.276}, "functorch/test_control_flow": {"TestControlFlow": 0.7176666666666667, "TestControlFlowTraced": 124.00249999999997}, "functorch/test_dims": {"TestMin": 16.2545, "TestMinFunctorchOnly": 14.524666666666665}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.11683333333333337, "TestAutogradFunctionVmapAPICPU": 0.02416666666666667, "TestCompileTransformsCPU": 9.714500000000001, "TestComposabilityCPU": 1.8643333333333332, "TestExamplesCorrectnessCPU": 4.912, "TestFunctionalizeCPU": 0.1385, "TestGradTransformCPU": 0.5371666666666668, "TestHelpersCPU": 0.009833333333333333, "TestHessianCPU": 0.04216666666666667, "TestHigherOrderOperatorInteractionCPU": 0.03216666666666667, "TestJacCPU": 0.7185000000000004, "TestJvpCPU": 0.059500000000000025, "TestLinearizeCPU": 0.21316666666666667, "TestMakeFunctional": 0.10616666666666669, "TestSliceArgnums": 0.01666666666666667, "TestVmapJvpInplaceViewCPU": 0.017666666666666667, "TestVmapOfGradCPU": 0.382}, "functorch/test_logging": {"TestAOTLogging": 0.18233333333333332}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.35516666666666674, "RandomOpTestCase": 0.07533333333333334, "ReduceTestCase": 0.07533333333333334, "TestMemoryEfficientOpAuthoring": 0.0003333333333333333}, "functorch/test_minifier": {"TestMinifier": 0.3526666666666667}, "functorch/test_ops": {"TestOperatorsCPU": 3686.686999999978}, "functorch/test_parsing": {"TestAnonymousAxis": 0.16699999999999998, "TestParsedExpression": 0.0061666666666666675, "TestParsingUtils": 0.006, "TestValidateRearrangeExpressions": 0.0061666666666666675}, "functorch/test_rearrange": {"TestRearrange": 0.22183333333333338}, "functorch/test_vmap": {"TestRandomnessCPU": 1.8255000000000003, "TestTransformFailureCPU": 0.19833333333333336, "TestVmapAPI": 0.3090000000000001, "TestVmapBatchedGradientCPU": 0.22833333333333336, "TestVmapDeviceTypeCPU": 0.0305, "TestVmapNestedTensorCPU": 0.055, "TestVmapOperators": 3.606333333333332, "TestVmapOperatorsOpInfoCPU": 662.169166666666}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.1619999999998756}, "higher_order_ops/test_with_effects": {"TestWithEffects": 10.2165}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.02583333333333334}, "lazy/test_debug_util": {"DebugUtilTest": 0.19783333333333333}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.19483333333333336}, "lazy/test_generator": {"LazyGeneratorTest": 0.21016666666666667}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.45466666666666666}, "lazy/test_step_closures": {"ClosuresTest": 2.1413333333333333}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.3133333333333333, "TestLazyOpInfoCPU": 9.769999999999982, "TestLazyTensor": 0.08050000000000002}, "nn/test_convolution": {"TestConvolutionNN": 12.995500000000003, "TestConvolutionNNDeviceTypeCPU": 7.029999999999953}, "nn/test_dropout": {"TestDropoutNN": 0.12433333333333334, "TestDropoutNNDeviceTypeCPU": 0.38416666666666666}, "nn/test_embedding": {"TestEmbeddingNN": 0.09800000000000003, "TestEmbeddingNNDeviceTypeCPU": 9.98183333333334}, "nn/test_init": {"TestNNInit": 3.933499999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.5703333333333336}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.0311666666666663, "TestLoadStateDictSwap": 0.003166666666666667}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.03066666666666667, "TestModuleHookNN": 0.10650000000000001, "TestModuleHooks": 0.10916666666666669, "TestStateDictHooks": 0.04166666666666667}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 7.579833333333333, "TestMultiheadAttentionNNDeviceTypeCPU": 0.0415}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.43200000000000005}, "nn/test_parametrization": {"TestNNParametrization": 1.3869999999999991, "TestNNParametrizationDeviceCPU": 0.027999999999999997}, "nn/test_pooling": {"TestAvgPool": 0.3155, "TestPoolingNN": 0.4021666666666667, "TestPoolingNNDeviceTypeCPU": 30.3705}, "nn/test_pruning": {"TestPruningNN": 0.12216666666666673}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.12966666666666665}, "profiler/test_memory_profiler": {"TestDataFlow": 1.4273333333333333, "TestIdentifyGradients": 0.30733333333333335, "TestMemoryProfiler": 0.18683333333333332, "TestMemoryProfilerE2E": 3.5098333333333334}, "profiler/test_profiler": {"TestExperimentalUtils": 4.9319999999999995, "TestProfiler": 17.65366666666667, "TestProfilerCUDA": 0.0008333333333333333, "TestProfilerITT": 0.011333333333333332}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.20600000000000004}, "profiler/test_record_function": {"TestRecordFunction": 0.24400000000000002}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.244166666666666}, "test_ao_sparsity": {"TestActivationSparsifier": 0.107, "TestBaseDataScheduler": 0.0405, "TestBaseDataSparsifier": 0.09533333333333334, "TestBaseSparsifier": 0.0345, "TestBaseStructuredSparsifier": 1.8388333333333333, "TestComposability": 2.6001666666666665, "TestCubicScheduler": 0.005666666666666667, "TestFPGMPruner": 0.028499999999999998, "TestFakeSparsity": 0.09483333333333334, "TestFxComposability": 2.1406666666666667, "TestNearlyDiagonalSparsifier": 0.9013333333333333, "TestNormDataSparsifiers": 1.1711666666666667, "TestQuantizationUtils": 0.0325, "TestQuantizedSparseKernels": 0.3165, "TestQuantizedSparseLayers": 0.5573333333333332, "TestSaliencyPruner": 0.03216666666666667, "TestScheduler": 0.01533333333333333, "TestSparsityUtilFunctions": 0.06883333333333333, "TestWeightNormSparsifier": 0.6006666666666667}, "test_autocast": {"TestAutocastCPU": 0.7121666666666668, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.005333333333333334}, "test_autograd": {"TestAllowMutationOnSaved": 0.03816666666666667, "TestAutograd": 19.464666666666655, "TestAutogradComplex": 0.005833333333333333, "TestAutogradDeviceTypeCPU": 0.33750000000000013, "TestAutogradForwardMode": 0.12250000000000005, "TestAutogradForwardModeBatchedGrad": 0.019166666666666665, "TestAutogradFunctional": 9.77, "TestAutogradInferenceMode": 0.04200000000000001, "TestAutogradLogging": 0.012333333333333333, "TestAutogradMultipleDispatchCPU": 0.029, "TestMultithreadAutograd": 0.2973333333333334, "TestNestedCheckpoint": 0.3710000000000001, "TestSelectiveActivationCheckpoint": 0.034333333333333334}, "test_autograd_fallback": {"TestAutogradFallback": 0.2418333333333334}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 148.29033333333186}, "test_bundled_inputs": {"TestBundledInputs": 1.0935}, "test_comparison_utils": {"TestComparisonUtils": 0.20700000000000002}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0006666666666666666}, "test_complex": {"TestComplexTensorCPU": 0.060833333333333336}, "test_content_store": {"TestContentStoreCPU": 7.3678333333333335}, "test_cpp_api_parity": {"TestCppApiParity": 3.572999999999988}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03300000000000001, "TestMAIATensor": 0.0075, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03300000000000001, "TestMAIATensor": 0.0075, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 28.487000000000002}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.5946666666666666}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 8.3885}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.6031666666666666}, "test_custom_backend": {"TestCustomBackend": 0.07299999999999998}, "test_custom_ops": {"MiniOpTest": 0.7513333333333332, "MiniOpTestOther": 0.08533333333333334, "TestCustomOp": 2.8261666666666634, "TestCustomOpAPI": 0.21650000000000003, "TestCustomOpTestingCPU": 2.1198333333333337, "TestCustomOperators": 0.24550000000000002, "TestGenerateOpcheckTests": 3.9186666666666667}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 35.82683333333334, "TestConcatDataset": 0.010333333333333333, "TestConvAfterFork": 0.10516666666666666, "TestCustomPinFn": 0.0013333333333333335, "TestDataLoader": 36.333, "TestDataLoaderDeviceTypeCPU": 0.0028333333333333335, "TestDataLoaderPersistentWorkers": 59.065, "TestDatasetRandomSplit": 0.03950000000000001, "TestDictDataLoader": 0.07100000000000001, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004, "TestSetAffinity": 0.07983333333333334, "TestStackDataset": 0.03516666666666668, "TestStringDataLoader": 0.0008333333333333333, "TestTensorDataset": 0.026333333333333334}, "test_datapipe": {"TestCaptureDataFrame": 0.0003333333333333333, "TestCircularSerialization": 0.009666666666666665, "TestDataChunk": 0.007, "TestDataFramesPipes": 0.004333333333333333, "TestFunctionalIterDataPipe": 5.2318333333333324, "TestFunctionalMapDataPipe": 0.04633333333333334, "TestGraph": 0.01633333333333333, "TestIterDataPipeCountSampleYielded": 0.011333333333333334, "TestIterDataPipeGraphFastForward": 0.0515, "TestIterDataPipeSingletonConstraint": 0.025500000000000002, "TestIterableDataPipeBasic": 0.03066666666666667, "TestSerialization": 7.098333333333333, "TestSharding": 0.266, "TestStreamWrapper": 0.16583333333333333, "TestTyping": 0.007000000000000001}, "test_decomp": {"DecompOneOffTestsCPU": 0.030000000000000002, "HasDecompTest": 0.38750000000000007, "TestDecompCPU": 252.0910000000004}, "test_deploy": {"TestFreezer": 0.15533333333333332}, "test_dispatch": {"TestDispatch": 24.759833333333326, "TestPythonDispatcher": 0.012166666666666666}, "test_dlpack": {"TestTorchDlPackCPU": 0.23350000000000015}, "test_dynamic_shapes": {"TestDimConstraints": 1.7118333333333333, "TestFloorDiv": 0.013166666666666667, "TestGuardsExpressions": 0.025, "TestPySymInt": 1.204833333333333, "TestSymNumberMagicMethods": 1.7831666666666623}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 2.6068333333333316, "TestExpandedWeightHelperFunctionCPU": 0.01866666666666667, "TestExpandedWeightModuleCPU": 6.786666666666667}, "test_fake_tensor": {"FakeTensorConstHandling": 0.05116666666666668, "FakeTensorConverterTest": 0.022500000000000003, "FakeTensorDispatchCache": 0.0615, "FakeTensorOpInfoTestCPU": 0.09833333333333333, "FakeTensorOperatorInvariants": 0.27416666666666667, "FakeTensorPropTest": 0.064, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.6065000000000002, "PropagateRealTensorsFakeTensorConstHandling": 0.08283333333333334, "PropagateRealTensorsFakeTensorConverterTest": 0.021500000000000002, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.07750000000000001, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.15700000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.043333333333333335, "PropagateRealTensorsFakeTensorTest": 0.21283333333333337}, "test_flop_counter": {"TestFlopCounter": 0.6186666666666667}, "test_foreach": {"TestForeachCPU": 73.92933333333349}, "test_function_schema": {"TestFunctionSchema": 0.5141666666666667}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 38.05200000000001}, "test_functional_optim": {"TestFunctionalOptimParity": 0.37616666666666665}, "test_functionalization": {"TestCrossRefFunctionalization": 2.3441666666666663, "TestFunctionalization": 2.8968333333333316}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.024333333333333332}, "test_futures": {"TestFuture": 0.8051666666666668}, "test_fx": {"AnnotationsTest": 0.01216666666666667, "TestCSEPass": 0.23266666666666672, "TestCommonPass": 0.055666666666666656, "TestConstFold": 0.14600000000000002, "TestConstParamShapeInControlFlow": 0.0415, "TestDCE": 0.026166666666666668, "TestFX": 2.667499999999997, "TestFXAPIBackwardCompatibility": 0.026666666666666665, "TestFunctionalTracing": 0.3166666666666669, "TestMatcher": 0.32466666666666666, "TestOperatorSignaturesCPU": 3.03266666666664, "TestPassManager": 0.021666666666666667, "TestSourceMatcher": 1.2556666666666665, "TestSubgraphRewriter": 0.3205000000000001, "TestVisionTracing": 218.93566666666663, "TypeCheckerTest": 1.4918333333333313}, "test_fx_experimental": {"TestFXExperimental": 17.468666666666667, "TestNormalizeOperatorsCPU": 55.71450000000003, "TestTranslationValidation": 0.184}, "test_fx_passes": {"TestFXGraphPasses": 0.5665000000000002, "TestFXMatcherUtils": 0.08933333333333335}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.40100000000000013}, "test_import_stats": {"TestImportTime": 3.373333333333333}, "test_indexing": {"NumpyTestsCPU": 0.047000000000000014, "TestIndexingCPU": 2.0071666666666643}, "test_itt": {"TestItt": 0.17066666666666666}, "test_jit": {"TestAliasAnalysis": 0.3078333333333333, "TestAsync": 0.4546666666666667, "TestAtenPow": 0.010166666666666668, "TestAutodiffJit": 0.0905, "TestAutodiffSubgraphSlicing": 0.31400000000000006, "TestAwait": 0.31933333333333347, "TestBackends": 0.6775, "TestBackendsWithCompiler": 0.15083333333333332, "TestBatchMM": 0.11116666666666666, "TestBuiltins": 0.0525, "TestClassType": 1.933833333333333, "TestComplex": 0.8263333333333336, "TestCustomOperators": 0.051500000000000004, "TestDCE": 0.022, "TestDataParallel": 0.0031666666666666666, "TestDataclasses": 4.542166666666667, "TestDeviceAnalysis": 3.9123333333333328, "TestDict": 0.49600000000000016, "TestDtypeAnalysis": 0.17700000000000005, "TestDtypeCustomRulesCPU": 3.3038333333333303, "TestEnum": 0.1891666666666667, "TestFreezing": 1.8821666666666665, "TestFrontend": 0.2513333333333333, "TestFrozenOptimizations": 13.51383333333333, "TestFunctionalBlocks": 0.0075, "TestFunctionalToInplaceActivation": 2.477166666666667, "TestGenerator": 0.07200000000000001, "TestGetDefaultAttr": 0.020333333333333335, "TestGraphRewritePasses": 0.07266666666666667, "TestHash": 0.07749999999999999, "TestHooks": 0.6871666666666669, "TestIgnorableArgs": 0.0105, "TestIgnoreContextManager": 0.03933333333333334, "TestInplaceToFunctionalActivation": 2.5413333333333337, "TestIsinstance": 0.22233333333333338, "TestJit": 5.3558333333333294, "TestJitGeneratedModule": 11.666833333333386, "TestJitProfiler": 0.0013333333333333335, "TestJitUtils": 0.017833333333333336, "TestList": 1.542333333333333, "TestLogging": 0.0505, "TestMKLDNNReinplacing": 0.004333333333333333, "TestMisc": 0.1883333333333334, "TestMixTracingScripting": 1.1946666666666668, "TestModels": 2.1598333333333324, "TestModuleAPIs": 0.13683333333333333, "TestModuleContainers": 1.2481666666666666, "TestModuleInterface": 0.5170000000000001, "TestModules": 0.016833333333333332, "TestNamedTuple": 0.07483333333333334, "TestNnapiBackend": 13.175333333333334, "TestOpDecompositions": 0.020666666666666667, "TestOptimizeForMobilePreserveDebugInfo": 0.21166666666666667, "TestParametrization": 0.11716666666666666, "TestPeephole": 0.4786666666666668, "TestProducerVersion": 0.002, "TestProfiler": 0.5455000000000001, "TestPythonBindings": 0.036000000000000004, "TestPythonBuiltinOP": 0.37500000000000006, "TestPythonIr": 0.02416666666666667, "TestRecursiveScript": 0.6780000000000002, "TestRemoveMutation": 0.16100000000000003, "TestSaveLoad": 0.611, "TestSaveLoadFlatbuffer": 0.3320000000000001, "TestSaveLoadForOpVersion": 2.3819999999999997, "TestScript": 27.180333333333344, "TestScriptDict": 0.032, "TestScriptList": 0.9071666666666661, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.1686666666666667, "TestScriptProfile": 0.4098333333333333, "TestSlice": 0.15533333333333338, "TestSparse": 0.06100000000000001, "TestStringFormatting": 0.1231666666666667, "TestSymbolicShapeAnalysis": 2.0099999999999993, "TestTensorBuiltins": 0.07016666666666665, "TestTensorCreationOps": 0.0485, "TestTensorMethods": 0.016166666666666666, "TestTorchbind": 0.12800000000000006, "TestTracer": 2.8996666666666635, "TestTypeSharing": 0.45650000000000013, "TestTypesAndAnnotation": 0.11533333333333334, "TestTyping": 0.3646666666666668, "TestUnion": 0.4966666666666669, "TestUnsupportedOps": 0.034166666666666665, "TestUpgraders": 0.08516666666666667, "TestWarn": 0.05133333333333333, "TestWith": 0.31566666666666665}, "test_jit_autocast": {"TestAutocast": 0.15916666666666668, "TestJitTraceAutocast": 17.624000000000002}, "test_jit_disabled": {"TestJitDisabled": 0.25866666666666666}, "test_jit_fuser_te": {"TestFuserCommon": 0.17833333333333332, "TestLoopnestRandomizationCPU": 0.0425, "TestNNCOpInfoCPU": 47.21183333333374, "TestTEFuserDynamic": 131.56833333333338, "TestTEFuserStatic": 56.471999999999994}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.08066666666666668, "TestFusionPatternCPU": 5.782166666666667, "TestModel": 3.484166666666667, "TestOpCPU": 41.39266666666667}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.9289999999999996, "TestVmapBatchedGradientLegacyCPU": 0.11433333333333338, "TestVmapOperatorsLegacy": 1.2208333333333332}, "test_license": {"TestLicense": 0.155}, "test_linalg": {"TestLinalgCPU": 161.29766666666688}, "test_logging": {"LoggingTest": 2.666}, "test_masked": {"TestMaskedCPU": 21.490999999999985}, "test_maskedtensor": {"TestBasicsCPU": 0.15183333333333332, "TestBinary": 0.3808333333333336, "TestOperatorsCPU": 6.660333333333279, "TestReductions": 0.08650000000000001, "TestUnary": 0.3596666666666669}, "test_meta": {"TestMetaCPU": 146.24466666662926, "TestMetaConverter": 0.06683333333333336}, "test_mkl_verbose": {"TestMKLVerbose": 4.179666666666667}, "test_mkldnn": {"TestMkldnnCPU": 117.26149999999997}, "test_mkldnn_fusion": {"TestMkldnnFusion": 60.719333333333324}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.713}, "test_mobile_optimizer": {"TestOptimizer": 2.7661666666666664}, "test_model_dump": {"TestModelDump": 1.2368333333333332}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.10283333333333335}, "test_module_tracker": {"TestModuleTracker": 0.17766666666666667}, "test_modules": {"TestModuleCPU": 593.8869999999872}, "test_monitor": {"TestMonitor": 0.16266666666666665, "TestMonitorTensorboard": 0.4866666666666667}, "test_multiprocessing": {"TestMultiprocessing": 45.223333333333336}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.4093333333333333, "SpawnTest": 24.869166666666672}, "test_namedtensor": {"TestNamedTensor": 0.44633333333333347}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.4636666666666667}, "test_native_functions": {"TestNativeFunctions": 0.2841666666666667}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.21366666666666675}, "test_nestedtensor": {"TestNestedTensor": 0.2140000000000001, "TestNestedTensorAutogradCPU": 1.0796666666666668, "TestNestedTensorDeviceTypeCPU": 0.9961666666666656, "TestNestedTensorSubclassCPU": 19.49983333333335}, "test_nn": {"TestAddRelu": 0.003666666666666667, "TestConstantPadNd": 0.0033333333333333335, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.30600000000000005, "TestFusionUtils": 0.004, "TestNN": 34.418833333333296, "TestNNDeviceTypeCPU": 114.16266666666701, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.005166666666666667}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.24716666666666676}, "test_openmp": {"TestOpenMP_ParallelFor": 7.492166666666666}, "test_ops": {"TestCommonCPU": 1496.1038333333122, "TestCompositeComplianceCPU": 827.4856666666617, "TestFakeTensorCPU": 304.92933333333417, "TestMathBitsCPU": 56.12283333333341, "TestRefsOpsInfoCPU": 1.8626666666666662, "TestSelfKwarg": 0.023333333333333338, "TestTagsCPU": 13.98166666666664}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 757.5736666666585}, "test_ops_gradients": {"TestBwdGradientsCPU": 1265.4273333333053}, "test_ops_jit": {"TestJitCPU": 1062.2226666666643}, "test_optim": {"TestDifferentiableOptimizer": 0.22066666666666668, "TestLRScheduler": 1.074833333333333, "TestOptimRenewedCPU": 50.86366666666673, "TestSWAUtils": 0.242}, "test_out_dtype_op": {"TestOutDtypeOp": 0.37016666666666664}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.0018333333333333335, "TestDisabledUserWarnings": 0.0015, "TestEinsumOverride": 0.003166666666666667, "TestGradCheckOverride": 0.020666666666666667, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.007000000000000001, "TestIterator": 0.0011666666666666665, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.0025000000000000005, "TestResolveName": 0.08716666666666667, "TestTorchFunctionMode": 0.00016666666666666666, "TestTorchFunctionOverride": 1.6154999999999355, "TestTorchFunctionWarning": 0.012, "TestWrapTorchFunction": 0.0013333333333333335}, "test_package": {"DirectoryReaderTest": 0.0475, "ModelTest": 0.0016666666666666666, "TestAnalyze": 0.14049999999999999, "TestDependencyAPI": 0.08233333333333334, "TestDependencyHooks": 0.014666666666666668, "TestDiGraph": 0.02366666666666667, "TestGlobGroup": 0.028666666666666674, "TestImporter": 0.013999999999999999, "TestLoadBCPackages": 0.08766666666666667, "TestMangling": 0.022000000000000002, "TestMisc": 0.14583333333333334, "TestPackageFX": 0.08683333333333332, "TestPackageScript": 2.021833333333333, "TestRepackage": 0.008666666666666666, "TestResources": 0.0125, "TestSaveLoad": 0.051000000000000004}, "test_per_overload_api": {"TestPerOverloadAPI": 0.15966666666666665}, "test_prims": {"TestDecompCPU": 0.07283333333333333, "TestPrimsBasic": 0.018666666666666665, "TestPrimsCPU": 0.09566666666666668, "TestRefsCPU": 0.011333333333333334}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.14116666666666666, "TestGenericProxyTensorFake": 2.1316666666666664, "TestGenericProxyTensorReal": 2.548166666666666, "TestGenericProxyTensorSymbolic": 18.91216666666667, "TestProxyTensorOpInfoCPU": 728.559500000001, "TestRealProxyTensor": 0.01633333333333333, "TestSymbolicTracing": 3.6246666666666667}, "test_pruning_op": {"PruningOpTest": 0.47683333333333333}, "test_public_bindings": {"TestPublicBindings": 5.941333333333333}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.011833333333333335, "TestPythonDispatch": 0.20566666666666678, "TestPythonDispatcher": 0.006000000000000001, "TestPythonRegistration": 0.25016666666666665, "TestWrapperSubclassAliasingCPU": 0.11183333333333337}, "test_pytree": {"TestCxxPytree": 0.015166666666666672, "TestGenericPytree": 0.29650000000000004, "TestPythonPytree": 0.08333333333333337}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.01866666666666667, "TestAOMigrationNNQuantized": 0.06350000000000001, "TestAOMigrationQuantization": 0.02316666666666667, "TestAOMigrationQuantizationFx": 0.02483333333333334, "TestBackendConfig": 0.05933333333333334, "TestBiasCorrectionEager": 2.107, "TestBitsCPU": 0.06366666666666668, "TestComparatorOps": 1.9356666666666666, "TestDeprecatedJitQuantized": 4.414833333333332, "TestDistributed": 0.0335, "TestDuplicateDQPass": 3.7880000000000003, "TestDynamicQuantizedModule": 63.13316666666666, "TestDynamicQuantizedOps": 30.872499999999995, "TestEqualizeEager": 0.44966666666666666, "TestEqualizeFx": 5.892166666666666, "TestFXGraphMatcher": 1.933, "TestFXGraphMatcherModels": 10.241500000000002, "TestFXNumericSuiteCoreAPIs": 31.822166666666664, "TestFXNumericSuiteCoreAPIsModels": 42.06999999999999, "TestFXNumericSuiteNShadows": 46.662333333333336, "TestFakeQuantize": 0.5421666666666667, "TestFakeQuantizeOps": 2.79, "TestFloat8DtypeCPU": 0.11550000000000005, "TestFloat8DtypeCPUOnlyCPU": 0.7064999999999999, "TestFuseEager": 3.9854999999999996, "TestFuseFx": 2.411166666666666, "TestFusedObsFakeQuant": 0.22350000000000003, "TestFusedObsFakeQuantModule": 0.31500000000000006, "TestFusionPasses": 0.027833333333333335, "TestFxDetectInputWeightEqualization": 0.25533333333333336, "TestFxDetectOutliers": 0.3798333333333333, "TestFxModelReportClass": 0.7115, "TestFxModelReportDetectDynamicStatic": 0.07566666666666667, "TestFxModelReportDetector": 0.25133333333333335, "TestFxModelReportObserver": 0.275, "TestFxModelReportVisualizer": 0.26416666666666666, "TestGenerateNumericDebugHandle": 1.1244999999999998, "TestGraphUtils": 1.5435, "TestHistogramObserver": 49.11416666666667, "TestMetaDataPorting": 9.152166666666666, "TestModelNumericsEager": 1.2471666666666665, "TestNumericSuiteEager": 13.332833333333332, "TestObserver": 4.642833333333334, "TestPT2ERepresentation": 31.52983333333333, "TestPadding": 21.754166666666666, "TestQNNPackOps": 6.890833333333333, "TestQuantizationDocs": 0.005333333333333333, "TestQuantizeDynamicJitOps": 2.833333333333333, "TestQuantizeDynamicJitPasses": 5.755, "TestQuantizeEagerOps": 2.2348333333333334, "TestQuantizeEagerPTQDynamic": 9.431833333333334, "TestQuantizeEagerPTQStatic": 38.52216666666667, "TestQuantizeEagerQAT": 13.68, "TestQuantizeEagerQATNumerics": 2.7276666666666665, "TestQuantizeFx": 50.39499999999998, "TestQuantizeFxModels": 8.761, "TestQuantizeFxOps": 147.32750000000001, "TestQuantizeJit": 23.814500000000002, "TestQuantizeJitOps": 243.06166666666667, "TestQuantizeJitPasses": 6.482666666666666, "TestQuantizePT2E": 52.131166666666665, "TestQuantizePT2EQATModels": 27.70283333333333, "TestQuantizePT2EQAT_ConvBn1d": 304.3135, "TestQuantizePT2EQAT_ConvBn2d": 306.441, "TestQuantizePT2EX86Inductor": 125.8375, "TestQuantizedConv": 70.60066666666668, "TestQuantizedEmbeddingOps": 1.6356666666666668, "TestQuantizedFunctionalOps": 3.7221666666666664, "TestQuantizedLinear": 24.71533333333333, "TestQuantizedOps": 157.05866666666662, "TestQuantizedTensor": 3.270999999999999, "TestRecordHistogramObserver": 0.05466666666666667, "TestReferenceQuantizedModule": 0.09016666666666667, "TestSerialization": 2.4443333333333337, "TestStaticQuantizedModule": 140.6155, "TestSubgraphRewriter": 1.3433333333333333, "TestUtils": 0.029833333333333333, "TestXNNPACKQuantizer": 54.51216666666666, "TestXNNPACKQuantizerModels": 3.0641666666666665}, "test_reductions": {"TestReductionsCPU": 198.68283333332732}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 6.2251666666666665}, "test_schema_check": {"TestSchemaCheck": 0.17450000000000007, "TestSchemaCheckModeOpInfoCPU": 198.90199999999692}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.488}, "test_serialization": {"TestBothSerializationCPU": 0.25233333333333335, "TestOldSerialization": 26.927333333333333, "TestSerialization": 8.781833333333331, "TestSubclassSerialization": 0.043000000000000003}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.16499999999999998}, "test_shape_ops": {"TestShapeOpsCPU": 1.3356666666666657}, "test_show_pickle": {"TestShowPickle": 0.1396666666666667}, "test_sort_and_select": {"TestSortAndSelectCPU": 2.2238333333333307}, "test_sparse": {"TestSparseAnyCPU": 403.57466666666596, "TestSparseCPU": 508.7623333333333, "TestSparseLegacyAndDeprecation": 0.07516666666666666, "TestSparseMaskedReductionsCPU": 1.611166666666667, "TestSparseMeta": 4.3134999999999994, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 9.423999999999953}, "test_sparse_csr": {"TestSparseCSRCPU": 95.1168333333336, "TestSparseCSRSampler": 0.6980000000000001, "TestSparseCompressedCPU": 115.9744999999997, "TestSparseCompressedTritonKernelsCPU": 0.004333333333333333}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 6.334666666666655, "TestFFTDocExamplesCPU": 0.0916666666666667}, "test_stateless": {"TestPythonOptimizeMode": 3.937333333333333, "TestStatelessDeprecation": 1.7076666666666667, "TestStatelessFunctionalAPI": 0.2830000000000001}, "test_subclass": {"TestSubclass": 0.3256666666666668}, "test_sympy_utils": {"TestNumbers": 0.03966666666666667, "TestSingletonInt": 0.006833333333333334, "TestSympyInterp": 9.769833333333334, "TestSympySolve": 0.23550000000000004, "TestValueRanges": 5.172666666666666}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.5853333333333337, "TestBufferProtocolCPU": 0.39016666666666694, "TestLikeTensorCreationCPU": 0.009333333333333336, "TestRandomTensorCreationCPU": 2.8051666666666657, "TestTensorCreationCPU": 24.74433333333335}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.004166666666666667, "TestTensorBoardFigure": 0.0016666666666666666, "TestTensorBoardNumpy": 0.0033333333333333335, "TestTensorBoardPyTorchNumpy": 0.11333333333333336, "TestTensorBoardPytorchGraph": 0.014499999999999999, "TestTensorBoardSummary": 0.03950000000000001, "TestTensorBoardSummaryWriter": 0.005833333333333333, "TestTensorBoardUtils": 0.006333333333333333, "TestTensorBoardWriter": 0.0015, "TestTensorProtoSummary": 0.014666666666666665}, "test_tensorexpr": {"TestTensorExprFuser": 46.58049999999999}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.008, "TestTensorExprPyBind": 0.7355}, "test_testing": {"TestAssertClose": 0.13600000000000007, "TestAssertCloseContainer": 0.008, "TestAssertCloseErrorMessage": 0.07866666666666669, "TestAssertCloseQuantized": 0.0155, "TestAssertCloseSparseBSC": 0.0255, "TestAssertCloseSparseBSR": 0.025, "TestAssertCloseSparseCOO": 0.030333333333333334, "TestAssertCloseSparseCSC": 0.025500000000000002, "TestAssertCloseSparseCSR": 0.02566666666666667, "TestFrameworkUtils": 11.7925, "TestImports": 12.065166666666666, "TestMakeTensorCPU": 1.3978333333333315, "TestOpInfoSampleFunctionsCPU": 6.051499999999975, "TestOpInfos": 0.004666666666666666, "TestTestParametrization": 0.03716666666666668, "TestTestParametrizationDeviceTypeCPU": 3.708499999999998, "TestTestingCPU": 0.19200000000000003}, "test_torch": {"TestBasicVitalSigns": 0.04050000000000001, "TestTorch": 3.8146666666666578, "TestTorchDeviceTypeCPU": 16.840833333333336, "TestVitalSignsCudaCPU": 0.0013333333333333335}, "test_transformers": {"TestAttnBiasCPU": 21.93133333333333, "TestSDPACPU": 281.3748333333325, "TestSDPAFailureModesCPU": 0.03450000000000002, "TestTransformersCPU": 6.531000000000001}, "test_type_hints": {"TestTypeHints": 0.21916666666666668}, "test_type_info": {"TestDTypeInfo": 0.20433333333333334}, "test_type_promotion": {"TestTypePromotionCPU": 3.661333333333331}, "test_typing": {"TestTyping": 77.01016666666669}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 454.3534999998891}, "test_utils": {"TestAssert": 0.05283333333333333, "TestBottleneck": 8.3245, "TestCheckpoint": 0.08583333333333334, "TestCollectEnv": 0.9886666666666666, "TestCppExtensionUtils": 0.11399999999999999, "TestDataLoaderUtils": 0.2595, "TestDeviceUtilsCPU": 31.052666666667157, "TestExtensionUtils": 0.004333333333333333, "TestHipify": 0.0011666666666666665, "TestHipifyTrie": 0.005333333333333333, "TestONNXUtils": 0.004166666666666667, "TestRenderUtils": 0.012166666666666668, "TestStandaloneCPPJIT": 1.6573333333333333, "TestTraceback": 0.009833333333333335}, "test_view_ops": {"TestOldViewOpsCPU": 18.3795, "TestViewOpsCPU": 0.9888333333333329, "TestViewOpsLAZY": 1.1186666666666663}, "test_vulkan": {"TestVulkanRewritePass": 0.0008333333333333333}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.024, "WeakKeyDictionaryTestCase": 0.03066666666666667, "WeakTest": 4.803333333333333}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 32.527166666666666, "TestXNNPACKOps": 4.987666666666667, "TestXNNPACKRewritePass": 1.9048333333333334, "TestXNNPACKSerDes": 5.416166666666666}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.09716666666666672}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.2501666666666667, "TestClassGetItem": 0.0006666666666666666, "TestDtypeAttributeDeletion": 0.0006666666666666666, "TestFromDTypeAttribute": 0.0023333333333333335, "TestMisc": 0.004666666666666667, "TestPickling": 0.1756666666666667, "TestPromotion": 0.0031666666666666666}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 14.976833333333335, "TestEinsumPath": 0.001, "TestMisc": 0.006500000000000001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.00016666666666666666, "TestFinfo": 0.019500000000000003, "TestHalf": 0.0003333333333333333, "TestIinfo": 0.1556666666666667, "TestMisc": 0.003166666666666667, "TestPythonFloat": 0.0008333333333333333, "TestRepr": 0.0028333333333333335, "TestSingle": 0.00016666666666666666}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.004333333333333333, "TestBooleanIndexing": 0.01, "TestBroadcastedAssignments": 0.021166666666666667, "TestFancyIndexingCast": 0.005, "TestFloatNonIntegerArgument": 0.013666666666666669, "TestIndexing": 0.3316666666666668, "TestMultiIndexingAutomated": 0.011833333333333335, "TestMultipleEllipsisError": 0.0021666666666666666, "TestNonIntegerArrayLike": 0.0008333333333333333}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.04183333333333334, "TestArgmax": 1.1785000000000005, "TestArgmaxArgminCommon": 0.9186666666666653, "TestArgmin": 1.2350000000000003, "TestArrayAttributeDeletion": 0.008, "TestArrayConstruction": 0.04883333333333334, "TestArrayCreationCopyArgument": 0.03816666666666669, "TestAssignment": 0.011000000000000003, "TestAttributes": 0.02433333333333334, "TestBinop": 0.02, "TestBool": 28.50766666666667, "TestCequenceMethods": 0.0021666666666666666, "TestChoose": 0.022833333333333337, "TestClip": 0.009166666666666667, "TestCompress": 0.005666666666666667, "TestConversion": 0.04783333333333334, "TestCreation": 0.00516666666666667, "TestDelMisc": 0.002, "TestDot": 0.0861666666666667, "TestDtypedescr": 0.0016666666666666666, "TestFancyIndexing": 0.0345, "TestFlag": 0.014333333333333337, "TestFormat": 0.006666666666666666, "TestFromBuffer": 0.020500000000000004, "TestHash": 0.11900000000000001, "TestHashing": 0.006666666666666666, "TestIO": 0.008000000000000002, "TestInner": 0.25783333333333336, "TestLexsort": 0.030000000000000006, "TestMatmul": 0.6038333333333334, "TestMatmulOperator": 0.3741666666666667, "TestMethods": 1.7471666666666663, "TestMinMax": 0.008, "TestMinScalarType": 0.01, "TestNewaxis": 0.004166666666666667, "TestPEP3118Dtype": 0.0006666666666666666, "TestPutmask": 0.016, "TestRepeat": 0.026333333333333334, "TestResize": 0.05700000000000001, "TestRichcompareScalar": 0.0008333333333333333, "TestScalarIndexing": 0.021333333333333336, "TestSortFloatMisc": 0.20216666666666666, "TestStats": 0.29366666666666663, "TestSubscripting": 0.0018333333333333335, "TestTake": 0.04550000000000001, "TestVdot": 0.04166666666666667, "TestWarnings": 0.0021666666666666666, "TestWhere": 0.5296666666666667, "TestWritebackIfCopy": 0.03866666666666667}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.022166666666666668, "TestArgwhere": 0.029333333333333333, "TestArrayComparisons": 0.015499999999999998, "TestBaseRepr": 0.0075, "TestBinaryRepr": 0.011833333333333335, "TestBoolArray": 2.4695, "TestBoolCmp": 0.21283333333333335, "TestBoolScalar": 0.010833333333333334, "TestBroadcast": 0.06566666666666666, "TestClip": 0.2386666666666668, "TestConvolve": 0.021, "TestCorrelate": 0.036833333333333336, "TestCreationFuncs": 1.15, "TestCross": 0.07250000000000001, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.011666666666666667, "TestFromiter": 0.0013333333333333333, "TestIndex": 0.007666666666666666, "TestIndices": 0.04883333333333334, "TestIsclose": 0.09533333333333334, "TestIsscalar": 0.0025, "TestLikeFuncs": 0.0013333333333333333, "TestMoveaxis": 0.010166666666666668, "TestNonarrayArgs": 0.11500000000000005, "TestNonzeroAndCountNonzero": 0.33433333333333337, "TestOuterMisc": 0.006, "TestRequire": 0.007166666666666667, "TestResize": 0.16666666666666666, "TestRoll": 0.0325, "TestRollaxis": 0.005, "TestSeterr": 0.008666666666666666, "TestStdVar": 0.032, "TestStdVarComplex": 0.013833333333333333, "TestStringFunction": 0.002, "TestTensordot": 0.017333333333333333, "TestTypes": 0.019666666666666666}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0016666666666666668, "TestCommonType": 0.20099999999999998, "TestDocStrings": 0.0, "TestIsSubDType": 0.009166666666666667, "TestScalarTypeNames": 0.03533333333333335}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.09566666666666673, "TestFromInt": 0.015000000000000001, "TestFromString": 0.1725}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.004666666666666667, "TestBitCount": 0.001, "TestClassGetItem": 0.002166666666666667, "TestClassGetitemMisc": 0.1771666666666667, "TestIsInteger": 0.0075}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0008333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.11333333333333331, "TestBaseMath": 9.621833333333335, "TestBitShifts": 0.10433333333333333, "TestComplexDivision": 0.07133333333333333, "TestConversion": 0.0745, "TestHash": 0.0003333333333333333, "TestModulus": 1.1795, "TestMultiply": 0.0006666666666666666, "TestNegative": 0.021333333333333336, "TestPower": 0.13133333333333333, "TestRepr": 0.0018333333333333335, "TestScalarOpsMisc": 0.05983333333333336, "TestScalarSubclassingMisc": 0.02966666666666668, "TestSubtract": 0.020333333333333335, "TestTypes": 14.518833333333333}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.20933333333333334, "TestAtleast2d": 0.022333333333333337, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.044666666666666674, "TestConcatenate": 0.19700000000000012, "TestHstack": 0.024833333333333332, "TestStackMisc": 0.06550000000000003, "TestVstack": 0.028000000000000004}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.009999999999999998, "TestFFTShift": 5.683166666666667, "TestIRFFTN": 0.006500000000000001, "TestRFFTFreq": 0.009999999999999998}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.8179999999999987, "TestFFTShift": 0.1736666666666667, "TestFFTThreadSafe": 1.5641666666666667}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.2445}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.011000000000000001, "TestUnique": 0.3988333333333334}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.0085, "TestAmax": 0.007, "TestAmin": 0.006500000000000001, "TestAngle": 0.009500000000000001, "TestAny": 0.008166666666666668, "TestAverage": 0.037500000000000006, "TestBincount": 0.05466666666666667, "TestCheckFinite": 0.004666666666666667, "TestCopy": 0.009500000000000001, "TestCorrCoef": 0.03833333333333334, "TestCov": 0.07100000000000001, "TestCumprod": 0.033, "TestCumsum": 0.042833333333333334, "TestDelete": 0.021333333333333336, "TestDiff": 0.1035, "TestDigitize": 0.020500000000000004, "TestExtins": 0.006833333333333333, "TestFilterwindows": 0.7083333333333339, "TestFlip": 0.04483333333333334, "TestGradient": 0.22783333333333333, "TestInsert": 0.009666666666666667, "TestInterp": 0.07050000000000003, "TestKaiser": 0.011000000000000001, "TestMedian": 0.1256666666666667, "TestMeshgrid": 0.06350000000000001, "TestMsort": 0.00016666666666666666, "TestPercentile": 0.17883333333333343, "TestPiecewise": 0.012333333333333335, "TestProd": 0.03183333333333334, "TestPtp": 0.010166666666666668, "TestQuantile": 0.05316666666666668, "TestRot90": 0.22083333333333333, "TestSelect": 0.010333333333333333, "TestSinc": 0.011166666666666667, "TestSortComplex": 0.011666666666666669, "TestTrapz": 0.006500000000000001, "TestTrimZeros": 0.013000000000000001, "TestUnique": 0.006666666666666668, "Test_I0": 0.014666666666666666}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.2801666666666668, "TestHistogramOptimBinNums": 0.03866666666666668, "TestHistogramdd": 0.1751666666666667}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0016666666666666666, "TestConcatenator": 0.0075, "TestDiagIndices": 0.004833333333333334, "TestDiagIndicesFrom": 0.007666666666666667, "TestFillDiagonal": 0.0245, "TestGrid": 0.010833333333333334, "TestIndexExpression": 0.010833333333333334, "TestIx_": 0.006500000000000001, "TestNdIndex": 0.0011666666666666665, "TestNdenumerate": 0.0015, "TestRavelUnravelIndex": 0.17350000000000002}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.014666666666666668, "TestApplyOverAxes": 0.002, "TestArraySplit": 0.1746666666666667, "TestColumnStack": 0.011833333333333335, "TestDsplit": 0.013, "TestDstack": 0.019500000000000003, "TestExpandDims": 0.007666666666666667, "TestHsplit": 0.0155, "TestKron": 0.02533333333333334, "TestMayShareMemory": 0.0021666666666666666, "TestPutAlongAxis": 0.011, "TestSplit": 0.008166666666666668, "TestSqueeze": 0.045666666666666675, "TestTakeAlongAxis": 0.21350000000000002, "TestTile": 0.11266666666666666, "TestVsplit": 0.0105}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.029500000000000002, "TestEye": 0.19800000000000004, "TestFliplr": 0.005333333333333334, "TestFlipud": 0.005333333333333334, "TestHistogram2d": 0.03766666666666667, "TestTri": 0.09133333333333335, "TestTrilIndicesFrom": 0.0018333333333333335, "TestTriuIndices": 0.0028333333333333335, "TestTriuIndicesFrom": 0.0016666666666666666, "TestVander": 0.018999999999999996}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0036666666666666666, "TestCommonType": 0.1605, "TestImag": 0.01916666666666667, "TestIscomplex": 0.009333333333333334, "TestIscomplexobj": 0.007666666666666667, "TestIsfinite": 0.023166666666666665, "TestIsinf": 0.01633333333333333, "TestIsnan": 0.0225, "TestIsneginf": 0.003, "TestIsposinf": 0.004, "TestIsreal": 0.011, "TestIsrealobj": 0.0021666666666666666, "TestIsscalar": 0.0041666666666666675, "TestMintypecode": 0.0065, "TestNanToNum": 0.021333333333333336, "TestReal": 0.020499999999999997, "TestRealIfClose": 0.006333333333333333}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.18933333333333335, "TestCond": 0.26233333333333336, "TestDet": 0.18050000000000002, "TestEig": 0.05416666666666667, "TestEigh": 0.02633333333333334, "TestEighCases": 0.0, "TestEigvals": 0.069, "TestEigvalsh": 0.02583333333333334, "TestEigvalshCases": 0.0, "TestInv": 0.062, "TestLstsq": 0.226, "TestMatrixRank": 0.4141666666666667, "TestMisc": 0.04833333333333334, "TestMisc2": 0.004833333333333334, "TestMultiDot": 0.07783333333333334, "TestNormDouble": 0.8091666666666668, "TestNormInt64": 0.8571666666666666, "TestNormSingle": 0.8993333333333333, "TestNorm_NonSystematic": 0.006, "TestPinv": 0.1255, "TestPinvHermitian": 0.03733333333333333, "TestQR": 3.532333333333334, "TestSVD": 0.06883333333333334, "TestSVDHermitian": 0.14033333333333334, "TestSolve": 0.25366666666666665, "TestTensorinv": 0.036333333333333336, "TestTensorsolve": 0.012666666666666666}, "torch_np/test_basic": {"TestArrayToSequence": 0.006666666666666666, "TestCopyTo": 0.007666666666666667, "TestCtorNested": 0.004333333333333333, "TestDefaultDtype": 0.009166666666666667, "TestDivmod": 0.02, "TestExport": 0.0015, "TestMisc": 0.002, "TestNormalizations": 0.006, "TestOneArr": 0.32016666666666693, "TestOneArrAndAxesTuple": 0.009666666666666667, "TestOneArrAndAxis": 0.17383333333333345, "TestOneArrAndShape": 0.00866666666666667, "TestOneArrToScalar": 0.010333333333333333, "TestPythonArgsToArray": 0.018500000000000003, "TestSequenceOfArrays": 0.01683333333333334, "TestSequenceOfArraysToSingle": 0.009, "TestShapeLikeToArray": 0.0041666666666666675, "TestSmokeNotImpl": 0.0018333333333333335}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.29233333333333344}, "torch_np/test_dtype": {"TestConvertDType": 0.1931666666666667}, "torch_np/test_function_base": {"TestAppend": 0.15666666666666668}, "torch_np/test_ndarray_methods": {"TestAmax": 0.009500000000000001, "TestAmin": 0.009500000000000001, "TestArgmax": 1.307, "TestArgmaxArgminCommon": 0.9166666666666657, "TestArgmin": 1.5209999999999997, "TestContains": 0.0025, "TestIndexing": 0.18833333333333332, "TestIter": 0.007333333333333332, "TestNoExtraMethods": 0.011333333333333334, "TestNonzero": 0.21333333333333335, "TestRavel": 0.009000000000000001, "TestReshape": 0.0085, "TestTranspose": 0.017333333333333333}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 1.8251666666666064, "TestNEP50Table": 0.05850000000000003}, "torch_np/test_random": {"TestChoice": 0.010833333333333334, "TestNumpyGlobal": 0.004166666666666667, "TestScalarReturn": 0.1771666666666667, "TestShuffle": 0.011000000000000003}, "torch_np/test_reductions": {"TestAll": 0.014499999999999999, "TestAny": 0.015166666666666665, "TestFlatnonzero": 0.18983333333333335, "TestGenericCumSumProd": 0.021833333333333337, "TestGenericReductions": 2.5086666666666186, "TestMean": 0.03066666666666667, "TestSum": 0.3506666666666667}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.17183333333333334, "TestIsScalar": 0.02833333333333335}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.7751666666666668, "TestNdarrayDunderVsUfunc": 0.25733333333333347, "TestUfuncDtypeKwd": 0.009166666666666667, "TestUnaryUfuncs": 0.19716666666666666}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.30183333333333345}}, "default": {"backends/xeon/test_launch": {"TestTorchrun": 2.0264038461538467}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.650429487179487}, "distributed/_composable/fsdp/test_fully_shard_autograd": {"TestFullyShardAutograd": 33.41277777777778}, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize2": 12.18811111111111, "TestClipGradNormWorldSize4": 7.707976190476189}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 29.8885, "TestFullyShardCollectiveOps": 70.71745238095238, "TestFullyShardCommunication": 18.239738095238096, "TestFullyShardPrefetch": 22.321722222222224, "TestFullyShardUnshardMultiProcess": 8.889190476190475, "TestFullyShardUnshardMultiThread": 0.019476190476190477}, "distributed/_composable/fsdp/test_fully_shard_compile": {"TestFullyShardCompile": 4.546666666666667, "TestFullyShardCompileCompute": 10.594333333333333}, "distributed/_composable/fsdp/test_fully_shard_extensions": {"TestFullyShardAllGatherExtensionsMultiProcess": 14.416722222222221, "TestFullyShardAllGatherExtensionsMultiThread": 7.688722222222222}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 31.934642857142855}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.11283333333333334, "TestFullyShardDeviceTensor": 0.17194444444444446, "TestFullyShardHSDPBroadcast": 0.4405555555555556, "TestFullyShardLazyInit": 0.050722222222222224, "TestFullyShardManagedModulesAndStates": 0.026, "TestFullyShardMeshArg": 0.0071666666666666675, "TestFullyShardMetaDeviceInit": 10.063055555555556, "TestFullyShardParamModuleInfos": 0.011944444444444445, "TestFullyShardProcessGroupInit": 0.6194444444444444, "TestFullyShardShardedParameterDTensor": 0.0665, "TestFullyShardShardedParameterTensor": 0.05499999999999999}, "distributed/_composable/fsdp/test_fully_shard_memory": {"TestFullyShardMemory": 13.053888888888887}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionCasts": 23.0885, "TestFullyShardMixedPrecisionTraining": 26.482}, "distributed/_composable/fsdp/test_fully_shard_overlap": {"TestFullyShardOverlap": 7.277333333333334}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.1968888888888889}, "distributed/_composable/fsdp/test_fully_shard_state_dict": {"TestFullyShardStateDictMultiProcess": 26.061944444444446, "TestFullyShardStateDictMultiThread": 0.2615}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 9.88009523809524, "TestFullyShard1DTrainingCore": 121.32390476190476, "TestFullyShard2DTraining": 12.39542857142857, "TestFullyShardCastAfterInit": 0.42333333333333334, "TestFullyShardCustomForwardMethod": 13.657111111111112, "TestFullyShardForwardInputs": 0.18666666666666665, "TestFullyShardGradientAccumulation": 25.08885714285714, "TestFullyShardHSDPTraining": 5.86047619047619, "TestFullyShardNDTraining": 10.840208333333335, "TestFullyShardRegisteredParams": 7.289833333333333, "TestFullyShardSharedParams": 11.944611111111113, "test_fully_shard_training": 0.0003333333333333333}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 35.36183333333334}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 33.48494444444444}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 11.491166666666667}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 20.129944444444444}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 23.009666666666664}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 23.881888888888884}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 4.630777777777777}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 6.976499999999999}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 88.89283333333333}, "distributed/_composable/test_contract": {"TestContract": 0.29838888888888887}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 7.887388888888888, "ReplicateTest": 46.84861111111112}, "distributed/_composable/test_replicate_with_compiler": {"DDP_TP_Test": 1.5133333333333334, "ReplicateTest": 56.18622222222223}, "distributed/_shard/sharded_optim/test_sharded_optim": {"TestShardedOptimizer": 3.844666666666666}, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": {"TestShardedTensorBinaryOps": 7.607666666666668}, "distributed/_shard/sharded_tensor/ops/test_embedding": {"TestShardedEmbedding": 3.8426666666666667}, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": {"TestShardedEmbeddingBag": 3.840166666666667}, "distributed/_shard/sharded_tensor/ops/test_init": {"TestShardedTensorNNInit": 5.751166666666667}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 14.230166666666667}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.28938888888888886}, "distributed/_shard/sharded_tensor/test_sharded_tensor": {"TestCreateTensorFromParams": 0.11388888888888889, "TestCreateTensorNoProcessGroupMode": 0.0034444444444444444, "TestLocalTensor": 6.7202222222222225, "TestModuleHookApi": 6.759111111111111, "TestShardMetadata": 8.990777777777778, "TestShardParameter": 6.695833333333333, "TestShardTensor": 10.091166666666668, "TestShardedTensorChunked": 93.79894444444444, "TestShardedTensorCustomOps": 13.4965, "TestShardedTensorEnumerable": 61.76577777777778, "TestShardedTensorFromLocalShards": 43.757000000000005, "TestShardedTensorFromLocalTensor": 9.056500000000002, "TestShardedTensorMetadata": 0.3413888888888889, "TestShardedTensorSubGroupInit": 0.03311111111111111}, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": {"TestReshard": 7.0554444444444435}, "distributed/_shard/sharding_plan/test_sharding_plan": {"TestShardingPlan": 10.615222222222222}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 13.772416666666668, "TestShardingSpec": 0.037250000000000005}, "distributed/_shard/test_sharder": {"TestCustomSharder": 5.797944444444444}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 6.5935}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.45611111111111113}, "distributed/_tensor/experimental/test_local_map": {"TestLocalMap": 45.07005555555555}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 26.762611111111113}, "distributed/_tensor/test_api": {"DTensorAPITest": 30.975833333333338}, "distributed/_tensor/test_attention": {"RingAttentionTest": 3.317166666666666}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 38.51533333333333}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 46.972388888888894}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 41.93577777777778, "DTensorTest": 84.06099999999999, "TestDTensorPlacementTypes": 4.1641111111111115}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 13.640687499999999, "TestDTensorCompileE2E": 28.754979166666665}, "distributed/_tensor/test_dtensor_ops": {"TestDTensorOpsCPU": 62.59200000000002}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 13.99211111111111}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 13.451666666666666}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 22.999166666666667, "DTensorInitOpsTest": 4.6339999999999995}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 48.515499999999996}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 79.99211111111111}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.103, "TestEinsumDims": 0.2756111111111111, "TestEinsumStrategies": 0.059}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 120.10527777777777}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.6277777777777778}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 5.170458333333333, "DistTensorRandomOpTest": 28.531708333333334}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 5.8643888888888895, "RedistributeTest": 38.53911111111111}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 182.90422222222222}, "distributed/_tensor/test_utils": {"Test2DStridedLocalShard": 7.6755, "UtilTest": 16.199277777777777}, "distributed/_tensor/test_view_ops": {"TestViewOps": 27.83388888888889}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.2886666666666667}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 8.913166666666667}, "distributed/_tools/test_mod_tracker": {"TestModTracker": 0.29033333333333333}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 29.140777777777775}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 42.453888888888876}, "distributed/algorithms/test_join": {"TestJoin": 36.794444444444444}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ESaveAndLoad": 44.26061111111111, "TestNoCPU": 4.381333333333333}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 2.9839444444444445}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 2.972555555555555}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 3.7279999999999998}, "distributed/checkpoint/fsdp/test_fsdp_dsd": {"TestFullyShardWithDistributedStateDict": 14.539333333333332}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 8.235208333333333, "TestDistributedFailure": 23.019666666666666}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.43272222222222223}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.31450000000000006}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 4.835388888888889}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 18.29372222222222, "TestDTensorReshardPlacementChange": 8.45}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 16.852416666666667, "TestDistributedStateDictSaveLoad": 0.493625, "TestDistributedStateDictSaveLoadWithSharedTensor": 4.136458333333333}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 30.452555555555552, "TestDistributedStateDictSaveLoad": 0.4397222222222223, "TestDistributedStateDictSaveLoadWithSharedTensor": 7.413611111111112}, "distributed/checkpoint/test_format_utils": {"TestFormatUtils": 12.461888888888888}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 15.287555555555556}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 22.751666666666665}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 11.743055555555557}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.43816666666666665, "TestFSSpecWithDist": 14.187888888888887}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 14.92827777777778}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.28994444444444445}, "distributed/checkpoint/test_planner": {"TestLoadPlanner": 0.15605555555555556, "TestPlannerHelpers": 0.002166666666666667, "TestSavePlan": 0.30211111111111105}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 3.8168333333333333}, "distributed/checkpoint/test_state_dict": {"TestNoComm": 4.245277777777777, "TestStateDict": 152.3171111111111}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 14.793999999999999}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 16.425}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.2953333333333333}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.3000555555555556, "TestTensorProperties": 0.002}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.30266666666666664, "RdzvEventLibTest": 0.06516666666666668}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.30088888888888893}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.3057222222222222, "StartProcessesListTest": 20.76111111111111, "StartProcessesTest": 15.999055555555557, "StdTest": 0.0051666666666666675}, "distributed/elastic/test_control_plane": {"WorkerServerTest": 4.9078333333333335}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 14.971055555555553}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.15422222222222223, "LocalTimerTest": 3.9008888888888897, "MultiprocessingRequestQueueTest": 1.6943333333333335}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 2.691444444444444}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.3277222222222222}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.3035555555555556, "UtilTest": 0.060277777777777784}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 5.281}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.30470833333333336}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 15.121749999999999}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 11.917874999999999}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 163.22283333333334, "TestFSDPCheckpointSubmodule": 10.006875}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 55.458375}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 82.15174999999999, "TestExplicitUnshard": 18.656333333333333}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 209.35137500000005}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 10.931875, "TestHooks": 72.57775000000001, "TestNoGrad": 20.743583333333333, "TestParamInit": 20.58083333333333, "TestParityWithDDP": 1186.7406666666666}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 148.79108333333335}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 81.06995833333333}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 46.93870833333334}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 64.57333333333334}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 333.7752916666667}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.32433333333333336}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 64.846}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 56.932375}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 101.27754166666665}, "distributed/fsdp/test_fsdp_input": {"TestInput": 19.035083333333333}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 24.812333333333335}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 68.71883333333335}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 107.71870833333332, "TestFSDPMiscMultiThread": 0.5988333333333334, "TestFSDPMiscWorldSize1": 4.883416666666667}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 59.15275, "TestFSDPMixedPrecisionIgnoredModules": 9.381666666666668, "TestFSDPMixedPrecisionSharded": 493.65195833333337, "TestFSDPMixedPrecisionUnsharded": 28.446666666666665, "TestFSDPTrainEval": 11.884875000000001}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 10.419083333333333}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 10.312958333333333}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 621.6459166666667}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 20.140791666666665, "TestForwardOverlapWorldSizeTwo": 30.708375000000004}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 20.521124999999998}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.44554166666666667, "TestShardedGradScalerParityWithDDP": 195.25250000000003}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 982.1815416666666, "TestFSDPStateDict4GPUs": 4.431666666666667}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 22.29254166666667}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 4.954083333333333}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 10.312999999999999}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 55.64458333333334, "TestUnshardParamsErrors": 23.778333333333332, "TestUnshardParamsNoShard": 9.222750000000001}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 10.406958333333334, "TestFSDPUseOrigParamsInit": 5.2805, "TestFSDPUseOrigParamsMultipleParamGroups": 176.75333333333333, "TestFSDPUseOrigParamsNoSync": 20.397291666666668, "TestFSDPUseOrigParamsParamAccess": 10.278875, "TestFSDPUseOrigParamsUnshardReshard": 46.016999999999996, "TestFSDPUseOrigParamsWriteback": 40.68170833333333, "TestMultiTensorApply": 0.10004166666666667}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 39.82325}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 4.9935, "TestShardUtilsDistributedDTensor": 4.7010000000000005}, "distributed/fsdp/test_utils": {"TestUtils": 0.48287499999999994}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 8.424333333333333, "TestFSDPWrap": 183.159625, "TestWrapUtils": 0.017291666666666667}, "distributed/launcher/test_run": {"ElasticLaunchTest": 43.455611111111104}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.3082777777777778}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 173.64716666666664, "TestZeroRedundancyOptimizerSingleRank": 31.13588888888889}, "distributed/pipelining/test_backward": {"StageBackwardTests": 0.31733333333333336}, "distributed/pipelining/test_composability": {"ComposabilityTest": 32.416000000000004}, "distributed/pipelining/test_microbatch": {"MicrobatchTests": 0.7111666666666666}, "distributed/pipelining/test_pipe": {"PipeTests": 1.2026111111111109}, "distributed/pipelining/test_schedule": {"ScheduleTest": 26.231999999999996, "TestSchedulePlan": 0.9938333333333333}, "distributed/pipelining/test_stage": {"StageTest": 23.225583333333333}, "distributed/pipelining/test_transformer": {"TransformerTests": 1.0212222222222223}, "distributed/pipelining/test_unflatten": {"UnflattenTests": 0.9515000000000001}, "distributed/rpc/cuda/test_tensorpipe_agent": {"TensorPipeCudaDdpComparisonTest": 3.924055555555556, "TensorPipeCudaDistAutogradTest": 15.384666666666666, "TensorPipeCudaRemoteModuleTest": 17.59572222222222, "TensorPipeCudaRpcTest": 5.090222222222222, "TensorPipeTensorPipeAgentCudaRpcTest": 553.0153888888889, "TensorPipeTensorPipeCudaDistAutogradTest": 15.906}, "distributed/rpc/test_faulty_agent": {"FaultyFaultyAgentDistAutogradTest": 19.854333333333333, "FaultyFaultyAgentRpcTest": 177.38566666666668, "FaultyJitFaultyAgentRpcTest": 49.06}, "distributed/rpc/test_share_memory": {"TestRPCPickler": 3.7123333333333335}, "distributed/rpc/test_tensorpipe_agent": {"TensorPipeDdpComparisonTest": 14.408000000000001, "TensorPipeDdpUnderDistAutogradTest": 5.460666666666666, "TensorPipeDistAutogradTest": 238.13166666666666, "TensorPipeDistOptimizerTest": 15.234, "TensorPipeJitDistAutogradTest": 14.283666666666667, "TensorPipeJitRpcTest": 193.28366666666668, "TensorPipeParameterServerTest": 3.5276666666666667, "TensorPipeReinforcementLearningRpcTest": 3.6926666666666663, "TensorPipeRemoteModuleTest": 42.486333333333334, "TensorPipeRpcTest": 798.1766666666668, "TensorPipeTensorPipeAgentDistAutogradTest": 112.9833333333333, "TensorPipeTensorPipeAgentRpcTest": 154.62300000000002, "TensorPipeThreeWorkersRemoteModuleTest": 9.881333333333332}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 5.087666666666666}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 38.85452083333333, "TestNew2dParallelTraining": 27.3410625}, "distributed/tensor/parallel/test_micro_pipeline_tp": {"MicroPipelineTPTest": 11.137500000000001, "test_micro_pipeline_tp": 0.0}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 38.60938888888889}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 53.93841666666667}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 5.03975}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 67.87922222222223}, "distributed/test_c10d_common": {"CommTest": 3.7770666666666672, "ComputeBucketAssignmentTest": 1.1454333333333335, "LocalRankTest": 15.901566666666664, "ProcessGroupWithDispatchedCollectivesTests": 7.563766666666666, "PythonProcessGroupExtensionTest": 31.2063, "ReduceOpTest": 1.1564, "TimeoutTest": 37.526799999999994}, "distributed/test_c10d_functional_native": {"CompileTest": 90.56211904761905, "TestWithNCCL": 41.19578571428571}, "distributed/test_c10d_gloo": {"CommTest": 44.928875000000005, "CompilerTest": 46.93816666666666, "DistributedDataParallelTest": 269.7095416666667, "GlooProcessGroupWithDispatchedCollectivesTests": 26.752833333333335, "LargeCommTest": 12.754958333333335, "ProcessGroupGlooTest": 230.90745833333338, "ReducerTest": 0.30333333333333334, "RendezvousEnvTest": 0.3314166666666667, "TimeoutTest": 4.113041666666667}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 16.512666666666664}, "distributed/test_c10d_nccl": {"CommTest": 94.22649999999999, "CompilerTest": 69.84887499999999, "DistributedDataParallelTest": 662.45375, "LargeCommTest": 70.76658333333333, "NCCLTraceTest": 129.47983333333335, "NCCLTraceTestDumpOnTimeout": 15.720291666666665, "NCCLTraceTestTimeoutDumpOnStuckRanks": 8.393291666666668, "NcclErrorDumpTest": 12.241625, "NcclErrorHandlingTest": 39.189166666666665, "NcclProcessGroupWithDispatchedCollectivesTests": 36.454458333333335, "ProcessGroupNCCLGroupTest": 100.36608333333334, "ProcessGroupNCCLNoGPUTest": 0.00125, "RendezvousEnvTest": 0.044708333333333336, "SparseCollective": 13.147124999999999, "TimeoutTest": 3.8089999999999997, "WorkHookTest": 36.237791666666666}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 41.899}, "distributed/test_c10d_ops_nccl": {"ProcessGroupNCCLOpTest": 8.399}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 176.14572222222228, "TestDDPWithWorkWrapper": 175.67194444444442}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 11.55, "ProcessGroupShareTensorTest": 11.6255, "TestDistributedNNFunctionsGloo": 34.66566666666667}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 13.826000000000002, "TestDistributedNNFunctionsNccl": 35.67704166666667}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.0037500000000000007, "TestDistributedNNFunctionsUcc": 7.775666666666667}, "distributed/test_c10d_ucc": {"CommTest": 29.427333333333333, "CompilerTest": 46.14833333333333, "DistributedDataParallelTest": 143.1026666666667, "ProcessGroupUCCTest": 27.559, "RendezvousEnvTest": 0.31033333333333335, "TimeoutTest": 3.3260000000000005, "UccProcessGroupWithDispatchedCollectivesTests": 7.928}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 2.935222222222222}, "distributed/test_control_collectives": {"TestCollectives": 0.3472777777777778}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 6.934749999999999}, "distributed/test_data_parallel": {"TestDataParallel": 15.05511111111111, "TestDataParallelDeviceTypeCPU": 0.019666666666666673, "TestDataParallelDeviceTypeCUDA": 0.09341666666666668}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 28.31516666666667, "DeviceMeshTest": 53.514916666666664, "DeviceMeshTestNDim": 24.470958333333336, "InitDeviceMeshTest": 14.270208333333334, "TestDeviceMeshGetItem": 28.71275, "TestMeshEnv": 19.66358333333333}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 5279.935888888899}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 15.770190476190475, "TestMultiProc": 96.30788095238096, "TestSingleProc": 18.169619047619047}, "distributed/test_fake_pg": {"TestFakePG": 6.841555555555555}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 25.78125, "TestExpand": 0.37325, "TestFunctionalAutograd": 13.717624999999998, "TestFunctionalAutogradWithNCCL": 3.9565833333333336, "TestGradCollectives": 0.004916666666666666, "TestMakeFx": 0.04666666666666666, "TestMetaCollectives": 0.002125, "TestNCCLCollectivesWithWorldSize4": 26.936208333333333, "TestPgTag": 0.042749999999999996, "TestTraceableCollectives": 0.41962500000000014}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.8905238095238093, "TestCollectivesMultiProc": 90.97433333333333}, "distributed/test_launcher": {"TestDistributedLaunch": 1.5170000000000001}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.30288888888888893, "TestCollectivesWithWrapper": 0.3458333333333334}, "distributed/test_nccl": {"TestNCCLCUDA": 0.5566666666666666}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 41.50991666666667, "ProcessGroupNCCLWrapperTest": 36.03175}, "distributed/test_store": {"FileStoreTest": 3.95375, "HashStoreTest": 2.2408333333333332, "InitPgWithNonUvStore": 0.6941666666666667, "LibUvTCPStoreTest": 11.26725, "PrefixFileStoreTest": 3.1842499999999996, "PrefixStoreTest": 0.01, "PrefixTCPStoreTest": 2.5817916666666667, "PythonStoreTest": 0.32329166666666664, "RendezvousEnvTest": 0.32458333333333333, "RendezvousFileTest": 0.6504583333333334, "RendezvousTCPTest": 26.988875, "RendezvousTest": 0.6385416666666668, "TCPStoreTest": 11.252291666666666, "TestMultiThreadedWait": 2.016125, "TestPythonStore": 2.2615, "TimeoutTest": 6.583291666666668}, "distributed/test_symmetric_memory": {"SymmetricMemoryTest": 0.0006666666666666666}, "distributions/test_constraints": {"test_constraints": 0.1666547619047618}, "distributions/test_distributions": {"TestAgainstScipy": 1.3259166666666666, "TestConstraints": 8.66370512820513, "TestDistributionShapes": 9.170051282051281, "TestDistributions": 40.97303846153846, "TestFunctors": 0.4584551282051284, "TestJit": 59.427410256410255, "TestKL": 3.566679487179487, "TestLazyLogitsInitialization": 8.57605769230769, "TestNumericalStability": 0.09215384615384617, "TestRsample": 0.8125512820512821, "TestValidation": 10.46305769230769}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 3.9584629629629635}, "dynamo/test_after_aot": {"TestAfterAot": 7.682259259259259}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 16.996805555555557}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.971611111111111, "AOTAutogradCacheTests": 16.51690740740741}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 3.9038148148148144}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.022027777777777778, "NormalizeIRTests": 0.04720370370370371, "TestCustomBackendAPI": 2.226453703703704, "TestExplainWithBackend": 13.095527777777775, "TestOptimizations": 2.4563240740740735}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 15.869750000000002}, "dynamo/test_base_output": {"TestBaseOutput": 0.003953703703703705}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 7.281759259259259, "BytecodeTests": 0.5473888888888889}, "dynamo/test_compile": {"InPlaceCompilationTests": 8.87037037037037, "PublicTorchCompilerTests": 0.002990740740740742}, "dynamo/test_comptime": {"ComptimeTests": 0.756101851851852}, "dynamo/test_config": {"ConfigTests": 0.695388888888889}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.8833981481481477}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 4.560404761904762}, "dynamo/test_debug_utils": {"TestDebugUtils": 1.1581944444444445}, "dynamo/test_decorators": {"DecoratorTests": 8.323694444444444}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.001888888888888889, "TestDeviceGuard": 0.02141666666666667}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 150.46187962962964, "DynamicShapesCtxManagerTests": 8.040796296296298, "DynamicShapesExportTests": 36.07580555555556, "DynamicShapesFuncTorchHigherOrderOpTests": 115.37016666666666, "DynamicShapesFunctionTests": 88.6488611111111, "DynamicShapesHigherOrderOpTests": 20.406351851851852, "DynamicShapesMiscTests": 110.76681481481485, "DynamicShapesNNModuleTests": 8.187925925925928, "DynamicShapesReproTests": 126.07362962962965, "DynamicShapesSubGraphTests": 12.390759259259259, "DynamicShapesTestSDPA": 0.4452777777777779}, "dynamo/test_exc": {"ExcTests": 2.400555555555556}, "dynamo/test_exceptions": {"ExceptionTests": 0.6440277777777779}, "dynamo/test_export": {"ExportTests": 20.563972222222223}, "dynamo/test_export_mutations": {"MutationExportTests": 0.6783703703703705}, "dynamo/test_frame_init": {"FrameInitTests": 0.2683148148148148}, "dynamo/test_functions": {"DefaultsTests": 0.951277777777778, "FunctionTests": 30.347037037037087}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.5337592592592595}, "dynamo/test_global": {"TestGlobals": 0.6499722222222223}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.31780555555555556}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 1.796907407407408, "FuncTorchHigherOrderOpTests": 11.82811111111111, "HigherOrderOpTests": 9.759629629629629, "HigherOrderOpVmapGuardTests": 4.86800925925926}, "dynamo/test_hooks": {"HooksTests": 32.61055555555557}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 11.086916666666667, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 11.702305555555556, "InlineInbuiltNNModulesFunctionTests": 21.428740740740754, "InlineInbuiltNNModulesHigherOrderOpTests": 9.139212962962961, "InlineInbuiltNNModulesMiscTests": 71.27860185185199, "InlineInbuiltNNModulesNNModuleTests": 6.299648148148146}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 10.147685185185184}, "dynamo/test_interop": {"InteropTests": 0.7015}, "dynamo/test_logging": {"LoggingTests": 23.041064814814817}, "dynamo/test_minifier": {"MinifierTests": 3.004222222222223}, "dynamo/test_misc": {"MiscTests": 74.20433333333345, "TestTracer": 0.07909259259259259}, "dynamo/test_model_output": {"TestHFPretrained": 0.0012129629629629634, "TestModelOutput": 0.006824074074074076}, "dynamo/test_modules": {"NNModuleTests": 4.713916666666664, "OptimizedModuleTest": 22.175666666666668}, "dynamo/test_nops": {"NopTests": 0.3869444444444443}, "dynamo/test_optimizers": {"End2EndTests": 0.803675925925926}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.5880092592592593}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.624388888888889}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.8207592592592593}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.0725000000000002}, "dynamo/test_recompiles": {"RecompileTests": 1.06487962962963}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.6325462962962964}, "dynamo/test_repros": {"ReproTests": 56.90831481481483}, "dynamo/test_resume": {"ResumeFunctionTests": 0.5256481481481481}, "dynamo/test_sdpa": {"TestSDPA": 0.5850185185185186}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.6720740740740742}, "dynamo/test_sources": {"SourceTests": 0.5925462962962963}, "dynamo/test_structured_trace": {"StructuredTraceTest": 17.57995370370371}, "dynamo/test_subclasses": {"SubclassTests": 4.726111111111109, "TestNestedTensor": 14.679638888888888}, "dynamo/test_subgraphs": {"SubGraphTests": 2.8246111111111096}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.12678703703703706, "TraceRuleTests": 1.4048888888888884}, "dynamo/test_unspec": {"UnspecTests": 16.58600925925926}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.7303888888888888}, "dynamo/test_view": {"ViewTests": 0.7666759259259258}, "export/test_converter": {"TestConverter": 7.849514492753622}, "export/test_db": {"ExampleTests": 3.3310507246376817}, "export/test_experimental": {"TestExperiment": 1.2302685185185185}, "export/test_export": {"TestDynamismExpression": 0.7868913043478262, "TestExport": 31.184478260869568, "TestExportCustomClass": 0.09727536231884058, "TestOneOffModelExportResult": 1.4490869565217392}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.5531111111111111, "NonStrictExportTestExport": 32.49012962962963}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.37809420289855067}, "export/test_hop": {"TestHOPCPU": 2.700283333333333, "TestHOPCUDA": 3.237729166666667, "TestHOPGeneric": 0.09333333333333332}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002543478260869567, "TestLift": 0.23284782608695653}, "export/test_pass_infra": {"TestPassInfra": 1.1792753623188406}, "export/test_passes": {"TestPasses": 16.292231884057973}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.0888518518518517, "RetraceExportTestExport": 53.93868518518517}, "export/test_schema": {"TestSchema": 0.4237173913043478}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.723611111111111, "SerDesExportTestExport": 38.118018518518525}, "export/test_serialize": {"TestDeserialize": 8.173166666666669, "TestSaveLoad": 0.3932971014492753, "TestSchemaVersioning": 0.04167391304347827, "TestSerialize": 1.5159927536231885, "TestSerializeCustomClass": 0.11406521739130435}, "export/test_sparse": {"TestSparseProp": 85.0647101449275}, "export/test_tools": {"TestExportTools": 0.7853623188405798}, "export/test_torchbind": {"TestCompileTorchbind": 1.4655362318840581, "TestExportTorchbind": 2.4530362318840573, "TestRegisterFakeClass": 0.004434782608695655}, "export/test_tree_utils": {"TestTreeUtils": 0.3665724637681159}, "export/test_unflatten": {"TestUnflatten": 4.086101449275363}, "export/test_verifier": {"TestVerifier": 1.2445942028985508}, "functorch/test_ac": {"MemoryBudgetTest": 12.085833333333333}, "functorch/test_aotdispatch": {"TestAOTAutograd": 20.592955128205134, "TestAOTAutogradWithDynamo": 16.72805769230769, "TestAOTDispatch": 1.4315833333333334, "TestAOTExport": 3.026839743589743, "TestAOTModuleSimplified": 0.9754551282051284, "TestEagerFusionModuleInfoCPU": 767.9015384615383, "TestEagerFusionOpInfoCPU": 1809.4615512820503, "TestPartitioning": 3.3410192307692297, "TestPythonKeyCPU": 4.5206923076923085}, "functorch/test_control_flow": {"TestControlFlow": 1.6939743589743586, "TestControlFlowTraced": 147.57027564102566}, "functorch/test_dims": {"TestMin": 16.877583333333337, "TestMinFunctorchOnly": 15.798076388888893}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 1.2224871794871794, "TestAutogradFunctionCUDA": 0.12316666666666673, "TestAutogradFunctionVmapAPICPU": 0.24846153846153843, "TestAutogradFunctionVmapAPICUDA": 0.027625, "TestCompileTransformsCPU": 9.608769230769228, "TestCompileTransformsCUDA": 4.5010625, "TestComposabilityCPU": 4.1614615384615385, "TestComposabilityCUDA": 0.21287500000000006, "TestExamplesCorrectnessCPU": 12.548551282051282, "TestExamplesCorrectnessCUDA": 5.3911875, "TestFunctionalizeCPU": 0.8666923076923078, "TestFunctionalizeCUDA": 0.1493541666666667, "TestGradTransformCPU": 5.7733846153846144, "TestGradTransformCUDA": 3.297500000000001, "TestHelpersCPU": 0.19314102564102567, "TestHelpersCUDA": 0.017479166666666667, "TestHessianCPU": 1.1088333333333333, "TestHessianCUDA": 0.09425, "TestHigherOrderOperatorInteractionCPU": 0.33753846153846145, "TestHigherOrderOperatorInteractionCUDA": 0.036708333333333336, "TestJacCPU": 14.216705128205124, "TestJacCUDA": 0.9921458333333338, "TestJvpCPU": 1.6415256410256414, "TestJvpCUDA": 0.08054166666666668, "TestLinearizeCPU": 0.5509487179487179, "TestLinearizeCUDA": 0.3987083333333334, "TestMakeFunctional": 0.3278846153846154, "TestSliceArgnums": 0.14048076923076924, "TestVmapJvpInplaceViewCPU": 1.1361923076923075, "TestVmapJvpInplaceViewCUDA": 0.024708333333333336, "TestVmapOfGradCPU": 6.646461538461538, "TestVmapOfGradCUDA": 0.7045625000000001}, "functorch/test_logging": {"TestAOTLogging": 0.44119871794871796}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.5478055555555555, "RandomOpTestCase": 0.13906944444444444, "ReduceTestCase": 0.15056250000000002, "TestMemoryEfficientOpAuthoring": 3.2240208333333342}, "functorch/test_minifier": {"TestMinifier": 0.7323141025641028}, "functorch/test_ops": {"TestOperatorsCPU": 2285.4609230769156, "TestOperatorsCUDA": 5753.745999999989}, "functorch/test_parsing": {"TestAnonymousAxis": 0.4094791666666666, "TestParsedExpression": 0.008451388888888892, "TestParsingUtils": 0.008944444444444448, "TestValidateRearrangeExpressions": 0.00885416666666667}, "functorch/test_rearrange": {"TestRearrange": 0.776652777777778}, "functorch/test_vmap": {"TestRandomnessCPU": 33.62473076923077, "TestRandomnessCUDA": 1.3622916666666667, "TestTransformFailureCPU": 0.18106410256410255, "TestTransformFailureCUDA": 0.2530625, "TestVmapAPI": 6.52623076923077, "TestVmapBatchedGradientCPU": 7.609602564102564, "TestVmapBatchedGradientCUDA": 0.29737500000000006, "TestVmapDeviceTypeCPU": 0.44938461538461544, "TestVmapDeviceTypeCUDA": 0.030604166666666665, "TestVmapNestedTensorCPU": 0.5938333333333334, "TestVmapNestedTensorCUDA": 0.08060416666666667, "TestVmapOperators": 127.89448076923077, "TestVmapOperatorsOpInfoCPU": 565.0421153846144, "TestVmapOperatorsOpInfoCUDA": 444.820854166666}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 4.627544871794706}, "higher_order_ops/test_with_effects": {"TestWithEffects": 7.904121794871795}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 524.1726041666666, "AOTInductorTestABICompatibleCpuWithStackAllocation": 370.12556249999983, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 164.28564583333332, "AOTInductorTestABICompatibleCuda": 1066.7820625, "AOTInductorTestNonABICompatibleCpu": 1060.3577499999994, "AOTInductorTestNonABICompatibleCuda": 1678.629479166667}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 11.35221568627451, "BenchmarkFusionCudaTest": 82.41055555555556, "BenchmarkMultiTemplateFusionCudaTest": 26.071277777777777}, "inductor/test_binary_folding": {"FreezingCpuTests": 49.14221568627451, "FreezingGpuTests": 2.3025555555555557}, "inductor/test_codecache": {"TestFxGraphCache": 63.07300925925924, "TestFxGraphCacheHashing": 0.9855833333333331, "TestUtils": 4.424638888888889, "test_codecache": 1.1617500000000003}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.2792314814814815}, "inductor/test_compile_worker": {"TestCompileWorker": 11.937111111111111}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 381.2296203703708, "TestCompiledAutograd": 226.13721296296296, "TestCustomOpWithCompiledAutograd": 2.6372222222222192}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 557.2139285714286, "CompiledOptimizerParityTestsCUDA": 318.68733333333336, "CompiledOptimizerTests": 537.0672037037041}, "inductor/test_config": {"TestInductorConfig": 7.706185185185183}, "inductor/test_control_flow": {"CondTests": 15.129824074074078, "WhileLoopTests": 7.214148148148147}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.4170000000000003}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1407.770619047619, "TestCppWrapper": 1438.8311904761904}, "inductor/test_cpu_repro": {"CPUReproTests": 877.8436470588235}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 1912.6236666666664, "TestSelectAlgorithmDynamicShapesCPU": 1893.7257499999998}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 835.8109583333334, "TestCudaWrapper": 788.87875}, "inductor/test_cuda_repro": {"CudaReproTests": 139.61511111111113}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 81.14294444444444}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.5315370370370371}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 14.52320588235294}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 82.83066666666667}, "inductor/test_debug_trace": {"TestDebugTrace": 6.902240740740742}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 7.324694444444442}, "inductor/test_dependencies": {"TestDependencies": 0.1935}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 48.03400980392157}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 60.27895098039218, "EfficientConvBNEvalCudaTests": 101.39911111111111}, "inductor/test_extension_backend": {"ExtensionBackendTests": 25.413196078431373}, "inductor/test_flex_attention": {"TestFlexAttention": 125.13767592592593}, "inductor/test_foreach": {"ForeachTests": 75.83787037037045}, "inductor/test_fp8": {"TestFP8Types": 0.010000000000000002}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 101.20982352941175, "SDPAPatternRewriterCpuTests": 97.84820588235293, "SDPAPatternRewriterCudaDynamicTests": 41.28855555555557, "SDPAPatternRewriterCudaTests": 38.93100000000001}, "inductor/test_fx_fusion": {"TestFxFusion": 0.26066666666666666}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.019490196078431374}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.20539814814814816, "TestGroupBatchFusion": 27.182861111111112, "TestPostGradBatchLinearFusion": 0.36600925925925926}, "inductor/test_halide": {"HalideTests": 1.8415}, "inductor/test_indexing": {"ExprPrinterTests": 0.056342592592592604, "TestIndexingSimplification": 1.0080277777777777}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 68.28342156862745, "FreezingCudaTests": 35.8125}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 5.649333333333334}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 195.26311111111113}, "inductor/test_layout_optim": {"TestLayoutOptim": 15.802777777777777}, "inductor/test_loop_ordering": {"LoopOrderingTest": 9.034611111111111}, "inductor/test_max_autotune": {"TestMaxAutotune": 288.15355555555544, "TestTuningProcess": 10.91961111111111}, "inductor/test_memory_planning": {"TestMemoryPlanning": 30.02355555555555}, "inductor/test_metrics": {"TestMetrics": 3.9586666666666672}, "inductor/test_minifier": {"MinifierTests": 32.57388541666668}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 70.84967857142856}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 172.33556862745095, "TestPatternMatcher": 675.1099607843138}, "inductor/test_mmdecomp": {"TestDecompCPU": 6.36181481481482, "TestDecompCUDA": 4.742428571428573}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.044333333333334}, "inductor/test_multi_kernel": {"MultiKernelTest": 82.72833333333334}, "inductor/test_pad_mm": {"PadMMTest": 139.20988888888888}, "inductor/test_padding": {"PaddingTest": 14.436333333333332, "PerfTestBetweenGoodAndBadShape": 0.0015555555555555557, "PerfTestWithAndWithoutPadding": 8.377}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 105.98333333333333}, "inductor/test_perf": {"FusionTests": 17.433888888888887, "InplacingTests": 8.076666666666666, "MinCutPartitioningTests": 14.072666666666668, "NoopTests": 1.102888888888889, "NumBytesMetricTests": 31.455222222222222, "SchedulerFusionTests": 9.443222222222223, "TilingTests": 2.4916666666666667}, "inductor/test_profiler": {"DynamoProfilerTests": 6.621555555555555}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 119.06477777777779}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 7.413444444444444, "MemoryBoundedTests": 2.598222222222222, "TestCommAnalysis": 4.421333333333333, "UnsupportedTests": 0.34933333333333333}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 100.75111111111111}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 22.586814814814815}, "inductor/test_torchbind": {"TestTorchbind": 10.770675925925921}, "inductor/test_torchinductor": {"CpuTests": 1700.3282196969694, "GPUTests": 1006.0174523809526, "NanCheckerTest": 1.3449166666666665, "RNNTest": 1.6211111111111112, "SweepInputsCpuTest": 145.01507936507937, "SweepInputsGPUTest": 35.18855555555556, "TestFull": 12.977928571428569, "TritonCodeGenTests": 53.7053888888889}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1924.4682499999992, "DynamicShapesCodegenGPUTests": 1153.2641111111109}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2016.6585588235291, "DynamicShapesGPUTests": 1553.0175555555554, "TestInductorDynamicCPU": 0.031194444444444455, "TestInductorDynamicCUDA": 21.721785714285716}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 17535.123547619056, "TestInductorOpInfoCUDA": 8860.820633333347}, "inductor/test_torchinductor_strided_blocks": {"TritonBlockPointerTest": 18.653000000000002}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 1.1911960784313729}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 23.89633333333333}, "inductor/test_triton_kernels": {"KernelTests": 18.903444444444442, "MutationTests": 0.08813888888888892}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 9.376444444444445}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 24.20477777777778}, "inductor/test_utils": {"TestUtils": 0.26877777777777784}, "lazy/test_debug_util": {"DebugUtilTest": 0.33257051282051286}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.4865705128205128}, "lazy/test_generator": {"LazyGeneratorTest": 0.48208333333333336}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.659525641025641}, "lazy/test_step_closures": {"ClosuresTest": 2.756134615384615}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.3971089743589743, "TestLazyOpInfoCPU": 8.544448717948708, "TestLazyTensor": 0.1183076923076923}, "nn/test_convolution": {"TestConvolutionNN": 29.73637179487179, "TestConvolutionNNDeviceTypeCPU": 47.6037179487179, "TestConvolutionNNDeviceTypeCUDA": 47.52935416666665}, "nn/test_dropout": {"TestDropoutNN": 0.3114358974358975, "TestDropoutNNDeviceTypeCPU": 1.3899487179487175, "TestDropoutNNDeviceTypeCUDA": 1.1002083333333335}, "nn/test_embedding": {"TestEmbeddingNN": 0.6597179487179485, "TestEmbeddingNNDeviceTypeCPU": 56.02691025641025, "TestEmbeddingNNDeviceTypeCUDA": 20.45070833333332}, "nn/test_init": {"TestNNInit": 30.246070512820513}, "nn/test_lazy_modules": {"TestLazyModules": 2.1443974358974356}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.2237948717948715, "TestLoadStateDictSwap": 0.05728846153846154}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.08196153846153847, "TestModuleHookNN": 0.3271666666666667, "TestModuleHooks": 1.652987179487179, "TestStateDictHooks": 0.1975512820512821}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 23.877019230769232, "TestMultiheadAttentionNNDeviceTypeCPU": 0.3568333333333334, "TestMultiheadAttentionNNDeviceTypeCUDA": 2.2032499999999997}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.3024423076923077}, "nn/test_parametrization": {"TestNNParametrization": 3.79426282051282, "TestNNParametrizationDeviceCPU": 0.039961538461538465, "TestNNParametrizationDeviceCUDA": 2.099041666666667}, "nn/test_pooling": {"TestAvgPool": 0.7168397435897433, "TestPoolingNN": 0.6806923076923076, "TestPoolingNNDeviceTypeCPU": 39.992961538461536, "TestPoolingNNDeviceTypeCUDA": 10.139479166666662}, "nn/test_pruning": {"TestPruningNN": 0.9004679487179483}, "onnx/dynamo/test_dynamo_with_onnxruntime_backend": {"TestDynamoWithONNXRuntime": 30.188000000000002}, "onnx/dynamo/test_exporter_api": {"TestDynamoExportAPI": 61.75300000000001, "TestExportOptionsAPI": 0.535, "TestLargeProtobufONNXProgramSerializerAPI": 42.720333333333336, "TestONNXExportWithDynamo": 4.983, "TestProtobufONNXProgramSerializerAPI": 48.61033333333333}, "onnx/dynamo/test_registry_dispatcher": {"TestDispatcher": 0.08066666666666666, "TestOpSchemaWrapper": 0.021000000000000008, "TestRegistration": 0.02}, "onnx/internal/test_beartype": {"TestBeartype": 0.06433333333333334}, "onnx/internal/test_diagnostics": {"TestDiagnosticsInfra": 0.03333333333333335, "TestDynamoOnnxDiagnostics": 0.11333333333333334, "TestTorchScriptOnnxDiagnostics": 0.03866666666666666}, "onnx/internal/test_registraion": {"TestGlobalHelpers": 0.08666666666666668, "TestOverrideDict": 0.008333333333333333, "TestRegistrationDecorators": 0.013000000000000003}, "onnx/test_autograd_funs": {"TestAutogradFuns": 0.09333333333333334}, "onnx/test_custom_ops": {"TestCustomAutogradFunction": 0.05266666666666666, "TestExportAsContribOps": 0.073}, "onnx/test_export_modes": {"TestExportModes": 0.12333333333333335}, "onnx/test_fx_op_consistency": {"TORCH_EXPORT_EXPORTEDPROGRAMCPU": 4947.014666666667, "TORCH_NN_MODULECPU": 4035.7103333333257}, "onnx/test_fx_passes": {"TestFxPasses": 1.0526666666666666, "TestModularizePass": 1.184}, "onnx/test_fx_to_onnx": {"TestFxToOnnx": 50.69466666666668}, "onnx/test_fx_to_onnx_decomp_skip": {"TestDynamoExportDecompSkip": 3.104333333333333}, "onnx/test_fx_to_onnx_with_onnxruntime": {"TORCH_EXPORT_EXPORTEDPROGRAM": 357.931, "TORCH_NN_MODULE": 414.32733333333334}, "onnx/test_fx_type_promotion": {"TestGeneratedTypePromotionRuleSet": 0.05533333333333334}, "onnx/test_models_onnxruntime": {"TestModels": 131.51500000000001, "TestModelsONNXRuntime_is_script_False": 33.96, "TestModelsONNXRuntime_is_script_True": 0.011333333333333334, "TestModels_new_jit_API": 168.3306666666667}, "onnx/test_onnx_opset": {"TestONNXOpset": 0.779}, "onnx/test_onnxscript_runtime": {"TestONNXScriptRuntime": 0.09000000000000001}, "onnx/test_op_consistency": {"TestOnnxModelOutputConsistency_opset10CPU": 3.975666666666665, "TestOnnxModelOutputConsistency_opset11CPU": 4.484333333333332, "TestOnnxModelOutputConsistency_opset12CPU": 4.247333333333333, "TestOnnxModelOutputConsistency_opset13CPU": 7.047999999999998, "TestOnnxModelOutputConsistency_opset14CPU": 6.655333333333331, "TestOnnxModelOutputConsistency_opset15CPU": 7.3023333333333325, "TestOnnxModelOutputConsistency_opset16CPU": 7.491333333333333, "TestOnnxModelOutputConsistency_opset17CPU": 7.896666666666666, "TestOnnxModelOutputConsistency_opset18CPU": 7.416333333333333, "TestOnnxModelOutputConsistency_opset19CPU": 6.850666666666665, "TestOnnxModelOutputConsistency_opset20CPU": 6.681666666666665, "TestOnnxModelOutputConsistency_opset9CPU": 4.011666666666667}, "onnx/test_operators": {"TestOperators": 3.262666666666662}, "onnx/test_pytorch_jit_onnx": {"TestJITIRToONNX_opset14": 0.1206666666666667}, "onnx/test_pytorch_onnx_no_runtime": {"TestONNXExport": 1.1673333333333333, "TestQuantizeEagerONNXExport": 0.015}, "onnx/test_pytorch_onnx_onnxruntime": {"TestONNXRuntime_opset_version_10_is_script_False_keep_initializers_as_inputs_False": 33.54499999999994, "TestONNXRuntime_opset_version_10_is_script_False_keep_initializers_as_inputs_True": 31.58966666666662, "TestONNXRuntime_opset_version_10_is_script_True_keep_initializers_as_inputs_False": 28.126999999999942, "TestONNXRuntime_opset_version_10_is_script_True_keep_initializers_as_inputs_True": 28.777999999999906, "TestONNXRuntime_opset_version_11_is_script_False_keep_initializers_as_inputs_False": 35.21933333333333, "TestONNXRuntime_opset_version_11_is_script_False_keep_initializers_as_inputs_True": 34.85999999999999, "TestONNXRuntime_opset_version_11_is_script_True_keep_initializers_as_inputs_False": 32.57433333333322, "TestONNXRuntime_opset_version_11_is_script_True_keep_initializers_as_inputs_True": 34.780333333333274, "TestONNXRuntime_opset_version_12_is_script_False_keep_initializers_as_inputs_False": 35.400999999999975, "TestONNXRuntime_opset_version_12_is_script_False_keep_initializers_as_inputs_True": 36.41099999999998, "TestONNXRuntime_opset_version_12_is_script_True_keep_initializers_as_inputs_False": 34.93266666666659, "TestONNXRuntime_opset_version_12_is_script_True_keep_initializers_as_inputs_True": 34.16899999999995, "TestONNXRuntime_opset_version_13_is_script_False_keep_initializers_as_inputs_False": 37.37066666666666, "TestONNXRuntime_opset_version_13_is_script_False_keep_initializers_as_inputs_True": 36.939333333333316, "TestONNXRuntime_opset_version_13_is_script_True_keep_initializers_as_inputs_False": 33.309999999999924, "TestONNXRuntime_opset_version_13_is_script_True_keep_initializers_as_inputs_True": 33.79699999999993, "TestONNXRuntime_opset_version_14_is_script_False_keep_initializers_as_inputs_False": 35.83466666666667, "TestONNXRuntime_opset_version_14_is_script_False_keep_initializers_as_inputs_True": 36.79166666666663, "TestONNXRuntime_opset_version_14_is_script_True_keep_initializers_as_inputs_False": 34.074333333333264, "TestONNXRuntime_opset_version_14_is_script_True_keep_initializers_as_inputs_True": 34.83533333333324, "TestONNXRuntime_opset_version_15_is_script_False_keep_initializers_as_inputs_False": 35.96766666666667, "TestONNXRuntime_opset_version_15_is_script_False_keep_initializers_as_inputs_True": 36.88833333333334, "TestONNXRuntime_opset_version_15_is_script_True_keep_initializers_as_inputs_False": 36.878333333333266, "TestONNXRuntime_opset_version_15_is_script_True_keep_initializers_as_inputs_True": 34.91133333333324, "TestONNXRuntime_opset_version_16_is_script_False_keep_initializers_as_inputs_False": 36.789333333333325, "TestONNXRuntime_opset_version_16_is_script_False_keep_initializers_as_inputs_True": 37.509999999999984, "TestONNXRuntime_opset_version_16_is_script_True_keep_initializers_as_inputs_False": 35.73933333333324, "TestONNXRuntime_opset_version_16_is_script_True_keep_initializers_as_inputs_True": 37.239999999999924, "TestONNXRuntime_opset_version_17_is_script_False_keep_initializers_as_inputs_False": 36.16533333333334, "TestONNXRuntime_opset_version_17_is_script_False_keep_initializers_as_inputs_True": 37.71733333333335, "TestONNXRuntime_opset_version_17_is_script_True_keep_initializers_as_inputs_False": 35.50299999999993, "TestONNXRuntime_opset_version_17_is_script_True_keep_initializers_as_inputs_True": 35.72833333333323, "TestONNXRuntime_opset_version_18_is_script_False_keep_initializers_as_inputs_False": 37.018666666666675, "TestONNXRuntime_opset_version_18_is_script_False_keep_initializers_as_inputs_True": 37.150666666666666, "TestONNXRuntime_opset_version_18_is_script_True_keep_initializers_as_inputs_False": 35.69566666666654, "TestONNXRuntime_opset_version_18_is_script_True_keep_initializers_as_inputs_True": 36.14299999999988, "TestONNXRuntime_opset_version_19_is_script_False_keep_initializers_as_inputs_False": 39.11066666666667, "TestONNXRuntime_opset_version_19_is_script_False_keep_initializers_as_inputs_True": 39.131333333333345, "TestONNXRuntime_opset_version_19_is_script_True_keep_initializers_as_inputs_False": 37.60733333333331, "TestONNXRuntime_opset_version_19_is_script_True_keep_initializers_as_inputs_True": 38.87233333333332, "TestONNXRuntime_opset_version_20_is_script_False_keep_initializers_as_inputs_False": 39.65300000000001, "TestONNXRuntime_opset_version_20_is_script_False_keep_initializers_as_inputs_True": 41.95200000000003, "TestONNXRuntime_opset_version_20_is_script_True_keep_initializers_as_inputs_False": 37.84399999999996, "TestONNXRuntime_opset_version_20_is_script_True_keep_initializers_as_inputs_True": 38.05699999999996, "TestONNXRuntime_opset_version_7_is_script_False_keep_initializers_as_inputs_True": 15.621000000000038, "TestONNXRuntime_opset_version_7_is_script_True_keep_initializers_as_inputs_True": 19.38866666666675, "TestONNXRuntime_opset_version_8_is_script_False_keep_initializers_as_inputs_True": 15.493000000000059, "TestONNXRuntime_opset_version_8_is_script_True_keep_initializers_as_inputs_True": 20.681333333333377, "TestONNXRuntime_opset_version_9_is_script_False_keep_initializers_as_inputs_False": 26.9753333333333, "TestONNXRuntime_opset_version_9_is_script_False_keep_initializers_as_inputs_True": 28.15566666666665, "TestONNXRuntime_opset_version_9_is_script_True_keep_initializers_as_inputs_False": 27.7773333333332, "TestONNXRuntime_opset_version_9_is_script_True_keep_initializers_as_inputs_True": 28.46766666666657}, "onnx/test_pytorch_onnx_shape_inference": {"TestONNXCustomOpShapeInference": 0.2186666666666667, "TestONNXShapeInference": 0.06800000000000002}, "onnx/test_symbolic_helper": {"TestHelperFunctions": 0.08333333333333333}, "onnx/test_utility_funs": {"TestUnconvertibleOps": 0.08200000000000002, "TestUtilityFuns_opset_10": 0.991666666666667, "TestUtilityFuns_opset_11": 1.0090000000000003, "TestUtilityFuns_opset_12": 0.9816666666666669, "TestUtilityFuns_opset_13": 1.002666666666667, "TestUtilityFuns_opset_14": 0.9930000000000003, "TestUtilityFuns_opset_15": 1.1023333333333334, "TestUtilityFuns_opset_16": 1.092, "TestUtilityFuns_opset_17": 1.041666666666667, "TestUtilityFuns_opset_18": 1.0233333333333334, "TestUtilityFuns_opset_19": 1.0520000000000003, "TestUtilityFuns_opset_20": 1.0380000000000003, "TestUtilityFuns_opset_9": 2.426666666666664}, "onnx/test_verification": {"TestFindMismatch_ONNX_RUNTIME_CPU": 0.44, "TestVerification": 0.10233333333333335, "TestVerificationOnWrongExport": 0.020333333333333335}, "onnx/torch_export/test_torch_export_with_onnxruntime": {"TestFxToOnnxWithOnnxRuntime": 3.031333333333334}, "profiler/test_execution_trace": {"TestExecutionTrace": 1.1824935897435898}, "profiler/test_memory_profiler": {"TestDataFlow": 1.2675064102564104, "TestIdentifyGradients": 0.2859423076923077, "TestMemoryProfiler": 0.3483974358974359, "TestMemoryProfilerE2E": 3.662064102564103}, "profiler/test_profiler": {"TestExperimentalUtils": 8.846397435897437, "TestProfiler": 23.42391025641026, "TestProfilerCUDA": 1.8789102564102569, "TestProfilerITT": 0.10358333333333333}, "profiler/test_profiler_tree": {"TestProfilerTree": 4.040743589743591}, "profiler/test_record_function": {"TestRecordFunction": 0.5024807692307692}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.94950641025641}, "test_ao_sparsity": {"TestActivationSparsifier": 0.14795512820512824, "TestBaseDataScheduler": 0.11565384615384616, "TestBaseDataSparsifier": 0.43354487179487183, "TestBaseSparsifier": 0.08453205128205127, "TestBaseStructuredSparsifier": 7.37202564102564, "TestComposability": 2.676106666666667, "TestCubicScheduler": 0.05776923076923077, "TestFPGMPruner": 0.1597307692307692, "TestFakeSparsity": 0.5118397435897436, "TestFxComposability": 3.1111199999999997, "TestNearlyDiagonalSparsifier": 2.0287307692307697, "TestNormDataSparsifiers": 2.046903846153847, "TestQuantizationUtils": 0.08381410256410257, "TestQuantizedSparseKernels": 0.4138974358974359, "TestQuantizedSparseLayers": 0.3994871794871794, "TestSaliencyPruner": 0.0696025641025641, "TestScheduler": 0.09587820512820514, "TestSparsityUtilFunctions": 0.08076923076923077, "TestWeightNormSparsifier": 0.8411602564102567}, "test_autocast": {"TestAutocastCPU": 3.0438333333333327, "TestAutocastGPU": 0.6623653846153844, "TestTorchAutocast": 0.02081410256410256}, "test_autograd": {"TestAllowMutationOnSaved": 0.07706410256410257, "TestAutograd": 33.308692307692304, "TestAutogradComplex": 0.09021794871794866, "TestAutogradDeviceTypeCPU": 2.042051282051282, "TestAutogradDeviceTypeCUDA": 2.3451458333333326, "TestAutogradForwardMode": 0.35487820512820506, "TestAutogradForwardModeBatchedGrad": 0.07328205128205129, "TestAutogradFunctional": 17.098378205128206, "TestAutogradInferenceMode": 0.13105128205128208, "TestAutogradLogging": 0.03299358974358974, "TestAutogradMultipleDispatchCPU": 0.27447435897435896, "TestAutogradMultipleDispatchCUDA": 0.025895833333333333, "TestMultithreadAutograd": 0.4541217948717948, "TestNestedCheckpoint": 0.7310897435897435, "TestSelectiveActivationCheckpoint": 0.053044871794871794}, "test_autograd_fallback": {"TestAutogradFallback": 0.6000256410256412}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 253.965679487176, "TestBinaryUfuncsCUDA": 200.18117083333584}, "test_bundled_inputs": {"TestBundledInputs": 1.797480769230769}, "test_comparison_utils": {"TestComparisonUtils": 0.4069294871794872}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0008269230769230771}, "test_complex": {"TestComplexTensorCPU": 0.2678076923076923, "TestComplexTensorCUDA": 0.46375}, "test_content_store": {"TestContentStoreCPU": 6.715589743589744, "TestContentStoreCUDA": 1.2562291666666663}, "test_cpp_api_parity": {"TestCppApiParity": 21.871206666666634}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.2693525641025641, "TestMAIATensor": 0.058846153846153854, "TestPybindTypeCasters": 0.00875, "TestRNGExtension": 0.0043461538461538485, "TestTorchLibrary": 0.022576923076923074}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.26436538461538456, "TestMAIATensor": 0.059538461538461554, "TestPybindTypeCasters": 0.008762820512820515, "TestRNGExtension": 0.0043461538461538485, "TestTorchLibrary": 0.022692307692307692}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 112.31814102564104}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.5156410256410257}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 11.452352564102565}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.5182051282051282}, "test_cuda": {"TestBlockStateAbsorption": 6.519125000000001, "TestCuda": 97.3039791666667, "TestCudaMallocAsync": 21.914145833333336, "TestCudaOptimsCUDA": 3.4464791666666663}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 6.6678749999999996, "TestCuda": 111.31597916666666, "TestCudaMallocAsync": 26.84852083333334, "TestCudaOptimsCUDA": 3.656520833333333}, "test_cuda_multigpu": {"TestCudaComm": 0.14101851851851854, "TestCudaMultiGPU": 1.6779259259259254}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.24140476190476187, "TestVisibleDeviceParses": 0.037928571428571436}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.16933333333333334}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.6813958333333333, "TestEventHandler": 0.03556250000000001, "TestMessages": 0.0045625}, "test_cuda_trace": {"TestCudaTrace": 3.0655416666666664}, "test_custom_backend": {"TestCustomBackend": 0.12878787878787878}, "test_custom_ops": {"MiniOpTest": 1.8402115384615383, "MiniOpTestOther": 0.12164743589743592, "TestCustomOp": 8.420711538461537, "TestCustomOpAPI": 0.2820769230769231, "TestCustomOpTestingCPU": 1.923217948717949, "TestCustomOpTestingCUDA": 1.8805625, "TestCustomOperators": 0.37981060606060607, "TestGenerateOpcheckTests": 4.0625}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 27.481352564102558, "TestConcatDataset": 0.030403846153846153, "TestConvAfterFork": 0.12176282051282052, "TestCustomPinFn": 0.964198717948718, "TestDataLoader": 127.6361282051282, "TestDataLoaderDeviceTypeCPU": 1.3286153846153848, "TestDataLoaderDeviceTypeCUDA": 15.767458333333334, "TestDataLoaderPersistentWorkers": 147.12223076923075, "TestDatasetRandomSplit": 0.6199935897435898, "TestDictDataLoader": 0.9676602564102563, "TestIndividualWorkerQueue": 0.002506410256410257, "TestNamedTupleDataLoader": 0.022711538461538453, "TestSetAffinity": 0.0732948717948718, "TestStackDataset": 0.10536538461538465, "TestStringDataLoader": 0.380025641025641, "TestTensorDataset": 0.059269230769230755}, "test_datapipe": {"TestCaptureDataFrame": 0.00047435897435897434, "TestCircularSerialization": 0.012666666666666668, "TestDataChunk": 0.03685897435897436, "TestDataFramesPipes": 0.023179487179487177, "TestFunctionalIterDataPipe": 5.279589743589743, "TestFunctionalMapDataPipe": 0.19096153846153846, "TestGraph": 0.04857692307692308, "TestIterDataPipeCountSampleYielded": 0.016948717948717953, "TestIterDataPipeGraphFastForward": 0.2722948717948717, "TestIterDataPipeSingletonConstraint": 0.039621794871794874, "TestIterableDataPipeBasic": 0.11016666666666666, "TestSerialization": 6.375198717948718, "TestSharding": 2.472224358974359, "TestStreamWrapper": 0.38299358974358977, "TestTyping": 0.013621794871794877}, "test_decomp": {"DecompOneOffTestsCPU": 0.5738974358974359, "DecompOneOffTestsCUDA": 0.042395833333333334, "HasDecompTest": 0.2629935897435898, "TestDecompCPU": 2748.9174615384622, "TestDecompCUDA": 12961.338937500004}, "test_deploy": {"TestFreezer": 0.41510897435897437}, "test_dispatch": {"TestDispatch": 43.244301282051275, "TestPythonDispatcher": 0.04103205128205128}, "test_dlpack": {"TestTorchDlPackCPU": 2.046564102564102, "TestTorchDlPackCUDA": 0.7169999999999993}, "test_dynamic_shapes": {"TestDimConstraints": 2.3786987179487182, "TestFloorDiv": 0.08782692307692308, "TestGuardsExpressions": 0.04657692307692307, "TestPySymInt": 1.4129487179487172, "TestSymNumberMagicMethods": 1.8339999999999952}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 4.029192307692305, "TestExpandedWeightFunctionalCUDA": 6.108729166666665, "TestExpandedWeightHelperFunctionCPU": 0.2602307692307693, "TestExpandedWeightHelperFunctionCUDA": 2.283645833333334, "TestExpandedWeightModuleCPU": 11.268115384615385, "TestExpandedWeightModuleCUDA": 18.53375}, "test_fake_tensor": {"FakeTensorConstHandling": 0.09840384615384619, "FakeTensorConverterTest": 0.057820512820512815, "FakeTensorDispatchCache": 0.19591025641025642, "FakeTensorOpInfoTestCPU": 0.10125641025641026, "FakeTensorOpInfoTestCUDA": 0.2380416666666667, "FakeTensorOperatorInvariants": 0.595, "FakeTensorPropTest": 0.10595512820512823, "FakeTensorSerialization": 0.013333333333333338, "FakeTensorTest": 4.4316666666666675, "PropagateRealTensorsFakeTensorConstHandling": 0.11304487179487183, "PropagateRealTensorsFakeTensorConverterTest": 0.03370512820512821, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.08478205128205128, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.21164743589743593, "PropagateRealTensorsFakeTensorPropTest": 0.05746153846153846, "PropagateRealTensorsFakeTensorTest": 5.879929487179489}, "test_flop_counter": {"TestFlopCounter": 1.3397051282051278}, "test_foreach": {"TestForeachCPU": 57.43745238095236, "TestForeachCUDA": 280.7616111111187}, "test_function_schema": {"TestFunctionSchema": 0.8325448717948718}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 35.15772435897437}, "test_functional_optim": {"TestFunctionalOptimParity": 0.6265961538461539}, "test_functionalization": {"TestCrossRefFunctionalization": 2.628871794871794, "TestFunctionalization": 3.110628205128204}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.06656944444444443, "TestFunctionalizationRngOpsCUDA": 3.2513095238095238}, "test_futures": {"TestFuture": 1.3745961538461537}, "test_fx": {"AnnotationsTest": 0.021910256410256415, "TestCSEPass": 0.5294871794871796, "TestCommonPass": 0.17338461538461541, "TestConstFold": 0.3507307692307692, "TestConstParamShapeInControlFlow": 0.3555320512820512, "TestDCE": 0.06585256410256411, "TestFX": 19.600775641025628, "TestFXAPIBackwardCompatibility": 0.4093076923076922, "TestFunctionalTracing": 5.916794871794869, "TestMatcher": 0.4440384615384616, "TestOperatorSignaturesCPU": 5.568205128205107, "TestOperatorSignaturesCUDA": 1.6469999999999971, "TestPassManager": 0.08003846153846153, "TestSourceMatcher": 1.590673076923077, "TestSubgraphRewriter": 0.5236089743589744, "TestVisionTracing": 278.22183333333334, "TypeCheckerTest": 2.333576923076922}, "test_fx_experimental": {"TestFXExperimental": 62.57923717948716, "TestNormalizeOperatorsCPU": 40.00925641025641, "TestNormalizeOperatorsCUDA": 2.664354166666645, "TestTranslationValidation": 0.18485256410256407}, "test_fx_passes": {"TestFXGraphPasses": 1.5936538461538463, "TestFXMatcherUtils": 0.11939102564102565}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.7816538461538461}, "test_import_stats": {"TestImportTime": 4.591839743589744}, "test_indexing": {"NumpyTestsCPU": 0.38267948717948713, "NumpyTestsCUDA": 0.056687500000000016, "TestIndexingCPU": 21.237115384615386, "TestIndexingCUDA": 2.603937499999997}, "test_itt": {"TestItt": 0.38069230769230783}, "test_jit": {"TestAliasAnalysis": 0.43010256410256414, "TestAsync": 0.6561089743589743, "TestAtenPow": 0.4403205128205129, "TestAutodiffJit": 0.10421153846153845, "TestAutodiffSubgraphSlicing": 0.5659807692307693, "TestAwait": 0.4514358974358975, "TestBackends": 2.2123397435897436, "TestBackendsWithCompiler": 0.8584807692307692, "TestBatchMM": 0.21014102564102569, "TestBuiltins": 0.09467948717948718, "TestCUDA": 0.7970208333333335, "TestClassType": 2.5733269230769222, "TestComplex": 1.105519230769231, "TestCustomOperators": 0.11576282051282055, "TestDCE": 0.02564102564102564, "TestDataParallel": 0.007384615384615387, "TestDataclasses": 6.558583333333332, "TestDeviceAnalysis": 4.566243589743589, "TestDict": 0.46976923076923094, "TestDtypeAnalysis": 0.8299615384615386, "TestDtypeCustomRulesCPU": 4.249615384615381, "TestEnum": 0.25696153846153846, "TestFreezing": 2.1687051282051284, "TestFrontend": 0.37823076923076926, "TestFrozenOptimizations": 14.059147435897435, "TestFunctionalBlocks": 0.04486538461538462, "TestFunctionalToInplaceActivation": 3.1232500000000005, "TestGenerator": 0.13965384615384616, "TestGetDefaultAttr": 0.028839743589743592, "TestGraphRewritePasses": 0.0625576923076923, "TestHash": 0.13059615384615383, "TestHooks": 0.9998589743589748, "TestIgnorableArgs": 0.01803846153846154, "TestIgnoreContextManager": 0.0554679487179487, "TestInplaceToFunctionalActivation": 2.925448717948718, "TestIsinstance": 0.34977564102564107, "TestJit": 8.376999999999995, "TestJitGeneratedModule": 19.12368589743591, "TestJitProfiler": 0.08158333333333333, "TestJitUtils": 0.05330769230769232, "TestList": 2.152532051282051, "TestLogging": 0.08690384615384614, "TestMKLDNNReinplacing": 0.041692307692307695, "TestMisc": 0.41306410256410264, "TestMixTracingScripting": 1.394647435897436, "TestModels": 5.2074358974358965, "TestModuleAPIs": 0.17050641025641025, "TestModuleContainers": 1.6781730769230765, "TestModuleInterface": 0.6525192307692307, "TestModules": 0.020384615384615386, "TestNamedTuple": 0.09917948717948723, "TestNnapiBackend": 7.823999999999997, "TestOpDecompositions": 0.050916666666666645, "TestOptimizeForMobilePreserveDebugInfo": 0.25759615384615386, "TestPDT": 0.4158750000000001, "TestParametrization": 0.2293205128205128, "TestPeephole": 1.18023717948718, "TestProducerVersion": 0.003455128205128206, "TestProfiler": 0.48645512820512826, "TestPythonBindings": 0.14152564102564102, "TestPythonBuiltinOP": 0.8840833333333334, "TestPythonIr": 0.06578846153846153, "TestRecursiveScript": 0.9673205128205129, "TestRemoveMutation": 0.48339102564102554, "TestSaveLoad": 6.361038461538465, "TestSaveLoadFlatbuffer": 0.48883333333333334, "TestSaveLoadForOpVersion": 2.4924166666666667, "TestScript": 42.47388461538465, "TestScriptDict": 0.08099999999999999, "TestScriptList": 0.9351025641025641, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2279294871794872, "TestScriptProfile": 3.299455128205128, "TestSlice": 0.2347371794871795, "TestSparse": 0.07332692307692307, "TestStringFormatting": 0.17226923076923084, "TestSymbolicShapeAnalysis": 5.135282051282049, "TestTensorBuiltins": 0.14876923076923076, "TestTensorCreationOps": 0.0723653846153846, "TestTensorMethods": 0.02686538461538461, "TestTorchbind": 0.16408333333333341, "TestTracer": 4.531217948717945, "TestTypeSharing": 0.6141089743589745, "TestTypesAndAnnotation": 0.18709615384615394, "TestTyping": 0.6306858974358975, "TestUnion": 0.7489871794871796, "TestUnsupportedOps": 0.04547435897435896, "TestUpgraders": 0.25526282051282057, "TestWarn": 0.09319871794871792, "TestWith": 0.49617307692307694}, "test_jit_autocast": {"TestAutocast": 1.2206794871794868, "TestJitTraceAutocast": 23.514551282051283}, "test_jit_disabled": {"TestJitDisabled": 0.46371794871794864}, "test_jit_fuser_legacy": {"TestFuser": 0.007541666666666667}, "test_jit_fuser_te": {"TestFuserCommon": 0.25100641025641024, "TestLoopnestRandomizationCPU": 0.21907692307692306, "TestNNCOpInfoCPU": 45.08339743589811, "TestNNCOpInfoCUDA": 22.726937500000737, "TestTEFuserDynamic": 260.4484551282052, "TestTEFuserStatic": 212.201217948718}, "test_jit_legacy": {"TestAliasAnalysis": 0.4684166666666667, "TestAsync": 0.46754166666666674, "TestAtenPow": 0.011125, "TestAutodiffJit": 0.06729166666666667, "TestAutodiffSubgraphSlicing": 0.34554166666666675, "TestAwait": 0.28412500000000007, "TestBackends": 0.696125, "TestBackendsWithCompiler": 0.14129166666666668, "TestBatchMM": 0.11449999999999999, "TestBuiltins": 0.078375, "TestCUDA": 1.059, "TestClassType": 2.9215416666666663, "TestComplex": 1.0923333333333336, "TestCustomOperators": 0.05566666666666669, "TestDCE": 0.025833333333333333, "TestDataParallel": 0.005958333333333333, "TestDataclasses": 5.017041666666666, "TestDeviceAnalysis": 0.22020833333333334, "TestDict": 0.5461250000000002, "TestDtypeAnalysis": 0.21470833333333333, "TestDtypeCustomRulesCPU": 1.5823333333333318, "TestEnum": 0.255375, "TestFreezing": 2.923, "TestFrontend": 0.4814583333333333, "TestFrozenOptimizations": 12.095500000000001, "TestFunctionalBlocks": 0.008625, "TestFunctionalToInplaceActivation": 0.15291666666666665, "TestGenerator": 0.069875, "TestGetDefaultAttr": 0.02270833333333333, "TestGraphRewritePasses": 0.05741666666666667, "TestHash": 0.09520833333333334, "TestHooks": 0.887041666666667, "TestIgnorableArgs": 0.014958333333333334, "TestIgnoreContextManager": 0.040375, "TestInplaceToFunctionalActivation": 0.07270833333333335, "TestIsinstance": 0.2632916666666668, "TestJit": 7.8284166666666595, "TestJitGeneratedModule": 15.885500000000011, "TestJitProfiler": 0.001375, "TestJitUtils": 0.02429166666666667, "TestList": 1.6847500000000006, "TestLogging": 0.067875, "TestMKLDNNReinplacing": 0.09425000000000001, "TestMisc": 0.3290833333333334, "TestMixTracingScripting": 1.6538333333333333, "TestModels": 5.617666666666665, "TestModuleAPIs": 0.18216666666666664, "TestModuleContainers": 1.6491250000000002, "TestModuleInterface": 0.68075, "TestModules": 0.018333333333333333, "TestNamedTuple": 0.09462500000000001, "TestNnapiBackend": 6.1615416666666665, "TestOpDecompositions": 0.02420833333333333, "TestOptimizeForMobilePreserveDebugInfo": 0.23950000000000002, "TestParametrization": 0.12883333333333336, "TestPeephole": 0.5832500000000003, "TestProducerVersion": 0.0025, "TestProfiler": 0.5938333333333334, "TestPythonBindings": 0.03966666666666667, "TestPythonBuiltinOP": 0.46054166666666674, "TestPythonIr": 0.03066666666666667, "TestRecursiveScript": 0.9232916666666671, "TestRemoveMutation": 0.16287500000000002, "TestSaveLoad": 0.6608333333333334, "TestSaveLoadFlatbuffer": 0.5873333333333333, "TestSaveLoadForOpVersion": 2.992375, "TestScript": 54.26745833333337, "TestScriptDict": 0.036750000000000005, "TestScriptList": 1.0534166666666667, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.20933333333333337, "TestScriptProfile": 0.5248333333333334, "TestSlice": 0.19050000000000009, "TestSparse": 0.05345833333333334, "TestStringFormatting": 0.1487916666666667, "TestSymbolicShapeAnalysis": 1.6423749999999995, "TestTensorBuiltins": 0.11945833333333335, "TestTensorCreationOps": 0.0555, "TestTensorMethods": 0.014541666666666668, "TestTorchbind": 0.18566666666666673, "TestTracer": 14.447374999999997, "TestTypeSharing": 0.6346250000000001, "TestTypesAndAnnotation": 0.1530416666666667, "TestTyping": 0.46554166666666685, "TestUnion": 0.5378333333333336, "TestUnsupportedOps": 0.03895833333333333, "TestUpgraders": 0.09054166666666669, "TestWarn": 0.06616666666666668, "TestWith": 0.5274166666666666}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0008141025641025643, "TestEnableDisableLlgaFuser": 0.19399999999999998, "TestFusionPatternCPU": 8.319166666666666, "TestFusionPatternCUDA": 0.003791666666666667, "TestModel": 2.795788461538462, "TestOpCPU": 41.1878717948718, "TestOpCUDA": 0.004229166666666667}, "test_jiterator": {"TestPythonJiteratorCUDA": 27.43806249999995}, "test_legacy_vmap": {"TestVmapAPILegacy": 10.453339743589748, "TestVmapBatchedGradientLegacyCPU": 3.8686538461538458, "TestVmapBatchedGradientLegacyCUDA": 0.7789375000000001, "TestVmapOperatorsLegacy": 13.668814102564102}, "test_license": {"TestLicense": 0.25544871794871793}, "test_linalg": {"TestLinalgCPU": 490.6584615384611, "TestLinalgCUDA": 772.8019999999982}, "test_logging": {"LoggingTest": 3.223083333333334}, "test_masked": {"TestMaskedCPU": 23.573294871794864, "TestMaskedCUDA": 38.44185416666671}, "test_maskedtensor": {"TestBasicsCPU": 1.6336794871794873, "TestBasicsCUDA": 0.2533958333333333, "TestBinary": 1.233365384615385, "TestOperatorsCPU": 6.8608205128204895, "TestOperatorsCUDA": 9.727583333333282, "TestReductions": 0.6588782051282055, "TestUnary": 2.460307692307692}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.030083333333333344, "TestMatmulCudaCUDA": 74.63714583333334, "TestMixedDtypesLinearCudaCUDA": 0.20237499999999997}, "test_meta": {"TestMetaCPU": 835.3884358973792, "TestMetaCUDA": 2937.664958333214, "TestMetaConverter": 0.9099423076923077}, "test_metal": {"TestMetalRewritePass": 1.1053333333333333}, "test_mkl_verbose": {"TestMKLVerbose": 5.103474358974359}, "test_mkldnn": {"TestMkldnnCPU": 120.2768205128205}, "test_mkldnn_fusion": {"TestMkldnnFusion": 140.1191794871795}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.7358076923076915}, "test_mobile_optimizer": {"TestOptimizer": 3.414371794871795}, "test_model_dump": {"TestModelDump": 1.398858974358974}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.19525641025641025}, "test_module_tracker": {"TestModuleTracker": 0.4170192307692308}, "test_modules": {"TestModuleCPU": 537.5117023809464, "TestModuleCUDA": 1101.6364999999914, "TestModuleMPS": 333.360000000007}, "test_monitor": {"TestMonitor": 0.39538461538461533, "TestMonitorTensorboard": 0.27475641025641023}, "test_mps": {"MPSLeakyReluTest": 0.3606666666666667, "MPSReluTest": 0.22533333333333336, "MatmulTest": 0.2693333333333333, "TestAdvancedIndexing": 14.111333333333329, "TestAvgPool": 0.081, "TestCommonMPS": 16.227000000000004, "TestComplex": 3.1136666666666666, "TestConsistencyCPU": 1911.8689999999942, "TestConvolutionMPS": 7.674333333333333, "TestErrorInputsMPS": 15.494666666666653, "TestFallbackWarning": 5.93, "TestGatherScatter": 0.37800000000000006, "TestLinalgMPSMPS": 56.24433333333334, "TestLogical": 1.329, "TestMPS": 112.69933333333336, "TestMemoryLeak": 0.9123333333333333, "TestNLLLoss": 1.6603333333333337, "TestNNMPS": 9.259, "TestNoRegression": 0.15333333333333332, "TestPad": 1.3033333333333335, "TestPixelShuffle": 6.572666666666667, "TestRNNMPS": 5.153333333333333, "TestSmoothL1Loss": 0.20066666666666666, "TestTopK": 2.092, "TestViewOpsMPS": 2.316333333333334}, "test_multiprocessing": {"TestMultiprocessing": 167.23316025641026}, "test_multiprocessing_spawn": {"ErrorTest": 0.005448717948717949, "ForkTest": 0.58125, "SpawnTest": 33.39933333333334}, "test_namedtensor": {"TestNamedTensor": 1.5637051282051277}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.0914615384615383}, "test_native_functions": {"TestNativeFunctions": 0.6123076923076924}, "test_native_mha": {"TestMHADeviceTypeCPU": 4.978628205128205, "TestMHADeviceTypeCUDA": 2.7591874999999986}, "test_nestedtensor": {"TestNestedTensor": 0.5675128205128204, "TestNestedTensorAutogradCPU": 2.085384615384615, "TestNestedTensorAutogradCUDA": 1.4387291666666666, "TestNestedTensorDeviceTypeCPU": 3.4115769230769226, "TestNestedTensorDeviceTypeCUDA": 3.7943958333333283, "TestNestedTensorSubclassCPU": 24.28585897435898, "TestNestedTensorSubclassCUDA": 3.6536041666666645}, "test_nn": {"TestAddRelu": 0.016448717948717953, "TestConstantPadNd": 0.014641025641025644, "TestFunctionalPickle": 0.0033012820512820524, "TestFusionEval": 0.46156666666666674, "TestFusionUtils": 0.04449999999999999, "TestNN": 72.70574358974363, "TestNNDeviceTypeCPU": 226.820807692308, "TestNNDeviceTypeCUDA": 176.21430416666763, "TestUtils": 0.006284615384615387}, "test_numba_integration": {"TestNumbaIntegration": 0.18616666666666662}, "test_numpy_interop": {"TestNumPyInteropCPU": 2.036320512820513, "TestNumPyInteropCUDA": 0.5064374999999999}, "test_openmp": {"TestOpenMP_ParallelFor": 5.860102564102563}, "test_ops": {"TestCommonCPU": 1147.5358076922864, "TestCommonCUDA": 3424.471499999921, "TestCompositeComplianceCPU": 655.4152692307664, "TestCompositeComplianceCUDA": 1068.9762575757538, "TestFakeTensorCPU": 234.611025641026, "TestFakeTensorCUDA": 997.561318181816, "TestMathBitsCPU": 40.687730769230726, "TestMathBitsCUDA": 118.6535909090911, "TestRefsOpsInfoCPU": 1.4445256410256362, "TestSelfKwarg": 0.21464367816091962, "TestTagsCPU": 10.287525641025619, "TestTagsCUDA": 3.4036969696969663}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 633.6967692307667, "TestFwdGradientsCUDA": 1375.3197083333275}, "test_ops_gradients": {"TestBwdGradientsCPU": 1033.9168333333214, "TestBwdGradientsCUDA": 2035.2001818181423}, "test_ops_jit": {"TestJitCPU": 1116.4790641025631, "TestJitCUDA": 1399.724458333332}, "test_optim": {"TestDifferentiableOptimizer": 0.22718589743589745, "TestLRScheduler": 2.6555256410256396, "TestOptimRenewedCPU": 109.52352380952384, "TestOptimRenewedCUDA": 303.9069259259256, "TestOptimRenewedMPS": 125.76733333333372, "TestSWAUtils": 9.342749999999999}, "test_out_dtype_op": {"TestOutDtypeOp": 0.5888525641025641}, "test_overrides": {"TestBroadcastAllOverride": 0.04425641025641022, "TestDisabledTorchFunction": 0.003371794871794873, "TestDisabledUserWarnings": 0.003935897435897437, "TestEinsumOverride": 0.07471153846153845, "TestGradCheckOverride": 0.07259615384615384, "TestGradNewOnesOverride": 0.003038461538461539, "TestIndexing": 0.017532051282051285, "TestIterator": 0.002762820512820514, "TestNamedTuple": 0.0035576923076923095, "TestPickle": 0.003525641025641027, "TestRNN": 0.013782051282051285, "TestResolveName": 0.13092307692307698, "TestTorchFunctionMode": 0.07944230769230773, "TestTorchFunctionOverride": 31.28370512820518, "TestTorchFunctionWarning": 0.015467948717948725, "TestWrapTorchFunction": 0.002653846153846154}, "test_package": {"DirectoryReaderTest": 0.887775641025641, "ModelTest": 0.00428846153846154, "TestAnalyze": 0.4385833333333334, "TestDependencyAPI": 2.0704102564102564, "TestDependencyHooks": 0.5954294871794874, "TestDiGraph": 1.4134294871794875, "TestGlobGroup": 1.686717948717949, "TestImporter": 0.7056474358974358, "TestLoadBCPackages": 0.4385256410256409, "TestMangling": 1.2060833333333334, "TestMisc": 1.3646217948717951, "TestPackageFX": 0.8517756410256413, "TestPackageScript": 5.178365384615385, "TestRepackage": 0.18120512820512824, "TestResources": 0.4748653846153846, "TestSaveLoad": 1.3369358974358976}, "test_per_overload_api": {"TestPerOverloadAPI": 0.4735769230769231}, "test_prims": {"TestDecompCPU": 0.08434615384615385, "TestDecompCUDA": 0.1594166666666667, "TestPrimsBasic": 0.1435705128205128, "TestPrimsCPU": 0.19876923076923078, "TestPrimsCUDA": 0.43243750000000014, "TestRefsCPU": 0.06212820512820515, "TestRefsCUDA": 0.013687500000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.1666410256410257, "TestGenericProxyTensorFake": 4.076660256410256, "TestGenericProxyTensorReal": 4.8338205128205125, "TestGenericProxyTensorSymbolic": 19.378108974358977, "TestProxyTensorOpInfoCPU": 543.4717435897418, "TestRealProxyTensor": 0.020294871794871796, "TestSymbolicTracing": 4.632173076923077}, "test_pruning_op": {"PruningOpTest": 0.6129038461538463}, "test_public_bindings": {"TestPublicBindings": 5.343858974358975}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.12987820512820514, "TestPythonDispatch": 1.7700256410256405, "TestPythonDispatcher": 0.019923076923076925, "TestPythonRegistration": 0.9335576923076923, "TestWrapperSubclassAliasingCPU": 0.22688461538461538, "TestWrapperSubclassAliasingCUDA": 0.19179166666666672}, "test_pytree": {"TestCxxPytree": 0.1676666666666666, "TestGenericPytree": 0.9103012820512818, "TestPythonPytree": 0.45668589743589744}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.029435897435897432, "TestAOMigrationNNQuantized": 0.0688717948717949, "TestAOMigrationQuantization": 0.037403846153846156, "TestAOMigrationQuantizationFx": 0.048038461538461544, "TestBackendConfig": 0.42121794871794893, "TestBiasCorrectionEager": 3.917660256410257, "TestBitsCPU": 0.16355128205128205, "TestBitsCUDA": 0.02672916666666667, "TestComparatorOps": 4.564461538461538, "TestDeprecatedJitQuantized": 4.318608974358975, "TestDistributed": 0.12370512820512822, "TestDuplicateDQPass": 4.0531538461538466, "TestDynamicQuantizedModule": 50.16755769230769, "TestDynamicQuantizedOps": 43.549878205128195, "TestEqualizeEager": 0.6706474358974359, "TestEqualizeFx": 10.365929487179487, "TestFXGraphMatcher": 2.3235576923076926, "TestFXGraphMatcherModels": 9.173262820512821, "TestFXNumericSuiteCoreAPIs": 36.96852564102565, "TestFXNumericSuiteCoreAPIsModels": 42.7694935897436, "TestFXNumericSuiteNShadows": 43.661948717948725, "TestFakeQuantize": 0.861884615384615, "TestFakeQuantizeOps": 12.76790384615385, "TestFloat8DtypeCPU": 0.9701923076923076, "TestFloat8DtypeCPUOnlyCPU": 0.4528974358974359, "TestFloat8DtypeCUDA": 0.462625, "TestFuseEager": 5.466237179487179, "TestFuseFx": 3.141532051282051, "TestFusedObsFakeQuant": 0.4162884615384615, "TestFusedObsFakeQuantModule": 0.4967435897435898, "TestFusionPasses": 0.0381923076923077, "TestFxDetectInputWeightEqualization": 0.4693910256410256, "TestFxDetectOutliers": 0.9314358974358973, "TestFxModelReportClass": 1.6028525641025637, "TestFxModelReportDetectDynamicStatic": 0.17096153846153844, "TestFxModelReportDetector": 0.6216730769230769, "TestFxModelReportObserver": 0.7203846153846153, "TestFxModelReportVisualizer": 1.0404358974358976, "TestGenerateNumericDebugHandle": 0.8155128205128205, "TestGraphUtils": 1.6590192307692309, "TestHistogramObserver": 48.39874358974359, "TestMetaDataPorting": 8.145641025641025, "TestModelNumericsEager": 1.502615384615385, "TestNumericSuiteEager": 15.572884615384607, "TestObserver": 4.935544871794871, "TestPT2ERepresentation": 25.51767307692307, "TestPadding": 22.97251282051282, "TestQNNPackOps": 5.8486730769230775, "TestQuantizationDocs": 0.0739102564102564, "TestQuantizeDynamicJitOps": 2.424301282051282, "TestQuantizeDynamicJitPasses": 5.695589743589745, "TestQuantizeEagerOps": 3.0591923076923075, "TestQuantizeEagerPTQDynamic": 13.55003846153846, "TestQuantizeEagerPTQStatic": 33.43750641025641, "TestQuantizeEagerQAT": 16.08891025641025, "TestQuantizeEagerQATNumerics": 10.691583333333332, "TestQuantizeFx": 53.98128846153847, "TestQuantizeFxModels": 12.898724358974356, "TestQuantizeFxOps": 153.19900641025643, "TestQuantizeJit": 24.087512820512814, "TestQuantizeJitOps": 274.9690192307693, "TestQuantizeJitPasses": 8.324833333333332, "TestQuantizePT2E": 60.063980769230774, "TestQuantizePT2EQATModels": 27.959756410256418, "TestQuantizePT2EQAT_ConvBn1d": 406.30759615384613, "TestQuantizePT2EQAT_ConvBn2d": 407.5808269230768, "TestQuantizePT2EX86Inductor": 130.04583333333332, "TestQuantizedConv": 94.2141858974359, "TestQuantizedEmbeddingOps": 2.716288461538461, "TestQuantizedFunctionalOps": 3.269532051282051, "TestQuantizedLinear": 42.12711538461539, "TestQuantizedOps": 226.95828205128203, "TestQuantizedTensor": 9.884942307692306, "TestRecordHistogramObserver": 0.05405128205128206, "TestReferenceQuantizedModule": 0.30901923076923077, "TestSerialization": 2.793596153846153, "TestStaticQuantizedModule": 124.73021153846155, "TestSubgraphRewriter": 1.279096153846154, "TestUtils": 0.16751282051282054, "TestXNNPACKQuantizer": 44.28794871794871, "TestXNNPACKQuantizerModels": 5.473762820512819}, "test_reductions": {"TestReductionsCPU": 261.52935897435947, "TestReductionsCUDA": 153.03014583333027}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 35.396243589743584, "TestScatterGatherCUDA": 24.87304166666667}, "test_schema_check": {"TestSchemaCheck": 0.3792243589743591, "TestSchemaCheckModeOpInfoCPU": 169.68274358974213, "TestSchemaCheckModeOpInfoCUDA": 403.98760416665823}, "test_segment_reductions": {"TestSegmentReductionsCPU": 6.979038461538462, "TestSegmentReductionsCUDA": 4.134166666666665}, "test_serialization": {"TestBothSerializationCPU": 0.2645897435897436, "TestBothSerializationCUDA": 0.11295833333333334, "TestOldSerialization": 39.80691025641026, "TestSerialization": 12.969032051282054, "TestSubclassSerialization": 0.0805641025641026}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.38826282051282046}, "test_shape_ops": {"TestShapeOpsCPU": 4.443935897435898, "TestShapeOpsCUDA": 5.496812499999999}, "test_show_pickle": {"TestShowPickle": 0.2682692307692308}, "test_sort_and_select": {"TestSortAndSelectCPU": 11.079294871794868, "TestSortAndSelectCUDA": 6.263291666666661}, "test_sparse": {"TestSparseAnyCPU": 568.2044230769227, "TestSparseAnyCUDA": 746.7267916666656, "TestSparseCPU": 206.45042307692313, "TestSparseCUDA": 53.12137500000001, "TestSparseLegacyAndDeprecation": 0.16724999999999998, "TestSparseMaskedReductionsCPU": 1.193923076923077, "TestSparseMaskedReductionsCUDA": 3.1379791666666668, "TestSparseMeta": 9.664602564102562, "TestSparseOneOff": 0.1347051282051282, "TestSparseUnaryUfuncsCPU": 9.907141025641002, "TestSparseUnaryUfuncsCUDA": 13.314041666666638}, "test_sparse_csr": {"TestSparseCSRCPU": 112.04483333333302, "TestSparseCSRCUDA": 238.22631249999998, "TestSparseCSRSampler": 0.7851217948717947, "TestSparseCompressedCPU": 115.01297435897429, "TestSparseCompressedCUDA": 164.80074999999988, "TestSparseCompressedTritonKernelsCPU": 0.02242307692307692, "TestSparseCompressedTritonKernelsCUDA": 342.74974999999984}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.7823525641025644, "TestSparseSemiStructuredCUDA": 0.6452083333333316, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.07137500000000004, "TestSparseSemiStructuredCUTLASSCUDA": 3.375958333333334, "TestSparseSemiStructuredTrainingCUDA": 1.2917916666666662}, "test_spectral_ops": {"TestFFTCPU": 14.134358974358983, "TestFFTCUDA": 52.610583333333345, "TestFFTDocExamplesCPU": 0.1742051282051283}, "test_stateless": {"TestPythonOptimizeMode": 4.696852564102564, "TestStatelessDeprecation": 2.11524358974359, "TestStatelessFunctionalAPI": 1.4751217948717954}, "test_subclass": {"TestSubclass": 0.9680384615384612}, "test_sympy_utils": {"TestNumbers": 0.10074509803921569, "TestSingletonInt": 0.009256410256410257, "TestSympyInterp": 13.101339743589742, "TestSympySolve": 0.3831794871794872, "TestValueRanges": 7.27003846153846}, "test_tensor_creation_ops": {"TestAsArrayCPU": 18.77669230769232, "TestAsArrayCUDA": 0.7220208333333339, "TestBufferProtocolCPU": 9.136038461538464, "TestLikeTensorCreationCPU": 0.06844871794871796, "TestLikeTensorCreationCUDA": 0.012375, "TestRandomTensorCreationCPU": 7.001294871794872, "TestRandomTensorCreationCUDA": 0.3348333333333334, "TestTensorCreationCPU": 31.405474358974395, "TestTensorCreationCUDA": 111.61235416666648}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0846474358974359, "TestTensorBoardFigure": 0.15151923076923077, "TestTensorBoardNumpy": 0.011333333333333336, "TestTensorBoardPyTorchNumpy": 0.3754551282051282, "TestTensorBoardPytorchGraph": 35.49280769230769, "TestTensorBoardSummary": 0.2543525641025641, "TestTensorBoardSummaryWriter": 0.01502564102564103, "TestTensorBoardUtils": 0.23101282051282052, "TestTensorBoardWriter": 0.2031474358974359, "TestTensorProtoSummary": 0.045551282051282053}, "test_tensorexpr": {"TestTensorExprFuser": 76.75428205128205}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.022262820512820518, "TestTensorExprPyBind": 1.215974358974359}, "test_testing": {"TestAssertClose": 0.3842884615384615, "TestAssertCloseContainer": 0.030166666666666668, "TestAssertCloseErrorMessage": 0.12967307692307695, "TestAssertCloseMultiDeviceCUDA": 0.012458333333333332, "TestAssertCloseQuantized": 0.06117307692307691, "TestAssertCloseSparseBSC": 0.03303846153846154, "TestAssertCloseSparseBSR": 0.03589102564102564, "TestAssertCloseSparseCOO": 0.12723717948717947, "TestAssertCloseSparseCSC": 0.03430769230769231, "TestAssertCloseSparseCSR": 0.03768589743589744, "TestFrameworkUtils": 12.910615384615385, "TestImports": 13.877826923076922, "TestMakeTensorCPU": 13.44353846153846, "TestMakeTensorCUDA": 1.9560416666666587, "TestOpInfoSampleFunctionsCPU": 7.452499999999973, "TestOpInfoSampleFunctionsCUDA": 6.468479166666624, "TestOpInfos": 0.007512820512820513, "TestTestParametrization": 0.05623717948717951, "TestTestParametrizationDeviceTypeCPU": 3.755410256410255, "TestTestParametrizationDeviceTypeCUDA": 4.648312499999998, "TestTestingCPU": 0.5317435897435898, "TestTestingCUDA": 1.4373958333333328}, "test_torch": {"TestBasicVitalSigns": 0.14216666666666666, "TestDevicePrecisionCUDA": 11.653969696969698, "TestTorch": 35.33926436781604, "TestTorchDeviceTypeCPU": 53.14993589743586, "TestTorchDeviceTypeCUDA": 732.9738636363635, "TestVitalSignsCudaCPU": 0.0032179487179487174, "TestVitalSignsCudaCUDA": 0.12240909090909087}, "test_transformers": {"TestAttnBiasCPU": 22.970371794871788, "TestAttnBiasCUDA": 1.8644166666666664, "TestSDPACPU": 418.806602564102, "TestSDPACUDA": 2.817999999999924, "TestSDPACudaOnlyCUDA": 575.2489791665079, "TestSDPAFailureModesCPU": 0.12866666666666665, "TestSDPAFailureModesCUDA": 0.11637500000000005, "TestTransformersCPU": 37.075333333333326, "TestTransformersCUDA": 8.040291666666665}, "test_type_hints": {"TestTypeHints": 0.2563461538461539}, "test_type_info": {"TestDTypeInfo": 0.4482884615384616}, "test_type_promotion": {"TestTypePromotionCPU": 16.29758974358975, "TestTypePromotionCUDA": 11.273270833333331}, "test_typing": {"TestTyping": 72.59346153846153}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 406.7321153845209, "TestUnaryUfuncsCUDA": 687.1901249999365}, "test_utils": {"TestAssert": 0.0851730769230769, "TestBottleneck": 13.588839743589745, "TestCheckpoint": 0.4844038461538461, "TestCollectEnv": 1.6165064102564104, "TestCppExtensionUtils": 0.07824358974358973, "TestDataLoaderUtils": 4.774749999999999, "TestDeviceUtilsCPU": 35.50746153846222, "TestDeviceUtilsCUDA": 20.843291666667064, "TestExtensionUtils": 0.015282051282051286, "TestHipify": 0.0022756410256410263, "TestHipifyTrie": 0.019000000000000003, "TestONNXUtils": 0.006307692307692311, "TestRenderUtils": 0.023262820512820512, "TestStandaloneCPPJIT": 5.0229871794871785, "TestTraceback": 0.015378205128205135}, "test_view_ops": {"TestOldViewOpsCPU": 18.126333333333335, "TestOldViewOpsCUDA": 20.926833333333327, "TestViewOpsCPU": 5.329038461538463, "TestViewOpsCUDA": 1.7588958333333307, "TestViewOpsLAZY": 1.9923333333333313}, "test_vulkan": {"TestVulkanRewritePass": 0.0012115384615384618}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.03420512820512821, "WeakKeyDictionaryTestCase": 0.0523525641025641, "WeakTest": 5.0060641025641015}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 39.31710256410258, "TestXNNPACKOps": 5.335673076923077, "TestXNNPACKRewritePass": 1.9868333333333332, "TestXNNPACKSerDes": 5.597711538461537}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.08976923076923082}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.47307051282051266, "TestClassGetItem": 0.006878205128205129, "TestDtypeAttributeDeletion": 0.00030128205128205124, "TestFromDTypeAttribute": 0.004589743589743591, "TestMisc": 0.0077371794871794915, "TestPickling": 0.1580576923076923, "TestPromotion": 0.0035512820512820517}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 18.434461538461537, "TestEinsumPath": 0.001544871794871795, "TestMisc": 0.017538461538461544}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.00025641025641025646, "TestFinfo": 0.029333333333333326, "TestHalf": 0.0007371794871794874, "TestIinfo": 0.3825, "TestMisc": 0.007166666666666669, "TestPythonFloat": 0.0009679487179487182, "TestRepr": 0.005641025641025642, "TestSingle": 0.00034615384615384613}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.009115384615384619, "TestBooleanIndexing": 0.020455128205128206, "TestBroadcastedAssignments": 0.04737820512820513, "TestFancyIndexingCast": 0.019108974358974365, "TestFloatNonIntegerArgument": 0.024217948717948724, "TestIndexing": 0.7753846153846153, "TestMultiIndexingAutomated": 0.02516666666666667, "TestMultipleEllipsisError": 0.006121794871794873, "TestNonIntegerArrayLike": 0.001570512820512821}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.042416666666666665, "TestArgmax": 1.427534722222223, "TestArgmaxArgminCommon": 1.1028472222222228, "TestArgmin": 1.4962083333333334, "TestArrayAttributeDeletion": 0.016833333333333336, "TestArrayConstruction": 0.09568750000000002, "TestArrayCreationCopyArgument": 0.05330555555555556, "TestAssignment": 0.02280555555555556, "TestAttributes": 0.05389583333333334, "TestBinop": 0.03805555555555556, "TestBool": 26.48719444444445, "TestCequenceMethods": 0.003652777777777779, "TestChoose": 0.04639583333333333, "TestClip": 0.016451388888888894, "TestCompress": 0.01466666666666667, "TestConversion": 0.04675694444444445, "TestCreation": 0.004125000000000002, "TestDelMisc": 0.0028819444444444452, "TestDot": 0.14274305555555564, "TestDtypedescr": 0.0029236111111111116, "TestFancyIndexing": 0.06344444444444446, "TestFlag": 0.054868055555555593, "TestFormat": 0.013263888888888893, "TestFromBuffer": 0.027722222222222218, "TestHash": 0.3386736111111111, "TestHashing": 0.007798611111111114, "TestIO": 0.005305555555555557, "TestInner": 0.24685416666666668, "TestLexsort": 0.07081250000000001, "TestMatmul": 0.6709791666666668, "TestMatmulOperator": 0.36223611111111115, "TestMethods": 2.2918333333333334, "TestMinMax": 0.008361111111111114, "TestMinScalarType": 0.013722222222222224, "TestNewaxis": 0.006916666666666669, "TestPEP3118Dtype": 0.0027291666666666666, "TestPutmask": 0.05940277777777778, "TestRepeat": 0.03197222222222221, "TestResize": 0.07488194444444447, "TestRichcompareScalar": 0.0014375000000000004, "TestScalarIndexing": 0.04921527777777779, "TestSortFloatMisc": 0.5916180555555556, "TestStats": 0.4158402777777778, "TestSubscripting": 0.005305555555555556, "TestTake": 0.07941666666666669, "TestVdot": 0.05380555555555558, "TestWarnings": 0.0055694444444444454, "TestWhere": 0.6021944444444446, "TestWritebackIfCopy": 0.05462500000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.07846153846153844, "TestArgwhere": 0.10688461538461538, "TestArrayComparisons": 0.25274999999999986, "TestBaseRepr": 0.027653846153846157, "TestBinaryRepr": 0.03858974358974359, "TestBoolArray": 2.7825320512820513, "TestBoolCmp": 0.5359871794871798, "TestBoolScalar": 0.09924999999999999, "TestBroadcast": 0.07098076923076922, "TestClip": 0.5093461538461539, "TestConvolve": 0.04743589743589745, "TestCorrelate": 0.10343589743589744, "TestCreationFuncs": 1.3102371794871794, "TestCross": 0.15101282051282047, "TestDtypePositional": 0.004083333333333335, "TestFloatExceptions": 0.0488653846153846, "TestFromiter": 0.0011666666666666668, "TestIndex": 0.026846153846153846, "TestIndices": 0.08721153846153847, "TestIsclose": 0.23226923076923076, "TestIsscalar": 0.012608974358974363, "TestLikeFuncs": 0.0014230769230769232, "TestMoveaxis": 0.01802564102564103, "TestNonarrayArgs": 0.2494679487179488, "TestNonzeroAndCountNonzero": 0.4207948717948718, "TestOuterMisc": 0.01593589743589744, "TestRequire": 0.012891025641025646, "TestResize": 0.44903846153846155, "TestRoll": 0.1264423076923077, "TestRollaxis": 0.011891025641025642, "TestSeterr": 0.03372435897435898, "TestStdVar": 0.6344487179487179, "TestStdVarComplex": 0.02169871794871795, "TestStringFunction": 0.022025641025641016, "TestTensordot": 0.026480769230769235, "TestTypes": 0.07489102564102565}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.008685897435897438, "TestCommonType": 0.4081602564102565, "TestDocStrings": 0.00028846153846153843, "TestIsSubDType": 0.019762820512820516, "TestScalarTypeNames": 0.05845512820512822}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.2425256410256411, "TestFromInt": 0.013897435897435901, "TestFromString": 0.4240641025641026}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0027692307692307695, "TestBitCount": 0.0011153846153846155, "TestClassGetItem": 0.0026666666666666666, "TestClassGetitemMisc": 0.11912820512820516, "TestIsInteger": 0.0028910256410256416}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0009935897435897436}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.27853846153846157, "TestBaseMath": 9.451237179487181, "TestBitShifts": 0.15335897435897436, "TestComplexDivision": 0.06634615384615385, "TestConversion": 0.07316666666666667, "TestHash": 0.0014615384615384618, "TestModulus": 1.083730769230769, "TestMultiply": 0.0003974358974358975, "TestNegative": 0.023724358974358976, "TestPower": 0.1438141025641026, "TestRepr": 0.0048974358974358985, "TestScalarOpsMisc": 0.25454487179487173, "TestScalarSubclassingMisc": 0.11014743589743599, "TestSubtract": 0.02328846153846154, "TestTypes": 15.194461538461537}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.4347564102564102, "TestAtleast2d": 0.032935897435897435, "TestAtleast3d": 0.030493589743589747, "TestBlock": 0.05755128205128208, "TestConcatenate": 0.4417179487179489, "TestHstack": 0.04746794871794872, "TestStackMisc": 0.12594871794871795, "TestVstack": 0.04735256410256412}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.011666666666666667, "TestFFTShift": 6.430557692307692, "TestIRFFTN": 0.010166666666666668, "TestRFFTFreq": 0.011410256410256411}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 10.931570512820514, "TestFFTShift": 0.3907371794871795, "TestFFTThreadSafe": 2.175217948717948}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.4738205128205128}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.006660256410256414, "TestUnique": 0.9456089743589744}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.011115384615384619, "TestAmax": 0.013160256410256413, "TestAmin": 0.013128205128205133, "TestAngle": 0.02738461538461539, "TestAny": 0.0231474358974359, "TestAverage": 0.07933333333333334, "TestBincount": 0.10576923076923075, "TestCheckFinite": 0.011461538461538464, "TestCopy": 0.016237179487179492, "TestCorrCoef": 0.09518589743589745, "TestCov": 0.1548141025641026, "TestCumprod": 0.03460897435897436, "TestCumsum": 0.04665384615384616, "TestDelete": 0.17917307692307688, "TestDiff": 0.20348076923076922, "TestDigitize": 0.09662820512820511, "TestExtins": 0.0390576923076923, "TestFilterwindows": 1.0064615384615387, "TestFlip": 0.05961538461538462, "TestGradient": 0.32351923076923084, "TestInsert": 0.2786602564102564, "TestInterp": 1.4088269230769233, "TestKaiser": 0.02358974358974359, "TestMedian": 0.577852564102564, "TestMeshgrid": 0.1341474358974359, "TestMsort": 0.00032692307692307697, "TestPercentile": 0.6251346153846153, "TestPiecewise": 0.02342948717948718, "TestProd": 0.033532051282051285, "TestPtp": 0.022205128205128207, "TestQuantile": 0.1226346153846154, "TestRot90": 0.4582307692307693, "TestSelect": 0.018467948717948723, "TestSinc": 0.01856410256410257, "TestSortComplex": 0.0444551282051282, "TestTrapz": 0.0923076923076923, "TestTrimZeros": 0.032865384615384616, "TestUnique": 0.018089743589743593, "Test_I0": 0.03597435897435897}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.8161217948717947, "TestHistogramOptimBinNums": 0.18610256410256418, "TestHistogramdd": 0.44918589743589743}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.005064102564102565, "TestConcatenator": 0.015596153846153852, "TestDiagIndices": 0.011301282051282056, "TestDiagIndicesFrom": 0.016012820512820516, "TestFillDiagonal": 0.049519230769230774, "TestGrid": 0.02314102564102564, "TestIndexExpression": 0.029615384615384602, "TestIx_": 0.01796153846153847, "TestNdIndex": 0.002525641025641026, "TestNdenumerate": 0.0027628205128205127, "TestRavelUnravelIndex": 0.5076089743589745}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.08300641025641024, "TestApplyOverAxes": 0.0031538461538461546, "TestArraySplit": 0.3094294871794873, "TestColumnStack": 0.02050641025641026, "TestDsplit": 0.022000000000000002, "TestDstack": 0.0346794871794872, "TestExpandDims": 0.014993589743589747, "TestHsplit": 0.02418589743589744, "TestKron": 0.05421794871794872, "TestMayShareMemory": 0.015480769230769234, "TestPutAlongAxis": 0.0221025641025641, "TestSplit": 0.012391025641025642, "TestSqueeze": 0.08592948717948717, "TestTakeAlongAxis": 0.4589166666666666, "TestTile": 0.12153846153846158, "TestVsplit": 0.018141025641025647}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.09779487179487181, "TestEye": 0.4959423076923076, "TestFliplr": 0.007455128205128208, "TestFlipud": 0.010743589743589745, "TestHistogram2d": 0.1044166666666667, "TestTri": 0.15469871794871798, "TestTrilIndicesFrom": 0.004179487179487181, "TestTriuIndices": 0.012294871794871801, "TestTriuIndicesFrom": 0.0039038461538461544, "TestVander": 0.03491025641025641}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0028525641025641028, "TestCommonType": 0.43669871794871795, "TestImag": 0.03206410256410257, "TestIscomplex": 0.011756410256410258, "TestIscomplexobj": 0.02005769230769231, "TestIsfinite": 0.05158974358974356, "TestIsinf": 0.044942307692307705, "TestIsnan": 0.0495705128205128, "TestIsneginf": 0.010070512820512821, "TestIsposinf": 0.010756410256410259, "TestIsreal": 0.017121794871794875, "TestIsrealobj": 0.007602564102564103, "TestIsscalar": 0.014160256410256412, "TestMintypecode": 0.010589743589743591, "TestNanToNum": 0.0642371794871795, "TestReal": 0.0338076923076923, "TestRealIfClose": 0.029115384615384605}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.4054358974358975, "TestCond": 0.4911474358974359, "TestDet": 0.19766666666666668, "TestEig": 0.09018589743589746, "TestEigh": 0.05885897435897436, "TestEighCases": 5.769230769230769e-05, "TestEigvals": 0.12265384615384617, "TestEigvalsh": 0.057294871794871804, "TestEigvalshCases": 0.00010256410256410256, "TestInv": 0.10716025641025641, "TestLstsq": 0.6243269230769231, "TestMatrixRank": 0.45153846153846167, "TestMisc": 0.051871794871794864, "TestMisc2": 0.009019230769230772, "TestMultiDot": 0.12166025641025643, "TestNormDouble": 1.0268333333333333, "TestNormInt64": 1.0346410256410254, "TestNormSingle": 1.0585128205128203, "TestNorm_NonSystematic": 0.006891025641025643, "TestPinv": 0.25864102564102565, "TestPinvHermitian": 0.0726025641025641, "TestQR": 2.287423076923077, "TestSVD": 0.11757692307692309, "TestSVDHermitian": 0.15473076923076926, "TestSolve": 0.458801282051282, "TestTensorinv": 0.044455128205128196, "TestTensorsolve": 0.02267948717948717}, "torch_np/test_basic": {"TestArrayToSequence": 0.02241025641025642, "TestCopyTo": 0.024256410256410253, "TestCtorNested": 0.007525641025641027, "TestDefaultDtype": 0.01386538461538462, "TestDivmod": 0.04105128205128205, "TestExport": 0.03594230769230768, "TestMisc": 0.6466217948717948, "TestNormalizations": 0.016551282051282055, "TestOneArr": 1.011442307692307, "TestOneArrAndAxesTuple": 0.04075641025641024, "TestOneArrAndAxis": 0.5249935897435895, "TestOneArrAndShape": 0.06297435897435896, "TestOneArrToScalar": 0.04637820512820513, "TestPythonArgsToArray": 0.04062179487179486, "TestSequenceOfArrays": 0.07046794871794876, "TestSequenceOfArraysToSingle": 0.03638461538461538, "TestShapeLikeToArray": 0.014717948717948721, "TestSmokeNotImpl": 0.00351923076923077}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.6515769230769227}, "torch_np/test_dtype": {"TestConvertDType": 0.5296089743589744}, "torch_np/test_function_base": {"TestAppend": 0.40403205128205133}, "torch_np/test_ndarray_methods": {"TestAmax": 0.01734615384615385, "TestAmin": 0.022179487179487183, "TestArgmax": 1.898, "TestArgmaxArgminCommon": 1.3295576923076917, "TestArgmin": 1.4609999999999999, "TestContains": 0.004442307692307693, "TestIndexing": 0.40171153846153845, "TestIter": 0.010064102564102563, "TestNoExtraMethods": 0.020448717948717946, "TestNonzero": 0.194974358974359, "TestRavel": 0.009493589743589746, "TestReshape": 0.007647435897435899, "TestTranspose": 0.015782051282051287}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 2.387756410256384, "TestNEP50Table": 0.05437820512820514}, "torch_np/test_random": {"TestChoice": 0.019089743589743594, "TestNumpyGlobal": 0.0067564102564102585, "TestScalarReturn": 0.4985512820512821, "TestShuffle": 0.041423076923076924}, "torch_np/test_reductions": {"TestAll": 0.029980769230769238, "TestAny": 0.027134615384615382, "TestFlatnonzero": 0.37466666666666665, "TestGenericCumSumProd": 0.043884615384615376, "TestGenericReductions": 3.5725576923076474, "TestMean": 0.0409423076923077, "TestSum": 0.34770512820512817}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.45932051282051284, "TestIsScalar": 0.0816346153846154}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 2.3166025641025643, "TestNdarrayDunderVsUfunc": 0.4773846153846154, "TestUfuncDtypeKwd": 0.010974358974358975, "TestUnaryUfuncs": 0.5190833333333331}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.6813653846153845}}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": {"TestFullyShardAutograd": 33.41277777777778}, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize2": 12.18811111111111, "TestClipGradNormWorldSize4": 3.483777777777778}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 29.8885, "TestFullyShardCollectiveOps": 56.97105555555556, "TestFullyShardCommunication": 21.466222222222225, "TestFullyShardPrefetch": 8.640166666666666, "TestFullyShardUnshardMultiProcess": 10.858944444444445, "TestFullyShardUnshardMultiThread": 0.01927777777777778}, "distributed/_composable/fsdp/test_fully_shard_compile": {"TestFullyShardCompile": 4.546666666666667, "TestFullyShardCompileCompute": 10.594333333333333}, "distributed/_composable/fsdp/test_fully_shard_extensions": {"TestFullyShardAllGatherExtensionsMultiProcess": 14.416722222222221, "TestFullyShardAllGatherExtensionsMultiThread": 7.688722222222222}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 35.542}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.11283333333333334, "TestFullyShardDeviceTensor": 0.17194444444444446, "TestFullyShardHSDPBroadcast": 0.4405555555555556, "TestFullyShardLazyInit": 0.050722222222222224, "TestFullyShardManagedModulesAndStates": 0.026, "TestFullyShardMeshArg": 0.0071666666666666675, "TestFullyShardMetaDeviceInit": 10.063055555555556, "TestFullyShardParamModuleInfos": 0.011944444444444445, "TestFullyShardProcessGroupInit": 0.6194444444444444, "TestFullyShardShardedParameterDTensor": 0.0665, "TestFullyShardShardedParameterTensor": 0.05499999999999999}, "distributed/_composable/fsdp/test_fully_shard_memory": {"TestFullyShardMemory": 13.053888888888887}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionCasts": 23.0885, "TestFullyShardMixedPrecisionTraining": 35.649499999999996}, "distributed/_composable/fsdp/test_fully_shard_overlap": {"TestFullyShardOverlap": 7.277333333333334}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.1968888888888889}, "distributed/_composable/fsdp/test_fully_shard_state_dict": {"TestFullyShardStateDictMultiProcess": 26.061944444444446, "TestFullyShardStateDictMultiThread": 0.2615}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 7.514555555555556, "TestFullyShard1DTrainingCore": 138.0821111111111, "TestFullyShard2DTraining": 15.368333333333334, "TestFullyShardCastAfterInit": 0.42333333333333334, "TestFullyShardCustomForwardMethod": 13.657111111111112, "TestFullyShardForwardInputs": 0.18666666666666665, "TestFullyShardGradientAccumulation": 28.587666666666664, "TestFullyShardHSDPTraining": 6.580444444444443, "TestFullyShardNDTraining": 3.696944444444444, "TestFullyShardRegisteredParams": 7.289833333333333, "TestFullyShardSharedParams": 11.944611111111113, "test_fully_shard_training": 0.0003333333333333333}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 35.36183333333334}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 33.48494444444444}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 11.491166666666667}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 20.129944444444444}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 23.009666666666664}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 23.881888888888884}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 4.630777777777777}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 6.976499999999999}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 88.89283333333333}, "distributed/_composable/test_contract": {"TestContract": 0.29838888888888887}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 7.887388888888888, "ReplicateTest": 46.84861111111112}, "distributed/_composable/test_replicate_with_compiler": {"DDP_TP_Test": 1.5133333333333334, "ReplicateTest": 56.18622222222223}, "distributed/_shard/sharded_optim/test_sharded_optim": {"TestShardedOptimizer": 3.844666666666666}, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": {"TestShardedTensorBinaryOps": 7.607666666666668}, "distributed/_shard/sharded_tensor/ops/test_embedding": {"TestShardedEmbedding": 3.8426666666666667}, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": {"TestShardedEmbeddingBag": 3.840166666666667}, "distributed/_shard/sharded_tensor/ops/test_init": {"TestShardedTensorNNInit": 5.751166666666667}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 14.230166666666667}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.28938888888888886}, "distributed/_shard/sharded_tensor/test_sharded_tensor": {"TestCreateTensorFromParams": 0.041833333333333333, "TestCreateTensorNoProcessGroupMode": 0.003666666666666667, "TestLocalTensor": 3.7633333333333336, "TestModuleHookApi": 3.7471666666666668, "TestShardMetadata": 3.7641666666666667, "TestShardParameter": 3.7655000000000003, "TestShardTensor": 5.586500000000001, "TestShardedTensorChunked": 41.12866666666665, "TestShardedTensorCustomOps": 5.587500000000001, "TestShardedTensorEnumerable": 26.076666666666668, "TestShardedTensorFromLocalShards": 21.361, "TestShardedTensorFromLocalTensor": 3.7130000000000005, "TestShardedTensorMetadata": 0.3113333333333333, "TestShardedTensorSubGroupInit": 0.019666666666666666}, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": {"TestReshard": 3.8626666666666662}, "distributed/_shard/sharding_plan/test_sharding_plan": {"TestShardingPlan": 5.666333333333333}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 10.07688888888889, "TestShardingSpec": 0.03516666666666667}, "distributed/_shard/test_sharder": {"TestCustomSharder": 5.797944444444444}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 6.5935}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.45611111111111113}, "distributed/_tensor/experimental/test_local_map": {"TestLocalMap": 45.07005555555555}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 26.762611111111113}, "distributed/_tensor/test_api": {"DTensorAPITest": 30.975833333333338}, "distributed/_tensor/test_attention": {"RingAttentionTest": 3.317166666666666}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 38.51533333333333}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 46.972388888888894}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 41.93577777777778, "DTensorTest": 84.06099999999999, "TestDTensorPlacementTypes": 4.1641111111111115}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 13.87533333333333, "TestDTensorCompileE2E": 19.83977777777778}, "distributed/_tensor/test_dtensor_ops": {"TestDTensorOpsCPU": 62.59200000000002}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 13.99211111111111}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 13.451666666666666}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 22.999166666666667, "DTensorInitOpsTest": 4.6339999999999995}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 48.515499999999996}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 79.99211111111111}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.103, "TestEinsumDims": 0.2756111111111111, "TestEinsumStrategies": 0.059}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 120.10527777777777}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.6277777777777778}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 4.673111111111111, "DistTensorRandomOpTest": 24.809277777777776}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 5.8643888888888895, "RedistributeTest": 38.53911111111111}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 182.90422222222222}, "distributed/_tensor/test_utils": {"Test2DStridedLocalShard": 7.6755, "UtilTest": 16.199277777777777}, "distributed/_tensor/test_view_ops": {"TestViewOps": 27.83388888888889}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.2886666666666667}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 8.913166666666667}, "distributed/_tools/test_mod_tracker": {"TestModTracker": 0.29033333333333333}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 29.140777777777775}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 42.453888888888876}, "distributed/algorithms/test_join": {"TestJoin": 36.794444444444444}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ESaveAndLoad": 44.26061111111111, "TestNoCPU": 4.381333333333333}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 2.9839444444444445}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 2.972555555555555}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 3.7279999999999998}, "distributed/checkpoint/fsdp/test_fsdp_dsd": {"TestFullyShardWithDistributedStateDict": 14.539333333333332}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 7.0826111111111105, "TestDistributedFailure": 18.829055555555556}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.43272222222222223}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.31450000000000006}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 4.835388888888889}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 18.29372222222222, "TestDTensorReshardPlacementChange": 8.45}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 14.802722222222224, "TestDistributedStateDictSaveLoad": 0.4416666666666667, "TestDistributedStateDictSaveLoadWithSharedTensor": 3.5992777777777776}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 30.452555555555552, "TestDistributedStateDictSaveLoad": 0.4397222222222223, "TestDistributedStateDictSaveLoadWithSharedTensor": 7.413611111111112}, "distributed/checkpoint/test_format_utils": {"TestFormatUtils": 12.461888888888888}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 15.287555555555556}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 22.751666666666665}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 11.743055555555557}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.43816666666666665, "TestFSSpecWithDist": 14.187888888888887}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 14.92827777777778}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.28994444444444445}, "distributed/checkpoint/test_planner": {"TestLoadPlanner": 0.15605555555555556, "TestPlannerHelpers": 0.002166666666666667, "TestSavePlan": 0.30211111111111105}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 3.8168333333333333}, "distributed/checkpoint/test_state_dict": {"TestNoComm": 4.245277777777777, "TestStateDict": 152.3171111111111}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 14.793999999999999}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 16.425}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.2953333333333333}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.3000555555555556, "TestTensorProperties": 0.002}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.30266666666666664, "RdzvEventLibTest": 0.06516666666666668}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.30088888888888893}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.3057222222222222, "StartProcessesListTest": 20.76111111111111, "StartProcessesTest": 15.999055555555557, "StdTest": 0.0051666666666666675}, "distributed/elastic/test_control_plane": {"WorkerServerTest": 4.9078333333333335}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 14.971055555555553}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.15422222222222223, "LocalTimerTest": 3.9008888888888897, "MultiprocessingRequestQueueTest": 1.6943333333333335}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 2.691444444444444}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.3277222222222222}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.3035555555555556, "UtilTest": 0.060277777777777784}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 6.780666666666666}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.28394444444444444}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 14.011833333333334}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 12.928166666666664}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 180.7532777777778, "TestFSDPCheckpointSubmodule": 11.087000000000002}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 59.059}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 90.96833333333332, "TestExplicitUnshard": 20.849277777777775}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 216.2923333333334}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 12.036499999999998, "TestHooks": 80.59683333333334, "TestNoGrad": 22.996277777777777, "TestParamInit": 22.79661111111111, "TestParityWithDDP": 1113.2890555555555}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 163.96994444444445}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 90.0436111111111}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 51.25994444444444}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 66.38694444444445}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 369.34588888888885}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.3042777777777778}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 69.72500000000001}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 48.954}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 108.97538888888887}, "distributed/fsdp/test_fsdp_input": {"TestInput": 21.71761111111111}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 28.62161111111111}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 75.75077777777778}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 116.42944444444443, "TestFSDPMiscMultiThread": 0.5517777777777778, "TestFSDPMiscWorldSize1": 6.4798888888888895}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 67.02733333333333, "TestFSDPMixedPrecisionIgnoredModules": 10.738222222222221, "TestFSDPMixedPrecisionSharded": 547.4054444444445, "TestFSDPMixedPrecisionUnsharded": 32.45072222222222, "TestFSDPTrainEval": 13.057666666666668}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 11.56411111111111}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 11.373777777777775}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 676.607388888889}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 16.67088888888889, "TestForwardOverlapWorldSizeTwo": 25.756}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 22.66416666666667}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.37738888888888883, "TestShardedGradScalerParityWithDDP": 212.943}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 962.9650555555558, "TestFSDPStateDict4GPUs": 3.4362222222222223}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 13.35311111111111}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 4.6127777777777785}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 11.391166666666665}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 55.532611111111116, "TestUnshardParamsErrors": 24.03644444444444, "TestUnshardParamsNoShard": 8.655166666666666}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 11.520444444444445, "TestFSDPUseOrigParamsInit": 4.735, "TestFSDPUseOrigParamsMultipleParamGroups": 167.55794444444444, "TestFSDPUseOrigParamsNoSync": 23.02072222222222, "TestFSDPUseOrigParamsParamAccess": 11.600999999999999, "TestFSDPUseOrigParamsUnshardReshard": 50.95183333333333, "TestFSDPUseOrigParamsWriteback": 43.90394444444444, "TestMultiTensorApply": 0.049055555555555554}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 29.0445}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 4.652833333333333, "TestShardUtilsDistributedDTensor": 4.3635}, "distributed/fsdp/test_utils": {"TestUtils": 0.43566666666666665}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 9.341777777777779, "TestFSDPWrap": 190.62516666666667, "TestWrapUtils": 0.017055555555555556}, "distributed/launcher/test_run": {"ElasticLaunchTest": 43.455611111111104}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.3082777777777778}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 173.64716666666664, "TestZeroRedundancyOptimizerSingleRank": 31.13588888888889}, "distributed/pipelining/test_backward": {"StageBackwardTests": 0.31733333333333336}, "distributed/pipelining/test_microbatch": {"MicrobatchTests": 0.7111666666666666}, "distributed/pipelining/test_pipe": {"PipeTests": 1.2026111111111109}, "distributed/pipelining/test_schedule": {"ScheduleTest": 26.231999999999996, "TestSchedulePlan": 0.9938333333333333}, "distributed/pipelining/test_stage": {"StageTest": 23.225583333333333}, "distributed/pipelining/test_transformer": {"TransformerTests": 1.0212222222222223}, "distributed/pipelining/test_unflatten": {"UnflattenTests": 0.9515000000000001}, "distributed/rpc/cuda/test_tensorpipe_agent": {"TensorPipeCudaDdpComparisonTest": 2.230833333333334, "TensorPipeCudaDistAutogradTest": 12.608, "TensorPipeCudaRemoteModuleTest": 15.344833333333334, "TensorPipeCudaRpcTest": 4.205333333333333, "TensorPipeTensorPipeAgentCudaRpcTest": 454.62533333333334, "TensorPipeTensorPipeCudaDistAutogradTest": 11.5675}, "distributed/rpc/test_faulty_agent": {"FaultyFaultyAgentDistAutogradTest": 19.854333333333333, "FaultyFaultyAgentRpcTest": 177.38566666666668, "FaultyJitFaultyAgentRpcTest": 49.06}, "distributed/rpc/test_share_memory": {"TestRPCPickler": 3.7123333333333335}, "distributed/rpc/test_tensorpipe_agent": {"TensorPipeDdpComparisonTest": 14.408000000000001, "TensorPipeDdpUnderDistAutogradTest": 5.460666666666666, "TensorPipeDistAutogradTest": 238.13166666666666, "TensorPipeDistOptimizerTest": 15.234, "TensorPipeJitDistAutogradTest": 14.283666666666667, "TensorPipeJitRpcTest": 193.28366666666668, "TensorPipeParameterServerTest": 3.5276666666666667, "TensorPipeReinforcementLearningRpcTest": 3.6926666666666663, "TensorPipeRemoteModuleTest": 42.486333333333334, "TensorPipeRpcTest": 798.1766666666668, "TensorPipeTensorPipeAgentDistAutogradTest": 112.9833333333333, "TensorPipeTensorPipeAgentRpcTest": 154.62300000000002, "TensorPipeThreeWorkersRemoteModuleTest": 9.881333333333332}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 3.8578888888888887}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 25.605888888888888, "TestNew2dParallelTraining": 18.63}, "distributed/tensor/parallel/test_micro_pipeline_tp": {"MicroPipelineTPTest": 11.137500000000001, "test_micro_pipeline_tp": 0.0}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 38.60938888888889}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 55.794555555555554}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 3.8796666666666666}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 67.87922222222223}, "distributed/test_c10d_common": {"CommTest": 3.6779583333333337, "ComputeBucketAssignmentTest": 1.0699166666666666, "LocalRankTest": 15.263333333333332, "ProcessGroupWithDispatchedCollectivesTests": 7.279333333333333, "PythonProcessGroupExtensionTest": 29.649124999999998, "ReduceOpTest": 1.0757500000000002, "TimeoutTest": 35.181125}, "distributed/test_c10d_functional_native": {"CompileTest": 57.08877777777778, "TestWithNCCL": 39.276}, "distributed/test_c10d_gloo": {"CommTest": 43.172000000000004, "CompilerTest": 44.88988888888889, "DistributedDataParallelTest": 293.6938888888889, "GlooProcessGroupWithDispatchedCollectivesTests": 25.906444444444446, "LargeCommTest": 12.265944444444445, "ProcessGroupGlooTest": 218.56077777777782, "ReducerTest": 0.3261111111111111, "RendezvousEnvTest": 0.3113888888888889, "TimeoutTest": 3.8403888888888886}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 16.512666666666664}, "distributed/test_c10d_nccl": {"CommTest": 91.55866666666667, "CompilerTest": 67.6435, "DistributedDataParallelTest": 756.131, "LargeCommTest": 62.68927777777778, "NCCLTraceTest": 125.41111111111111, "NCCLTraceTestDumpOnTimeout": 15.705888888888888, "NCCLTraceTestTimeoutDumpOnStuckRanks": 8.31238888888889, "NcclErrorDumpTest": 6.866666666666667, "NcclErrorHandlingTest": 28.935555555555556, "NcclProcessGroupWithDispatchedCollectivesTests": 36.186777777777785, "ProcessGroupNCCLGroupTest": 100.29794444444444, "ProcessGroupNCCLNoGPUTest": 0.0011666666666666668, "RendezvousEnvTest": 0.04311111111111112, "SparseCollective": 15.920833333333334, "TimeoutTest": 3.5683333333333334, "WorkHookTest": 37.76888888888889}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 41.899}, "distributed/test_c10d_ops_nccl": {"ProcessGroupNCCLOpTest": 8.399}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 176.14572222222228, "TestDDPWithWorkWrapper": 175.67194444444442}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 14.953000000000001, "ProcessGroupShareTensorTest": 11.6255, "TestDistributedNNFunctionsGloo": 32.964055555555554}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 13.826000000000002, "TestDistributedNNFunctionsNccl": 31.252055555555557}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.0037500000000000007, "TestDistributedNNFunctionsUcc": 7.775666666666667}, "distributed/test_c10d_ucc": {"CommTest": 29.427333333333333, "CompilerTest": 46.14833333333333, "DistributedDataParallelTest": 143.1026666666667, "ProcessGroupUCCTest": 27.559, "RendezvousEnvTest": 0.31033333333333335, "TimeoutTest": 3.3260000000000005, "UccProcessGroupWithDispatchedCollectivesTests": 7.928}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 2.935222222222222}, "distributed/test_control_collectives": {"TestCollectives": 0.3472777777777778}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 9.246333333333332}, "distributed/test_data_parallel": {"TestDataParallel": 15.05511111111111, "TestDataParallelDeviceTypeCPU": 0.019666666666666673, "TestDataParallelDeviceTypeCUDA": 0.09341666666666668}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 27.049222222222227, "DeviceMeshTest": 47.040888888888894, "DeviceMeshTestNDim": 23.34561111111111, "InitDeviceMeshTest": 13.658444444444447, "TestDeviceMeshGetItem": 27.445833333333336, "TestMeshEnv": 17.596277777777775}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 5279.935888888899}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 15.118944444444445, "TestMultiProc": 64.21488888888888, "TestSingleProc": 17.906111111111112}, "distributed/test_fake_pg": {"TestFakePG": 6.841555555555555}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 22.129, "TestExpand": 0.3791666666666667, "TestFunctionalAutograd": 13.51, "TestFunctionalAutogradWithNCCL": 3.4706111111111113, "TestGradCollectives": 0.004555555555555556, "TestMakeFx": 0.04505555555555555, "TestMetaCollectives": 0.002166666666666667, "TestNCCLCollectivesWithWorldSize4": 19.68961111111111, "TestPgTag": 0.03966666666666666, "TestTraceableCollectives": 0.15650000000000006}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.559555555555555, "TestCollectivesMultiProc": 87.99694444444447}, "distributed/test_launcher": {"TestDistributedLaunch": 1.5170000000000001}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.30288888888888893, "TestCollectivesWithWrapper": 0.3458333333333334}, "distributed/test_nccl": {"TestNCCLCUDA": 0.5566666666666666}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 38.13138888888889, "ProcessGroupNCCLWrapperTest": 31.279333333333337}, "distributed/test_store": {"FileStoreTest": 3.6750000000000003, "HashStoreTest": 2.068111111111111, "InitPgWithNonUvStore": 0.638888888888889, "LibUvTCPStoreTest": 10.487166666666667, "PrefixFileStoreTest": 2.9599999999999995, "PrefixStoreTest": 0.004333333333333334, "PrefixTCPStoreTest": 2.3933888888888886, "PythonStoreTest": 0.2957222222222222, "RendezvousEnvTest": 0.30044444444444446, "RendezvousFileTest": 0.6106111111111111, "RendezvousTCPTest": 25.170666666666666, "RendezvousTest": 0.5942222222222223, "TCPStoreTest": 10.481055555555555, "TestMultiThreadedWait": 1.7686666666666666, "TestPythonStore": 2.0913333333333335, "TimeoutTest": 6.142222222222223}, "distributed/test_symmetric_memory": {"SymmetricMemoryTest": 0.0006666666666666666}}, "dynamo": {"backends/xeon/test_launch": {"TestTorchrun": 1.9959999999999998}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.062}, "distributions/test_constraints": {"test_constraints": 0.08277777777777784}, "distributions/test_distributions": {"TestAgainstScipy": 0.0001111111111111111, "TestConstraints": 73.51633333333334, "TestDistributionShapes": 78.06933333333332, "TestDistributions": 0.003444444444444445, "TestFunctors": 3.859555555555556, "TestJit": 329.9116666666667, "TestKL": 0.033555555555555554, "TestLazyLogitsInitialization": 74.18922222222221, "TestNumericalStability": 0.026333333333333334, "TestRsample": 0.0, "TestValidation": 86.77444444444444}, "functorch/test_aotdispatch": {"TestAOTAutograd": 44.00866666666666, "TestAOTAutogradWithDynamo": 0.005222222222222223, "TestAOTDispatch": 7.06311111111111, "TestAOTExport": 5.339333333333333, "TestAOTModuleSimplified": 1.517777777777778, "TestEagerFusionModuleInfoCPU": 2.6024444444444352, "TestEagerFusionOpInfoCPU": 14.531333333333306, "TestPartitioning": 5.852444444444444, "TestPythonKeyCPU": 14.539666666666667}, "functorch/test_control_flow": {"TestControlFlow": 8.409666666666665, "TestControlFlowTraced": 386.9460000000001}, "functorch/test_dims": {"TestMin": 0.0026666666666666666, "TestMinFunctorchOnly": 0.0008333333333333333}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 4.922, "TestAutogradFunctionVmapAPICPU": 0.9955555555555554, "TestCompileTransformsCPU": 10.766, "TestComposabilityCPU": 11.143666666666668, "TestExamplesCorrectnessCPU": 28.19633333333333, "TestFunctionalizeCPU": 3.2928888888888888, "TestGradTransformCPU": 22.98744444444444, "TestHelpersCPU": 0.797, "TestHessianCPU": 4.645333333333333, "TestHigherOrderOperatorInteractionCPU": 1.3527777777777779, "TestJacCPU": 59.35655555555555, "TestJvpCPU": 6.9143333333333326, "TestLinearizeCPU": 1.5638888888888889, "TestMakeFunctional": 1.655, "TestSliceArgnums": 0.4034444444444445, "TestVmapJvpInplaceViewCPU": 4.868333333333333, "TestVmapOfGradCPU": 27.498555555555555}, "functorch/test_logging": {"TestAOTLogging": 0.5722222222222222}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.8321666666666665, "RandomOpTestCase": 0.47916666666666663, "ReduceTestCase": 0.6881666666666666, "TestMemoryEfficientOpAuthoring": 0.00016666666666666666}, "functorch/test_minifier": {"TestMinifier": 1.5866666666666667}, "functorch/test_ops": {"TestOperatorsCPU": 38.52222222222576}, "functorch/test_parsing": {"TestAnonymousAxis": 0.5738333333333333, "TestParsedExpression": 0.026666666666666665, "TestParsingUtils": 0.03166666666666667, "TestValidateRearrangeExpressions": 0.03166666666666667}, "functorch/test_rearrange": {"TestRearrange": 4.338166666666667}, "functorch/test_vmap": {"TestRandomnessCPU": 140.43244444444446, "TestTransformFailureCPU": 0.06755555555555555, "TestVmapAPI": 46.90744444444445, "TestVmapBatchedGradientCPU": 32.300111111111114, "TestVmapDeviceTypeCPU": 1.8623333333333332, "TestVmapNestedTensorCPU": 2.4021111111111115, "TestVmapOperators": 1072.6026666666664, "TestVmapOperatorsOpInfoCPU": 32.550333333333384}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 13.112444444444188}, "higher_order_ops/test_with_effects": {"TestWithEffects": 7.647333333333333}, "lazy/test_debug_util": {"DebugUtilTest": 0.6444444444444445}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.7478888888888888}, "lazy/test_generator": {"LazyGeneratorTest": 0.582}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.7163333333333334}, "lazy/test_step_closures": {"ClosuresTest": 2.604111111111111}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.21633333333333335, "TestLazyOpInfoCPU": 2.655333333333322, "TestLazyTensor": 0.24822222222222223}, "nn/test_convolution": {"TestConvolutionNN": 22.86277777777778, "TestConvolutionNNDeviceTypeCPU": 175.59444444444432}, "nn/test_dropout": {"TestDropoutNN": 0.8406666666666668, "TestDropoutNNDeviceTypeCPU": 4.860888888888888}, "nn/test_embedding": {"TestEmbeddingNN": 4.097555555555554, "TestEmbeddingNNDeviceTypeCPU": 214.16255555555549}, "nn/test_init": {"TestNNInit": 1.660333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 11.843777777777776}, "nn/test_load_state_dict": {"TestLoadStateDict": 3.4086666666666665, "TestLoadStateDictSwap": 0.017111111111111108}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.45177777777777783, "TestModuleHookNN": 2.0975555555555556, "TestModuleHooks": 12.818333333333333, "TestStateDictHooks": 1.406}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 23.44088888888889, "TestMultiheadAttentionNNDeviceTypeCPU": 1.438}, "nn/test_packed_sequence": {"PackedSequenceTest": 5.622111111111111}, "nn/test_parametrization": {"TestNNParametrization": 16.20866666666667, "TestNNParametrizationDeviceCPU": 0.10111111111111111}, "nn/test_pooling": {"TestAvgPool": 2.8027777777777776, "TestPoolingNN": 1.086888888888889, "TestPoolingNNDeviceTypeCPU": 49.84266666666667}, "nn/test_pruning": {"TestPruningNN": 6.1258888888888885}, "profiler/test_execution_trace": {"TestExecutionTrace": 1.2237777777777776}, "profiler/test_memory_profiler": {"TestDataFlow": 0.0, "TestIdentifyGradients": 0.0001111111111111111, "TestMemoryProfiler": 0.0006666666666666666, "TestMemoryProfilerE2E": 0.0003333333333333333}, "profiler/test_profiler": {"TestExperimentalUtils": 26.599999999999998, "TestProfiler": 35.26355555555555, "TestProfilerCUDA": 0.0004444444444444444, "TestProfilerITT": 0.17655555555555558}, "profiler/test_profiler_tree": {"TestProfilerTree": 31.37966666666667}, "profiler/test_record_function": {"TestRecordFunction": 0.7719999999999999}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.342222222222222}, "test_ao_sparsity": {"TestActivationSparsifier": 0.010333333333333333, "TestBaseDataScheduler": 0.45011111111111113, "TestBaseDataSparsifier": 2.8159999999999994, "TestBaseSparsifier": 0.4797777777777778, "TestBaseStructuredSparsifier": 33.07633333333334, "TestComposability": 2.5973333333333333, "TestCubicScheduler": 0.45555555555555555, "TestFPGMPruner": 0.9728888888888889, "TestFakeSparsity": 3.6592222222222226, "TestFxComposability": 9.404111111111112, "TestNearlyDiagonalSparsifier": 9.757888888888887, "TestNormDataSparsifiers": 5.109111111111111, "TestQuantizationUtils": 0.36366666666666675, "TestQuantizedSparseKernels": 0.4623333333333333, "TestQuantizedSparseLayers": 0.022000000000000002, "TestSaliencyPruner": 0.34333333333333327, "TestScheduler": 0.6902222222222223, "TestSparsityUtilFunctions": 0.31544444444444447, "TestWeightNormSparsifier": 1.1851111111111112}, "test_autocast": {"TestAutocastCPU": 11.063333333333333, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.10033333333333333}, "test_autograd": {"TestAllowMutationOnSaved": 0.3701111111111111, "TestAutograd": 61.49266666666667, "TestAutogradComplex": 0.7283333333333334, "TestAutogradDeviceTypeCPU": 7.687, "TestAutogradForwardMode": 2.2600000000000002, "TestAutogradForwardModeBatchedGrad": 0.4687777777777778, "TestAutogradFunctional": 44.55522222222222, "TestAutogradInferenceMode": 0.8088888888888889, "TestAutogradLogging": 0.14533333333333331, "TestAutogradMultipleDispatchCPU": 1.0934444444444444, "TestMultithreadAutograd": 1.7557777777777777, "TestNestedCheckpoint": 2.2526666666666664, "TestSelectiveActivationCheckpoint": 0.11188888888888891}, "test_autograd_fallback": {"TestAutogradFallback": 1.9768888888888885}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 607.1754444444308}, "test_bundled_inputs": {"TestBundledInputs": 2.324}, "test_comparison_utils": {"TestComparisonUtils": 0.5866666666666668}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0004444444444444444}, "test_complex": {"TestComplexTensorCPU": 0.9383333333333334}, "test_content_store": {"TestContentStoreCPU": 8.138777777777777}, "test_cpp_api_parity": {"TestCppApiParity": 117.13566666666657}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.817888888888889, "TestMAIATensor": 0.40900000000000003, "TestPybindTypeCasters": 0.05755555555555556, "TestRNGExtension": 0.009, "TestTorchLibrary": 0.007555555555555556}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.8213333333333334, "TestMAIATensor": 0.4096666666666667, "TestPybindTypeCasters": 0.0578888888888889, "TestRNGExtension": 0.008888888888888889, "TestTorchLibrary": 0.007555555555555555}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 55.28677777777778}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.8706666666666667}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.0213333333333345}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.8623333333333333}, "test_custom_ops": {"MiniOpTest": 9.21111111111111, "MiniOpTestOther": 0.45055555555555565, "TestCustomOp": 13.480000000000002, "TestCustomOpAPI": 1.1295555555555559, "TestCustomOpTestingCPU": 2.8416666666666663, "TestGenerateOpcheckTests": 3.4166666666666665}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 34.00322222222222, "TestConcatDataset": 0.1662222222222222, "TestConvAfterFork": 0.16255555555555556, "TestCustomPinFn": 0.02033333333333333, "TestDataLoader": 92.95100000000001, "TestDataLoaderDeviceTypeCPU": 0.04688888888888889, "TestDataLoaderPersistentWorkers": 121.29911111111112, "TestDatasetRandomSplit": 3.0724444444444448, "TestDictDataLoader": 0.16577777777777777, "TestIndividualWorkerQueue": 0.011111111111111112, "TestNamedTupleDataLoader": 0.15688888888888888, "TestSetAffinity": 0.1752222222222222, "TestStackDataset": 0.5842222222222223, "TestStringDataLoader": 0.011222222222222222, "TestTensorDataset": 0.30000000000000004}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.04288888888888889, "TestDataChunk": 0.25866666666666677, "TestDataFramesPipes": 0.048777777777777774, "TestFunctionalIterDataPipe": 4.517222222222222, "TestFunctionalMapDataPipe": 1.3282222222222224, "TestGraph": 0.28833333333333333, "TestIterDataPipeCountSampleYielded": 0.05722222222222222, "TestIterDataPipeGraphFastForward": 1.9685555555555554, "TestIterDataPipeSingletonConstraint": 0.14633333333333334, "TestIterableDataPipeBasic": 0.6658888888888889, "TestSerialization": 6.461333333333333, "TestSharding": 0.442, "TestStreamWrapper": 0.45411111111111113, "TestTyping": 0.06255555555555554}, "test_decomp": {"DecompOneOffTestsCPU": 0.5978888888888889, "HasDecompTest": 0.25, "TestDecompCPU": 14.304111111111126}, "test_deploy": {"TestFreezer": 0.458}, "test_dispatch": {"TestDispatch": 36.39211111111111, "TestPythonDispatcher": 0.08944444444444445}, "test_dlpack": {"TestTorchDlPackCPU": 8.086333333333332}, "test_dynamic_shapes": {"TestDimConstraints": 2.387, "TestFloorDiv": 0.6555555555555556, "TestGuardsExpressions": 0.21055555555555558, "TestPySymInt": 0.0026666666666666666, "TestSymNumberMagicMethods": 0.033}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 8.304888888888886, "TestExpandedWeightHelperFunctionCPU": 1.057777777777778, "TestExpandedWeightModuleCPU": 22.01866666666667}, "test_fake_tensor": {"FakeTensorConstHandling": 0.27944444444444444, "FakeTensorConverterTest": 0.28222222222222226, "FakeTensorDispatchCache": 1.011222222222222, "FakeTensorOpInfoTestCPU": 0.09233333333333334, "FakeTensorOperatorInvariants": 0.3645555555555557, "FakeTensorPropTest": 0.221, "FakeTensorSerialization": 0.06544444444444444, "FakeTensorTest": 3.5674444444444444, "PropagateRealTensorsFakeTensorConstHandling": 0.08266666666666667, "PropagateRealTensorsFakeTensorConverterTest": 0.08399999999999998, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.09177777777777778, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.10100000000000002, "PropagateRealTensorsFakeTensorPropTest": 0.03422222222222222, "PropagateRealTensorsFakeTensorTest": 0.4755555555555559}, "test_flop_counter": {"TestFlopCounter": 0.0021111111111111113}, "test_foreach": {"TestForeachCPU": 30.89688888888919}, "test_function_schema": {"TestFunctionSchema": 1.0424444444444445}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 34.08866666666666}, "test_functional_optim": {"TestFunctionalOptimParity": 1.4342222222222223}, "test_functionalization": {"TestCrossRefFunctionalization": 0.030888888888888886, "TestFunctionalization": 0.0028888888888888888}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.19866666666666666}, "test_futures": {"TestFuture": 3.088777777777777}, "test_fx": {"AnnotationsTest": 0.0628888888888889, "TestCSEPass": 2.167333333333333, "TestCommonPass": 0.5588888888888889, "TestConstFold": 1.6451111111111107, "TestConstParamShapeInControlFlow": 2.7133333333333334, "TestDCE": 0.3154444444444444, "TestFX": 136.59322222222224, "TestFXAPIBackwardCompatibility": 3.300444444444444, "TestFunctionalTracing": 48.29077777777775, "TestMatcher": 0.8905555555555557, "TestOperatorSignaturesCPU": 13.89677777777777, "TestPassManager": 0.4830000000000001, "TestSourceMatcher": 1.583888888888889, "TestSubgraphRewriter": 1.3703333333333336, "TestVisionTracing": 0.002111111111111111, "TypeCheckerTest": 5.554888888888889}, "test_fx_experimental": {"TestFXExperimental": 325.0123333333333, "TestNormalizeOperatorsCPU": 6.546888888888898, "TestTranslationValidation": 0.3107777777777778}, "test_fx_passes": {"TestFXGraphPasses": 7.4495555555555555, "TestFXMatcherUtils": 0.24900000000000008}, "test_fx_reinplace_pass": {"TestReinplacePass": 2.0864444444444445}, "test_import_stats": {"TestImportTime": 3.7464444444444442}, "test_indexing": {"NumpyTestsCPU": 1.4867777777777775, "TestIndexingCPU": 85.0367777777778}, "test_itt": {"TestItt": 0.4988888888888889}, "test_jit": {"TestAliasAnalysis": 0.5006666666666667, "TestAsync": 2.0394444444444444, "TestAtenPow": 3.7300000000000004, "TestAutodiffJit": 0.048666666666666664, "TestAutodiffSubgraphSlicing": 1.7839999999999998, "TestAwait": 1.8967777777777777, "TestBackends": 13.820666666666666, "TestBackendsWithCompiler": 6.272777777777777, "TestBatchMM": 1.0421111111111112, "TestBuiltins": 0.2997777777777778, "TestClassType": 2.9515555555555557, "TestComplex": 1.8708888888888886, "TestCustomOperators": 0.6203333333333334, "TestDCE": 0.05277777777777778, "TestDataParallel": 0.03988888888888888, "TestDataclasses": 9.82311111111111, "TestDeviceAnalysis": 6.315222222222222, "TestDict": 0.30922222222222234, "TestDtypeAnalysis": 5.592, "TestDtypeCustomRulesCPU": 5.466111111111101, "TestEnum": 0.39311111111111113, "TestFreezing": 0.4525555555555558, "TestFrontend": 0.31977777777777777, "TestFrozenOptimizations": 0.2828888888888891, "TestFunctionalBlocks": 0.3252222222222222, "TestFunctionalToInplaceActivation": 6.069222222222222, "TestGenerator": 0.5856666666666667, "TestGetDefaultAttr": 0.09755555555555556, "TestGraphRewritePasses": 0.06666666666666667, "TestHash": 0.4176666666666667, "TestHooks": 2.239888888888889, "TestIgnorableArgs": 0.054, "TestIgnoreContextManager": 0.18266666666666667, "TestInplaceToFunctionalActivation": 5.046222222222222, "TestIsinstance": 1.0414444444444448, "TestJit": 17.225444444444438, "TestJitGeneratedModule": 42.24233333333336, "TestJitProfiler": 0.6974444444444444, "TestJitUtils": 0.3076666666666667, "TestList": 7.303777777777776, "TestLogging": 0.29144444444444445, "TestMKLDNNReinplacing": 0.03255555555555555, "TestMisc": 1.5858888888888887, "TestMixTracingScripting": 0.15966666666666673, "TestModels": 4.311, "TestModuleAPIs": 0.1821111111111111, "TestModuleContainers": 3.0997777777777777, "TestModuleInterface": 0.8647777777777779, "TestModules": 0.03833333333333333, "TestNamedTuple": 0.2581111111111111, "TestNnapiBackend": 0.25722222222222235, "TestOpDecompositions": 0.27977777777777774, "TestOptimizeForMobilePreserveDebugInfo": 0.3804444444444444, "TestParametrization": 0.9346666666666666, "TestPeephole": 6.085222222222224, "TestProducerVersion": 0.01577777777777778, "TestProfiler": 0.0957777777777778, "TestPythonBindings": 0.8802222222222222, "TestPythonBuiltinOP": 4.136555555555556, "TestPythonIr": 0.3527777777777778, "TestRecursiveScript": 2.1809999999999996, "TestRemoveMutation": 3.025777777777778, "TestSaveLoad": 0.8173333333333336, "TestSaveLoadFlatbuffer": 0.5231111111111112, "TestSaveLoadForOpVersion": 2.412555555555556, "TestScript": 64.0553333333334, "TestScriptDict": 0.4697777777777778, "TestScriptList": 1.3308888888888888, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.4691111111111112, "TestScriptProfile": 21.633333333333336, "TestSlice": 0.618, "TestSparse": 0.18233333333333335, "TestStringFormatting": 0.4283333333333335, "TestSymbolicShapeAnalysis": 28.76722222222222, "TestTensorBuiltins": 0.5385555555555556, "TestTensorCreationOps": 0.19644444444444445, "TestTensorMethods": 0.11988888888888889, "TestTorchbind": 0.22844444444444456, "TestTracer": 1.0421111111111114, "TestTypeSharing": 1.235888888888889, "TestTypesAndAnnotation": 0.5728888888888889, "TestTyping": 2.0123333333333333, "TestUnion": 2.4678888888888886, "TestUnsupportedOps": 0.14800000000000002, "TestUpgraders": 1.5301111111111114, "TestWarn": 0.3504444444444444, "TestWith": 0.8024444444444444}, "test_jit_autocast": {"TestAutocast": 0.002444444444444445, "TestJitTraceAutocast": 0.0003333333333333333}, "test_jit_disabled": {"TestJitDisabled": 0.5724444444444444}, "test_jit_fuser_te": {"TestFuserCommon": 0.29688888888888887, "TestLoopnestRandomizationCPU": 0.8412222222222221, "TestNNCOpInfoCPU": 63.07688888889104, "TestTEFuserDynamic": 156.95777777777778, "TestTEFuserStatic": 114.18844444444444}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 1.030888888888889, "TestFusionPatternCPU": 13.349444444444444, "TestModel": 5.841000000000001, "TestOpCPU": 35.54622222222222}, "test_legacy_vmap": {"TestVmapAPILegacy": 11.187888888888887, "TestVmapBatchedGradientLegacyCPU": 16.375888888888888, "TestVmapOperatorsLegacy": 106.19611111111111}, "test_license": {"TestLicense": 0.4665555555555556}, "test_linalg": {"TestLinalgCPU": 1518.332555555555}, "test_logging": {"LoggingTest": 2.4726666666666666}, "test_masked": {"TestMaskedCPU": 36.37211111111111}, "test_maskedtensor": {"TestBasicsCPU": 6.4879999999999995, "TestBinary": 7.416555555555557, "TestOperatorsCPU": 7.371111111111112, "TestReductions": 5.023777777777778, "TestUnary": 17.712222222222223}, "test_meta": {"TestMetaCPU": 69.74244444444277, "TestMetaConverter": 2.4236666666666666}, "test_mkl_verbose": {"TestMKLVerbose": 3.9954444444444444}, "test_mkldnn": {"TestMkldnnCPU": 128.42744444444443}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0005555555555555556}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.8703333333333334}, "test_mobile_optimizer": {"TestOptimizer": 4.854}, "test_model_dump": {"TestModelDump": 2.851888888888889}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.3892222222222222}, "test_module_tracker": {"TestModuleTracker": 0.7476666666666666}, "test_modules": {"TestModuleCPU": 32.74133333333372}, "test_monitor": {"TestMonitor": 0.5303333333333334, "TestMonitorTensorboard": 0.0001111111111111111}, "test_multiprocessing": {"TestMultiprocessing": 25.63177777777778}, "test_multiprocessing_spawn": {"ErrorTest": 0.02622222222222222, "ForkTest": 0.8473333333333333, "SpawnTest": 26.231222222222218}, "test_namedtensor": {"TestNamedTensor": 6.9593333333333325}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.2025555555555556}, "test_native_functions": {"TestNativeFunctions": 1.1541111111111113}, "test_native_mha": {"TestMHADeviceTypeCPU": 20.677}, "test_nestedtensor": {"TestNestedTensor": 2.6205555555555553, "TestNestedTensorAutogradCPU": 5.184111111111111, "TestNestedTensorDeviceTypeCPU": 11.638888888888891, "TestNestedTensorSubclassCPU": 47.219777777777786}, "test_nn": {"TestAddRelu": 0.10744444444444444, "TestConstantPadNd": 0.09422222222222222, "TestFunctionalPickle": 0.016111111111111114, "TestFusionEval": 1.0425555555555557, "TestFusionUtils": 0.34166666666666673, "TestNN": 129.45055555555555, "TestNNDeviceTypeCPU": 518.0343333333334, "TestUtils": 0.022222222222222227}, "test_numba_integration": {"TestNumbaIntegration": 0.20666666666666675}, "test_numpy_interop": {"TestNumPyInteropCPU": 8.126777777777777}, "test_openmp": {"TestOpenMP_ParallelFor": 7.570555555555555}, "test_ops": {"TestCommonCPU": 37.03144444444664, "TestCompositeComplianceCPU": 5.4301111111108975, "TestFakeTensorCPU": 3.271444444444198, "TestMathBitsCPU": 3.2507777777776137, "TestRefsOpsInfoCPU": 1.4375555555555353, "TestSelfKwarg": 0.1771111111111111, "TestTagsCPU": 1.4775555555555409}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 4.865777777777526}, "test_ops_gradients": {"TestBwdGradientsCPU": 8.541444444444373}, "test_ops_jit": {"TestJitCPU": 1.805666666666639}, "test_optim": {"TestDifferentiableOptimizer": 0.0938888888888889, "TestLRScheduler": 13.405999999999997, "TestOptimRenewedCPU": 345.2914444444444, "TestSWAUtils": 5.3551111111111105}, "test_out_dtype_op": {"TestOutDtypeOp": 0.9950000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.3618888888888889, "TestDisabledTorchFunction": 0.012000000000000002, "TestDisabledUserWarnings": 0.017888888888888888, "TestEinsumOverride": 0.577, "TestGradCheckOverride": 0.43999999999999995, "TestGradNewOnesOverride": 0.009666666666666665, "TestIndexing": 0.08344444444444445, "TestIterator": 0.00977777777777778, "TestNamedTuple": 0.01011111111111111, "TestPickle": 0.009555555555555555, "TestRNN": 0.06644444444444444, "TestResolveName": 0.20866666666666667, "TestTorchFunctionMode": 0.3706666666666667, "TestTorchFunctionOverride": 251.12822222222357, "TestTorchFunctionWarning": 0.024444444444444446, "TestWrapTorchFunction": 0.01011111111111111}, "test_package": {"DirectoryReaderTest": 7.354888888888888, "ModelTest": 0.023777777777777776, "TestAnalyze": 1.1872222222222222, "TestDependencyAPI": 17.47444444444444, "TestDependencyHooks": 5.066888888888888, "TestDiGraph": 12.08, "TestGlobGroup": 14.400333333333334, "TestImporter": 6.009888888888888, "TestLoadBCPackages": 3.106666666666667, "TestMangling": 10.28388888888889, "TestMisc": 11.359111111111112, "TestPackageFX": 6.794555555555555, "TestPackageScript": 29.24977777777778, "TestRepackage": 1.4933333333333334, "TestResources": 4.009333333333333, "TestSaveLoad": 11.260222222222223}, "test_per_overload_api": {"TestPerOverloadAPI": 1.168111111111111}, "test_prims": {"TestDecompCPU": 0.02033333333333334, "TestPrimsBasic": 0.4192222222222222, "TestPrimsCPU": 0.5483333333333333, "TestRefsCPU": 0.22366666666666665}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.4121111111111111, "TestGenericProxyTensorFake": 12.322000000000001, "TestGenericProxyTensorReal": 14.286777777777777, "TestGenericProxyTensorSymbolic": 28.20866666666667, "TestProxyTensorOpInfoCPU": 31.905444444444928, "TestRealProxyTensor": 0.02033333333333333, "TestSymbolicTracing": 9.677}, "test_pruning_op": {"PruningOpTest": 0.5117777777777778}, "test_public_bindings": {"TestPublicBindings": 1.0725555555555557}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.3744444444444444, "TestPythonDispatch": 4.938444444444443, "TestPythonDispatcher": 0.11077777777777777, "TestPythonRegistration": 2.603444444444445, "TestWrapperSubclassAliasingCPU": 0.5533333333333335}, "test_pytree": {"TestCxxPytree": 1.314111111111111, "TestGenericPytree": 3.8733333333333326, "TestPythonPytree": 3.349888888888889}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.1048888888888889, "TestAOMigrationNNQuantized": 0.16766666666666674, "TestAOMigrationQuantization": 0.1347777777777778, "TestAOMigrationQuantizationFx": 0.18433333333333335, "TestBackendConfig": 3.203333333333333, "TestBiasCorrectionEager": 2.586444444444444, "TestBitsCPU": 0.3688888888888889, "TestComparatorOps": 2.6893333333333334, "TestDeprecatedJitQuantized": 4.853111111111111, "TestDistributed": 0.7092222222222223, "TestDuplicateDQPass": 8.630555555555556, "TestDynamicQuantizedModule": 62.04944444444444, "TestDynamicQuantizedOps": 36.39633333333334, "TestEqualizeEager": 2.298888888888889, "TestEqualizeFx": 41.81966666666667, "TestFXGraphMatcher": 4.781666666666667, "TestFXGraphMatcherModels": 6.851888888888889, "TestFXNumericSuiteCoreAPIs": 61.381, "TestFXNumericSuiteCoreAPIsModels": 35.58533333333333, "TestFXNumericSuiteNShadows": 48.01177777777778, "TestFakeQuantize": 4.574222222222222, "TestFakeQuantizeOps": 18.278333333333332, "TestFloat8DtypeCPU": 3.805444444444444, "TestFloat8DtypeCPUOnlyCPU": 0.40166666666666667, "TestFuseEager": 13.801111111111112, "TestFuseFx": 6.925888888888889, "TestFusedObsFakeQuant": 1.6467777777777781, "TestFusedObsFakeQuantModule": 1.4533333333333334, "TestFusionPasses": 0.04477777777777778, "TestFxDetectInputWeightEqualization": 2.1294444444444447, "TestFxDetectOutliers": 3.14, "TestFxModelReportClass": 7.130777777777777, "TestFxModelReportDetectDynamicStatic": 0.65, "TestFxModelReportDetector": 3.2576666666666667, "TestFxModelReportObserver": 2.9057777777777773, "TestFxModelReportVisualizer": 6.237555555555556, "TestGenerateNumericDebugHandle": 0.5303333333333332, "TestGraphUtils": 1.795222222222222, "TestHistogramObserver": 31.121444444444446, "TestMetaDataPorting": 13.159777777777776, "TestModelNumericsEager": 2.679555555555556, "TestNumericSuiteEager": 37.33288888888888, "TestObserver": 5.566777777777777, "TestPT2ERepresentation": 1.950888888888889, "TestPadding": 16.307666666666666, "TestQNNPackOps": 7.711111111111112, "TestQuantizationDocs": 0.06477777777777778, "TestQuantizeDynamicJitOps": 2.244666666666667, "TestQuantizeDynamicJitPasses": 6.112000000000001, "TestQuantizeEagerOps": 8.008444444444445, "TestQuantizeEagerPTQDynamic": 16.412555555555553, "TestQuantizeEagerPTQStatic": 40.443888888888885, "TestQuantizeEagerQAT": 36.25022222222222, "TestQuantizeEagerQATNumerics": 37.90611111111111, "TestQuantizeFx": 124.04466666666669, "TestQuantizeFxModels": 21.23266666666667, "TestQuantizeFxOps": 272.0995555555555, "TestQuantizeJit": 27.190222222222218, "TestQuantizeJitOps": 232.1163333333333, "TestQuantizeJitPasses": 11.113333333333335, "TestQuantizePT2E": 47.38411111111111, "TestQuantizePT2EQATModels": 2.212888888888889, "TestQuantizePT2EQAT_ConvBn1d": 49.45088888888889, "TestQuantizePT2EQAT_ConvBn2d": 43.90522222222222, "TestQuantizePT2EX86Inductor": 82.43599999999999, "TestQuantizedConv": 81.53077777777776, "TestQuantizedEmbeddingOps": 9.850999999999999, "TestQuantizedFunctionalOps": 3.6739999999999995, "TestQuantizedLinear": 29.728444444444445, "TestQuantizedOps": 177.6011111111111, "TestQuantizedTensor": 60.39822222222224, "TestRecordHistogramObserver": 0.14388888888888887, "TestReferenceQuantizedModule": 1.1239999999999999, "TestSerialization": 7.115111111111111, "TestStaticQuantizedModule": 142.95877777777778, "TestSubgraphRewriter": 2.4226666666666667, "TestUtils": 1.2582222222222221, "TestXNNPACKQuantizer": 26.35688888888889, "TestXNNPACKQuantizerModels": 2.4182222222222225}, "test_reductions": {"TestReductionsCPU": 466.15000000001424}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 131.69255555555551}, "test_schema_check": {"TestSchemaCheck": 0.5173333333333335, "TestSchemaCheckModeOpInfoCPU": 55.548111111112746}, "test_segment_reductions": {"TestSegmentReductionsCPU": 25.847222222222218}, "test_serialization": {"TestBothSerializationCPU": 0.19622222222222221, "TestOldSerialization": 34.74111111111112, "TestSerialization": 23.391222222222225, "TestSubclassSerialization": 0.4200000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.4754444444444445}, "test_shape_ops": {"TestShapeOpsCPU": 14.240222222222222}, "test_show_pickle": {"TestShowPickle": 0.46288888888888896}, "test_sort_and_select": {"TestSortAndSelectCPU": 39.908111111111104}, "test_sparse": {"TestSparseAnyCPU": 382.7824444444441, "TestSparseCPU": 465.6704444444444, "TestSparseLegacyAndDeprecation": 0.18411111111111111, "TestSparseMaskedReductionsCPU": 0.3721111111111112, "TestSparseMeta": 46.11222222222222, "TestSparseOneOff": 0.18588888888888888, "TestSparseUnaryUfuncsCPU": 12.319666666666684}, "test_sparse_csr": {"TestSparseCSRCPU": 180.3038888888871, "TestSparseCSRSampler": 0.7211111111111111, "TestSparseCompressedCPU": 154.14811111111118, "TestSparseCompressedTritonKernelsCPU": 0.08044444444444444}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.16911111111111113}, "test_spectral_ops": {"TestFFTCPU": 27.629444444444527, "TestFFTDocExamplesCPU": 0.4403333333333335}, "test_stateless": {"TestPythonOptimizeMode": 3.499111111111111, "TestStatelessDeprecation": 1.672666666666667, "TestStatelessFunctionalAPI": 9.804}, "test_subclass": {"TestSubclass": 3.7504444444444434}, "test_sympy_utils": {"TestNumbers": 0.33955555555555555, "TestSingletonInt": 0.02744444444444445, "TestSympyInterp": 31.570000000000004, "TestSympySolve": 1.127, "TestValueRanges": 7.06711111111111}, "test_tensor_creation_ops": {"TestAsArrayCPU": 79.41511111111114, "TestBufferProtocolCPU": 38.25288888888889, "TestLikeTensorCreationCPU": 0.2617777777777778, "TestRandomTensorCreationCPU": 20.427444444444443, "TestTensorCreationCPU": 54.34711111111113}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.5523333333333333, "TestTensorBoardFigure": 0.01622222222222222, "TestTensorBoardNumpy": 0.058888888888888886, "TestTensorBoardPyTorchNumpy": 0.6705555555555556, "TestTensorBoardPytorchGraph": 30.91633333333333, "TestTensorBoardSummary": 1.821, "TestTensorBoardSummaryWriter": 0.04966666666666667, "TestTensorBoardUtils": 0.5785555555555555, "TestTensorBoardWriter": 0.5695555555555555, "TestTensorProtoSummary": 0.2833333333333334}, "test_tensorexpr": {"TestTensorExprFuser": 0.002333333333333333}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.09444444444444446, "TestTensorExprPyBind": 3.483333333333333}, "test_testing": {"TestAssertClose": 1.8157777777777773, "TestAssertCloseContainer": 0.19511111111111112, "TestAssertCloseErrorMessage": 0.545888888888889, "TestAssertCloseQuantized": 0.17466666666666664, "TestAssertCloseSparseBSC": 0.12066666666666669, "TestAssertCloseSparseBSR": 0.13122222222222224, "TestAssertCloseSparseCOO": 0.6819999999999999, "TestAssertCloseSparseCSC": 0.12022222222222222, "TestAssertCloseSparseCSR": 0.14633333333333334, "TestFrameworkUtils": 11.108444444444444, "TestImports": 13.931666666666665, "TestMakeTensorCPU": 53.573, "TestOpInfoSampleFunctionsCPU": 11.70077777777773, "TestOpInfos": 0.023000000000000003, "TestTestParametrization": 0.17233333333333337, "TestTestParametrizationDeviceTypeCPU": 3.9206666666666656, "TestTestingCPU": 1.5354444444444448}, "test_torch": {"TestBasicVitalSigns": 0.22533333333333336, "TestTorch": 33.5887777777778, "TestTorchDeviceTypeCPU": 179.12199999999964, "TestVitalSignsCudaCPU": 0.009}, "test_transformers": {"TestAttnBiasCPU": 15.966222222222221, "TestSDPACPU": 665.5905555555554, "TestSDPAFailureModesCPU": 0.45555555555555566, "TestTransformersCPU": 130.70633333333333}, "test_type_hints": {"TestTypeHints": 0.45811111111111114}, "test_type_info": {"TestDTypeInfo": 0.8650000000000001}, "test_type_promotion": {"TestTypePromotionCPU": 57.478888888888974}, "test_typing": {"TestTyping": 75.41911111111112}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 240.01777777774228}, "test_utils": {"TestAssert": 0.09233333333333334, "TestBottleneck": 7.9717777777777785, "TestCheckpoint": 2.420555555555555, "TestCollectEnv": 0.9744444444444444, "TestCppExtensionUtils": 0.15288888888888888, "TestDataLoaderUtils": 3.7482222222222217, "TestDeviceUtilsCPU": 48.92200000000127, "TestExtensionUtils": 0.09266666666666667, "TestHipify": 0.006777777777777778, "TestHipifyTrie": 0.10566666666666667, "TestONNXUtils": 0.017, "TestRenderUtils": 0.08055555555555556, "TestStandaloneCPPJIT": 2.016888888888889, "TestTraceback": 0.042111111111111106}, "test_view_ops": {"TestOldViewOpsCPU": 25.630888888888894, "TestViewOpsCPU": 19.859444444444446, "TestViewOpsLAZY": 4.657333333333331}, "test_vulkan": {"TestVulkanRewritePass": 0.0007777777777777777}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.12966666666666668, "WeakKeyDictionaryTestCase": 0.2501111111111111, "WeakTest": 5.550888888888888}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 31.801888888888893, "TestXNNPACKOps": 9.112888888888888, "TestXNNPACKRewritePass": 1.881, "TestXNNPACKSerDes": 5.195444444444445}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.5784444444444448}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.9383333333333329, "TestClassGetItem": 0.000888888888888889, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.02011111111111111, "TestMisc": 0.030333333333333337, "TestPickling": 0.2757777777777779, "TestPromotion": 0.0011111111111111111}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 26.391666666666666, "TestEinsumPath": 0.0, "TestMisc": 0.09799999999999999}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.2138888888888889, "TestHalf": 0.0001111111111111111, "TestIinfo": 0.35255555555555557, "TestMisc": 0.032999999999999995, "TestPythonFloat": 0.0006666666666666666, "TestRepr": 0.022777777777777775, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0558888888888889, "TestBooleanIndexing": 0.11122222222222222, "TestBroadcastedAssignments": 0.23144444444444448, "TestFancyIndexingCast": 0.12866666666666668, "TestFloatNonIntegerArgument": 0.12288888888888888, "TestIndexing": 2.4026666666666663, "TestMultiIndexingAutomated": 0.13855555555555557, "TestMultipleEllipsisError": 0.03255555555555555, "TestNonIntegerArrayLike": 0.007666666666666666}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.17683333333333334, "TestArgmax": 2.197333333333333, "TestArgmaxArgminCommon": 10.238333333333337, "TestArgmin": 2.1584999999999996, "TestArrayAttributeDeletion": 0.10316666666666666, "TestArrayConstruction": 0.5913333333333335, "TestArrayCreationCopyArgument": 0.49900000000000017, "TestAssignment": 0.12833333333333335, "TestAttributes": 0.3108333333333333, "TestBinop": 0.22166666666666668, "TestBool": 0.38650000000000007, "TestCequenceMethods": 0.01566666666666667, "TestChoose": 0.2871666666666667, "TestClip": 0.10949999999999999, "TestCompress": 0.1085, "TestConversion": 0.05316666666666667, "TestCreation": 0.004666666666666667, "TestDelMisc": 0.010499999999999999, "TestDot": 0.7741666666666668, "TestDtypedescr": 0.014166666666666668, "TestFancyIndexing": 0.3655, "TestFlag": 0.49050000000000016, "TestFormat": 0.08533333333333333, "TestFromBuffer": 0.1375, "TestHash": 0.45149999999999996, "TestHashing": 0.04566666666666667, "TestIO": 0.0033333333333333335, "TestInner": 0.10416666666666667, "TestLexsort": 0.5635000000000001, "TestMatmul": 2.2599999999999993, "TestMatmulOperator": 0.4385000000000001, "TestMethods": 8.527833333333334, "TestMinMax": 0.026333333333333334, "TestMinScalarType": 0.06566666666666668, "TestNewaxis": 0.02983333333333333, "TestPEP3118Dtype": 0.0006666666666666666, "TestPutmask": 0.5405000000000001, "TestRepeat": 0.16749999999999998, "TestResize": 0.2781666666666667, "TestRichcompareScalar": 0.007833333333333333, "TestScalarIndexing": 0.32216666666666666, "TestSortFloatMisc": 4.8740000000000006, "TestStats": 1.7413333333333334, "TestSubscripting": 0.03916666666666667, "TestTake": 0.46916666666666673, "TestVdot": 0.14566666666666667, "TestWarnings": 0.03716666666666667, "TestWhere": 0.41800000000000004, "TestWritebackIfCopy": 0.27133333333333337}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.4863333333333333, "TestArgwhere": 0.6492222222222224, "TestArrayComparisons": 2.063333333333333, "TestBaseRepr": 0.17822222222222225, "TestBinaryRepr": 0.24233333333333332, "TestBoolArray": 4.39088888888889, "TestBoolCmp": 3.0568888888888885, "TestBoolScalar": 0.7704444444444444, "TestBroadcast": 0.4796666666666667, "TestClip": 2.621666666666666, "TestConvolve": 0.21933333333333338, "TestCorrelate": 0.5333333333333333, "TestCreationFuncs": 1.7186666666666668, "TestCross": 0.8223333333333332, "TestDtypePositional": 0.018333333333333337, "TestFloatExceptions": 0.33299999999999996, "TestFromiter": 0.0005555555555555556, "TestIndex": 0.17377777777777778, "TestIndices": 0.38255555555555554, "TestIsclose": 1.24, "TestIsscalar": 0.060222222222222226, "TestLikeFuncs": 0.001, "TestMoveaxis": 0.06444444444444444, "TestNonarrayArgs": 1.1335555555555559, "TestNonzeroAndCountNonzero": 1.39, "TestOuterMisc": 0.09022222222222222, "TestRequire": 0.05455555555555556, "TestResize": 0.847, "TestRoll": 0.7951111111111112, "TestRollaxis": 0.058888888888888886, "TestSeterr": 0.22822222222222224, "TestStdVar": 5.242888888888888, "TestStdVarComplex": 0.07566666666666667, "TestStringFunction": 0.1738888888888889, "TestTensordot": 0.09433333333333332, "TestTypes": 0.5121111111111111}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.061777777777777786, "TestCommonType": 0.6324444444444445, "TestDocStrings": 0.0002222222222222222, "TestIsSubDType": 0.0931111111111111, "TestScalarTypeNames": 0.24411111111111117}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 1.225888888888889, "TestFromInt": 0.04355555555555555, "TestFromString": 0.6962222222222222}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0014444444444444444, "TestBitCount": 0.0004444444444444444, "TestClassGetItem": 0.0006666666666666666, "TestClassGetitemMisc": 0.4981111111111111, "TestIsInteger": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0007777777777777778}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 1.5010000000000001, "TestBaseMath": 0.3437777777777778, "TestBitShifts": 0.49466666666666687, "TestComplexDivision": 0.028111111111111104, "TestConversion": 0.12366666666666669, "TestHash": 0.0005555555555555556, "TestModulus": 0.4998888888888889, "TestMultiply": 0.0001111111111111111, "TestNegative": 0.034444444444444444, "TestPower": 0.08233333333333333, "TestRepr": 0.02788888888888889, "TestScalarOpsMisc": 1.7002222222222219, "TestScalarSubclassingMisc": 0.601555555555556, "TestSubtract": 0.03588888888888889, "TestTypes": 0.576}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.7144444444444445, "TestAtleast2d": 0.13655555555555557, "TestAtleast3d": 0.12944444444444445, "TestBlock": 0.21533333333333338, "TestConcatenate": 2.356444444444444, "TestHstack": 0.23444444444444446, "TestStackMisc": 0.850888888888889, "TestVstack": 0.20044444444444445}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007888888888888888, "TestFFTShift": 1.0165555555555557, "TestIRFFTN": 0.03155555555555556, "TestRFFTFreq": 0.007666666666666666}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 68.64166666666667, "TestFFTShift": 0.5274444444444444, "TestFFTThreadSafe": 1.0795555555555554}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.9414444444444445}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.004333333333333334, "TestUnique": 3.8298888888888887}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.028777777777777777, "TestAmax": 0.053888888888888896, "TestAmin": 0.05577777777777778, "TestAngle": 0.1566666666666667, "TestAny": 0.13211111111111112, "TestAverage": 0.4257777777777778, "TestBincount": 0.5168888888888888, "TestCheckFinite": 0.07233333333333333, "TestCopy": 0.0658888888888889, "TestCorrCoef": 0.4561111111111111, "TestCov": 0.7840000000000001, "TestCumprod": 0.018666666666666668, "TestCumsum": 0.023777777777777776, "TestDelete": 1.3846666666666667, "TestDiff": 0.9414444444444444, "TestDigitize": 0.6813333333333333, "TestExtins": 0.2825555555555556, "TestFilterwindows": 3.500555555555554, "TestFlip": 0.20244444444444445, "TestGradient": 1.3981111111111109, "TestInsert": 2.317333333333333, "TestInterp": 11.713222222222223, "TestKaiser": 0.10922222222222222, "TestMedian": 4.001888888888889, "TestMeshgrid": 0.664888888888889, "TestMsort": 0.0, "TestPercentile": 4.338888888888887, "TestPiecewise": 0.09600000000000002, "TestProd": 0.019333333333333338, "TestPtp": 0.10266666666666668, "TestQuantile": 0.7296666666666667, "TestRot90": 0.7224444444444446, "TestSelect": 0.06955555555555554, "TestSinc": 0.084, "TestSortComplex": 0.2785555555555556, "TestTrapz": 0.7460000000000001, "TestTrimZeros": 0.17444444444444443, "TestUnique": 0.11677777777777777, "Test_I0": 0.1821111111111111}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 3.013222222222222, "TestHistogramOptimBinNums": 1.3208888888888888, "TestHistogramdd": 1.7307777777777777}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.03022222222222222, "TestConcatenator": 0.053888888888888896, "TestDiagIndices": 0.051222222222222225, "TestDiagIndicesFrom": 0.06633333333333334, "TestFillDiagonal": 0.18955555555555556, "TestGrid": 0.09499999999999999, "TestIndexExpression": 0.15622222222222223, "TestIx_": 0.08344444444444445, "TestNdIndex": 0.008666666666666668, "TestNdenumerate": 0.01, "TestRavelUnravelIndex": 1.3406666666666667}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.5765555555555556, "TestApplyOverAxes": 0.010222222222222221, "TestArraySplit": 1.1605555555555556, "TestColumnStack": 0.08355555555555555, "TestDsplit": 0.09166666666666666, "TestDstack": 0.14288888888888893, "TestExpandDims": 0.057888888888888886, "TestHsplit": 0.0898888888888889, "TestKron": 0.3222222222222223, "TestMayShareMemory": 0.11566666666666665, "TestPutAlongAxis": 0.09599999999999999, "TestSplit": 0.04455555555555555, "TestSqueeze": 0.439888888888889, "TestTakeAlongAxis": 0.7284444444444444, "TestTile": 0.26222222222222225, "TestVsplit": 0.07066666666666667}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.5405555555555556, "TestEye": 0.9376666666666665, "TestFliplr": 0.014777777777777779, "TestFlipud": 0.045000000000000005, "TestHistogram2d": 0.5611111111111111, "TestTri": 0.26744444444444443, "TestTrilIndicesFrom": 0.016888888888888887, "TestTriuIndices": 0.07622222222222223, "TestTriuIndicesFrom": 0.016, "TestVander": 0.11977777777777776}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.009222222222222222, "TestCommonType": 0.8273333333333334, "TestImag": 0.16122222222222224, "TestIscomplex": 0.050333333333333334, "TestIscomplexobj": 0.1287777777777778, "TestIsfinite": 0.3131111111111111, "TestIsinf": 0.268, "TestIsnan": 0.2986666666666667, "TestIsneginf": 0.06688888888888889, "TestIsposinf": 0.06777777777777778, "TestIsreal": 0.06811111111111111, "TestIsrealobj": 0.050333333333333334, "TestIsscalar": 0.10399999999999998, "TestMintypecode": 0.03522222222222223, "TestNanToNum": 0.40644444444444444, "TestReal": 0.16111111111111112, "TestRealIfClose": 0.21011111111111114}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 1.7614444444444446, "TestCond": 2.2257777777777776, "TestDet": 0.31088888888888894, "TestEig": 0.4223333333333334, "TestEigh": 0.2697777777777777, "TestEighCases": 0.0, "TestEigvals": 0.47288888888888897, "TestEigvalsh": 0.27644444444444444, "TestEigvalshCases": 0.0, "TestInv": 0.459888888888889, "TestLstsq": 3.438555555555556, "TestMatrixRank": 0.429, "TestMisc": 0.18555555555555556, "TestMisc2": 0.037666666666666675, "TestMultiDot": 0.48833333333333345, "TestNormDouble": 1.6885555555555554, "TestNormInt64": 1.7085555555555556, "TestNormSingle": 1.7394444444444443, "TestNorm_NonSystematic": 0.024111111111111114, "TestPinv": 1.1955555555555557, "TestPinvHermitian": 0.29377777777777775, "TestQR": 3.2038888888888892, "TestSVD": 0.5716666666666668, "TestSVDHermitian": 0.4385555555555556, "TestSolve": 1.2456666666666667, "TestTensorinv": 0.17544444444444443, "TestTensorsolve": 0.11133333333333334}, "torch_np/test_basic": {"TestArrayToSequence": 0.11355555555555556, "TestCopyTo": 0.11622222222222223, "TestCtorNested": 0.030888888888888886, "TestDefaultDtype": 0.04733333333333334, "TestDivmod": 0.20066666666666666, "TestExport": 0.307, "TestMisc": 0.036111111111111115, "TestNormalizations": 0.09333333333333334, "TestOneArr": 4.947555555555543, "TestOneArrAndAxesTuple": 0.23744444444444443, "TestOneArrAndAxis": 2.799999999999996, "TestOneArrAndShape": 0.4348888888888889, "TestOneArrToScalar": 0.2806666666666666, "TestPythonArgsToArray": 0.19511111111111112, "TestSequenceOfArrays": 0.4005555555555557, "TestSequenceOfArraysToSingle": 0.214, "TestShapeLikeToArray": 0.07466666666666666, "TestSmokeNotImpl": 0.014222222222222221}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 1.8239999999999992}, "torch_np/test_dtype": {"TestConvertDType": 1.250333333333333}, "torch_np/test_function_base": {"TestAppend": 0.5347777777777777}, "torch_np/test_ndarray_methods": {"TestAmax": 0.07644444444444444, "TestAmin": 0.11955555555555554, "TestArgmax": 6.5376666666666665, "TestArgmaxArgminCommon": 7.09911111111111, "TestArgmin": 1.3913333333333335, "TestContains": 0.019666666666666666, "TestIndexing": 0.5852222222222222, "TestIter": 0.03733333333333333, "TestNoExtraMethods": 0.09233333333333332, "TestNonzero": 0.32855555555555555, "TestRavel": 0.016999999999999998, "TestReshape": 0.017777777777777778, "TestTranspose": 0.017111111111111108}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 16.72677777777768, "TestNEP50Table": 0.3493333333333335}, "torch_np/test_random": {"TestChoice": 0.0558888888888889, "TestNumpyGlobal": 0.023555555555555555, "TestScalarReturn": 1.0987777777777776, "TestShuffle": 0.24511111111111114}, "torch_np/test_reductions": {"TestAll": 0.14944444444444446, "TestAny": 0.12, "TestFlatnonzero": 0.4942222222222223, "TestGenericCumSumProd": 0.1937777777777778, "TestGenericReductions": 11.20322222222216, "TestMean": 0.1331111111111111, "TestSum": 0.9026666666666667}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.86, "TestIsScalar": 0.38922222222222236}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 14.524999999999993, "TestNdarrayDunderVsUfunc": 2.265444444444444, "TestUfuncDtypeKwd": 0.043444444444444445, "TestUnaryUfuncs": 1.2255555555555553}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 1.9074444444444438}}, "force_on_cpu": {"backends/xeon/test_launch": {"TestTorchrun": 0.003}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.9240000000000002}, "distributions/test_distributions": {"TestAgainstScipy": 2.338, "TestConstraints": 0.2855, "TestDistributionShapes": 0.3390000000000002, "TestDistributions": 67.44049999999999, "TestFunctors": 0.03, "TestJit": 18.587, "TestKL": 6.545499999999999, "TestLazyLogitsInitialization": 0.028499999999999998, "TestNumericalStability": 0.15100000000000005, "TestRsample": 1.573, "TestValidation": 0.679}, "export/test_converter": {"TestConverter": 6.628499999999999}, "export/test_db": {"ExampleTests": 0.019500000000000007}, "export/test_export": {"TestDynamismExpression": 1.0145, "TestExport": 0.033500000000000016, "TestExportCustomClass": 0.17500000000000002, "TestOneOffModelExportResult": 1.8080000000000003}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.47050000000000003}, "export/test_hop": {"TestHOPGeneric": 0.0085}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.16}, "export/test_pass_infra": {"TestPassInfra": 1.4255}, "export/test_passes": {"TestPasses": 20.280499999999996}, "export/test_schema": {"TestSchema": 0.552}, "export/test_serialize": {"TestDeserialize": 0.023500000000000007, "TestSaveLoad": 0.5704999999999999, "TestSchemaVersioning": 0.0545, "TestSerialize": 2.1295, "TestSerializeCustomClass": 0.1695}, "export/test_sparse": {"TestSparseProp": 115.015}, "export/test_tools": {"TestExportTools": 1.3215}, "export/test_torchbind": {"TestCompileTorchbind": 1.7770000000000006, "TestExportTorchbind": 3.2069999999999994, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.47750000000000004}, "export/test_unflatten": {"TestUnflatten": 4.955500000000001}, "export/test_verifier": {"TestVerifier": 1.576}, "functorch/test_aotdispatch": {"TestAOTAutograd": 20.392499999999988, "TestAOTAutogradWithDynamo": 22.143500000000003, "TestAOTDispatch": 0.8444999999999999, "TestAOTExport": 1.4885000000000002, "TestAOTModuleSimplified": 1.4325, "TestPartitioning": 1.6804999999999999}, "functorch/test_control_flow": {"TestControlFlow": 0.0055, "TestControlFlowTraced": 0.04850000000000003}, "functorch/test_dims": {"TestMin": 20.742, "TestMinFunctorchOnly": 19.195}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.20700000000000007, "TestSliceArgnums": 0.035}, "functorch/test_logging": {"TestAOTLogging": 0.542}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 1.2215, "RandomOpTestCase": 0.138, "ReduceTestCase": 0.17149999999999999, "TestMemoryEfficientOpAuthoring": 0.0055}, "functorch/test_minifier": {"TestMinifier": 0.8300000000000001}, "functorch/test_parsing": {"TestAnonymousAxis": 0.5115, "TestParsedExpression": 0.011, "TestParsingUtils": 0.012, "TestValidateRearrangeExpressions": 0.012}, "functorch/test_rearrange": {"TestRearrange": 0.5815000000000001}, "functorch/test_vmap": {"TestVmapAPI": 0.5540000000000003, "TestVmapOperators": 4.791499999999992}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 6.850999999999748}, "higher_order_ops/test_with_effects": {"TestWithEffects": 1.2695000000000003}, "lazy/test_debug_util": {"DebugUtilTest": 0.0015}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.573}, "lazy/test_generator": {"LazyGeneratorTest": 0.6074999999999999}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.003}, "lazy/test_step_closures": {"ClosuresTest": 3.4825}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.5125, "TestLazyTensor": 0.1395}, "nn/test_convolution": {"TestConvolutionNN": 30.475500000000004}, "nn/test_dropout": {"TestDropoutNN": 0.139}, "nn/test_embedding": {"TestEmbeddingNN": 0.13150000000000006}, "nn/test_init": {"TestNNInit": 240.67749999999992}, "nn/test_lazy_modules": {"TestLazyModules": 0.5900000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.137, "TestLoadStateDictSwap": 0.08050000000000002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.045, "TestModuleHookNN": 0.157, "TestModuleHooks": 0.15000000000000002, "TestStateDictHooks": 0.0555}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 9.7045}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.8315000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.4895}, "nn/test_pooling": {"TestAvgPool": 0.4625, "TestPoolingNN": 0.735}, "nn/test_pruning": {"TestPruningNN": 0.21850000000000008}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.41350000000000003}, "profiler/test_memory_profiler": {"TestDataFlow": 1.478, "TestIdentifyGradients": 0.3075, "TestMemoryProfiler": 0.491, "TestMemoryProfilerE2E": 5.8905}, "profiler/test_profiler": {"TestExperimentalUtils": 10.4575, "TestProfiler": 21.0245, "TestProfilerCUDA": 0.0015, "TestProfilerITT": 0.009000000000000001}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.6505000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.539}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.1754999999999995}, "test_ao_sparsity": {"TestActivationSparsifier": 0.1345, "TestBaseDataScheduler": 0.06, "TestBaseDataSparsifier": 0.1395, "TestBaseSparsifier": 0.05450000000000001, "TestBaseStructuredSparsifier": 2.8375000000000004, "TestComposability": 3.299, "TestCubicScheduler": 0.0075, "TestFPGMPruner": 0.0505, "TestFakeSparsity": 0.134, "TestFxComposability": 2.9485, "TestNearlyDiagonalSparsifier": 1.3170000000000002, "TestNormDataSparsifiers": 1.4049999999999998, "TestQuantizationUtils": 0.052000000000000005, "TestQuantizedSparseKernels": 0.483, "TestQuantizedSparseLayers": 0.3655, "TestSaliencyPruner": 0.0615, "TestScheduler": 0.025, "TestSparsityUtilFunctions": 0.0865, "TestWeightNormSparsifier": 0.4645}, "test_autocast": {"TestAutocastCPU": 3.28, "TestAutocastGPU": 0.002, "TestTorchAutocast": 0.014}, "test_autograd": {"TestAllowMutationOnSaved": 0.06000000000000001, "TestAutograd": 49.128000000000014, "TestAutogradComplex": 0.0115, "TestAutogradForwardMode": 0.15750000000000008, "TestAutogradForwardModeBatchedGrad": 0.031000000000000003, "TestAutogradFunctional": 15.432499999999985, "TestAutogradInferenceMode": 0.07350000000000002, "TestAutogradLogging": 0.036000000000000004, "TestMultithreadAutograd": 0.3295, "TestNestedCheckpoint": 0.6785000000000001, "TestSelectiveActivationCheckpoint": 0.028999999999999998}, "test_autograd_fallback": {"TestAutogradFallback": 0.6680000000000001}, "test_bundled_inputs": {"TestBundledInputs": 2.079999999999999}, "test_comparison_utils": {"TestComparisonUtils": 0.48350000000000004}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_cpp_api_parity": {"TestCppApiParity": 8.184000000000012}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.0475, "TestMAIATensor": 0.018000000000000002, "TestPybindTypeCasters": 0.0045000000000000005, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.0015}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.04700000000000001, "TestMAIATensor": 0.018000000000000002, "TestPybindTypeCasters": 0.0045000000000000005, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.0015}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 338.1355}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0075}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 23.981}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0015}, "test_custom_backend": {"TestCustomBackend": 0.15000000000000002}, "test_custom_ops": {"MiniOpTest": 1.0515000000000003, "MiniOpTestOther": 0.10600000000000004, "TestCustomOp": 22.456999999999997, "TestCustomOpAPI": 0.20050000000000007, "TestCustomOperators": 0.337, "TestGenerateOpcheckTests": 5.302}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.023, "TestConvAfterFork": 0.0015, "TestCustomPinFn": 0.003, "TestDataLoader": 360.31549999999993, "TestDataLoaderPersistentWorkers": 366.642, "TestDatasetRandomSplit": 0.064, "TestDictDataLoader": 5.372, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.006, "TestSetAffinity": 0.0015, "TestStackDataset": 0.05700000000000001, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.041999999999999996}, "test_datapipe": {"TestCaptureDataFrame": 0.0015, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.0105, "TestDataFramesPipes": 0.009000000000000001, "TestFunctionalIterDataPipe": 5.8495, "TestFunctionalMapDataPipe": 0.08399999999999999, "TestGraph": 0.028, "TestIterDataPipeCountSampleYielded": 0.0235, "TestIterDataPipeGraphFastForward": 0.0735, "TestIterDataPipeSingletonConstraint": 0.0425, "TestIterableDataPipeBasic": 0.0885, "TestSerialization": 0.003, "TestSharding": 11.194500000000001, "TestStreamWrapper": 0.48650000000000004, "TestTyping": 0.015000000000000003}, "test_decomp": {"HasDecompTest": 0.314}, "test_deploy": {"TestFreezer": 0.4625}, "test_dispatch": {"TestDispatch": 79.6545, "TestPythonDispatcher": 0.033}, "test_dynamic_shapes": {"TestDimConstraints": 4.455, "TestFloorDiv": 0.019500000000000003, "TestGuardsExpressions": 0.026000000000000002, "TestPySymInt": 2.986999999999998, "TestSymNumberMagicMethods": 3.6104999999999947}, "test_fake_tensor": {"FakeTensorConstHandling": 0.12600000000000003, "FakeTensorConverterTest": 0.05450000000000001, "FakeTensorDispatchCache": 0.14350000000000002, "FakeTensorOperatorInvariants": 0.6215, "FakeTensorPropTest": 0.119, "FakeTensorSerialization": 0.0105, "FakeTensorTest": 1.4400000000000004, "PropagateRealTensorsFakeTensorConstHandling": 0.18100000000000005, "PropagateRealTensorsFakeTensorConverterTest": 0.053000000000000005, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.35250000000000004, "PropagateRealTensorsFakeTensorPropTest": 0.0835, "PropagateRealTensorsFakeTensorTest": 0.5180000000000001}, "test_flop_counter": {"TestFlopCounter": 0.3480000000000001}, "test_function_schema": {"TestFunctionSchema": 1.0525}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 0.003}, "test_functional_optim": {"TestFunctionalOptimParity": 0.6765}, "test_functionalization": {"TestCrossRefFunctionalization": 3.637999999999999, "TestFunctionalization": 4.088}, "test_futures": {"TestFuture": 1.4480000000000002}, "test_fx": {"AnnotationsTest": 0.030000000000000006, "TestCSEPass": 0.5055000000000001, "TestCommonPass": 0.1235, "TestConstFold": 0.25250000000000006, "TestConstParamShapeInControlFlow": 0.068, "TestDCE": 0.0495, "TestFX": 10.023499999999975, "TestFXAPIBackwardCompatibility": 0.06, "TestFunctionalTracing": 0.6475000000000005, "TestMatcher": 0.119, "TestPassManager": 0.0455, "TestSourceMatcher": 2.9155, "TestSubgraphRewriter": 0.43600000000000017, "TypeCheckerTest": 0.4545000000000001}, "test_fx_experimental": {"TestFXExperimental": 2.8789999999999987, "TestTranslationValidation": 0.265}, "test_fx_passes": {"TestFXGraphPasses": 1.0900000000000003, "TestFXMatcherUtils": 0.14500000000000005}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.8065}, "test_import_stats": {"TestImportTime": 6.349}, "test_itt": {"TestItt": 0.477}, "test_jit": {"TestAliasAnalysis": 0.5485000000000001, "TestAsync": 0.5535000000000001, "TestAtenPow": 0.014, "TestAutodiffJit": 0.15350000000000003, "TestAutodiffSubgraphSlicing": 0.4910000000000002, "TestAwait": 0.31700000000000006, "TestBackends": 0.0045000000000000005, "TestBackendsWithCompiler": 0.003, "TestBatchMM": 0.127, "TestBuiltins": 0.0935, "TestClassType": 3.789999999999999, "TestComplex": 1.3130000000000002, "TestCustomOperators": 0.0775, "TestDCE": 0.028499999999999998, "TestDataParallel": 0.0075, "TestDataclasses": 7.167999999999999, "TestDeviceAnalysis": 0.24950000000000003, "TestDict": 0.6300000000000003, "TestDtypeAnalysis": 0.253, "TestEnum": 0.31450000000000006, "TestFreezing": 3.6779999999999995, "TestFrontend": 0.624, "TestFrozenOptimizations": 14.813000000000006, "TestFunctionalBlocks": 0.0105, "TestFunctionalToInplaceActivation": 0.156, "TestGenerator": 0.12, "TestGetDefaultAttr": 0.029, "TestGraphRewritePasses": 0.08299999999999999, "TestHash": 0.11999999999999998, "TestHooks": 1.0820000000000005, "TestIgnorableArgs": 0.019000000000000003, "TestIgnoreContextManager": 0.0045000000000000005, "TestInplaceToFunctionalActivation": 0.0775, "TestIsinstance": 0.3370000000000001, "TestJit": 9.311999999999994, "TestJitGeneratedModule": 21.304000000000062, "TestJitProfiler": 0.0015, "TestJitUtils": 0.03350000000000001, "TestList": 1.8245000000000007, "TestLogging": 0.07800000000000001, "TestMKLDNNReinplacing": 0.29400000000000004, "TestMisc": 0.2855000000000001, "TestMixTracingScripting": 2.0735, "TestModels": 2.2115, "TestModuleAPIs": 0.239, "TestModuleContainers": 1.8849999999999998, "TestModuleInterface": 0.9410000000000002, "TestModules": 0.0305, "TestNamedTuple": 0.11050000000000001, "TestNnapiBackend": 0.045000000000000026, "TestOpDecompositions": 0.0335, "TestOptimizeForMobilePreserveDebugInfo": 0.2775, "TestParametrization": 0.147, "TestPeephole": 0.7095000000000002, "TestProducerVersion": 0.004, "TestProfiler": 0.21200000000000008, "TestPythonBindings": 0.060000000000000005, "TestPythonBuiltinOP": 0.6295000000000002, "TestPythonIr": 0.0385, "TestRecursiveScript": 1.1095000000000004, "TestRemoveMutation": 0.18200000000000002, "TestSaveLoad": 0.7160000000000002, "TestSaveLoadFlatbuffer": 0.7875000000000001, "TestSaveLoadForOpVersion": 2.745, "TestScript": 58.466000000000015, "TestScriptDict": 0.050499999999999996, "TestScriptList": 1.2570000000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2395, "TestScriptProfile": 0.5609999999999999, "TestSlice": 0.23850000000000013, "TestSparse": 0.040999999999999995, "TestStringFormatting": 0.19000000000000006, "TestSymbolicShapeAnalysis": 2.339499999999999, "TestTensorBuiltins": 0.1175, "TestTensorCreationOps": 0.07150000000000001, "TestTensorMethods": 0.025, "TestTorchbind": 0.19000000000000009, "TestTracer": 4.576999999999997, "TestTypeSharing": 0.7135000000000002, "TestTypesAndAnnotation": 0.19200000000000003, "TestTyping": 0.5915000000000004, "TestUnion": 0.6990000000000003, "TestUnsupportedOps": 0.043, "TestUpgraders": 0.11450000000000002, "TestWarn": 0.08750000000000001, "TestWith": 0.5}, "test_jit_autocast": {"TestAutocast": 0.23300000000000004, "TestJitTraceAutocast": 16.019499999999997}, "test_jit_disabled": {"TestJitDisabled": 0.8654999999999999}, "test_jit_fuser_te": {"TestFuserCommon": 0.1265, "TestTEFuserDynamic": 249.5925000000001, "TestTEFuserStatic": 236.579}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0015, "TestEnableDisableLlgaFuser": 0.0015, "TestModel": 0.05000000000000003}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.933499999999998, "TestVmapOperatorsLegacy": 1.7489999999999997}, "test_license": {"TestLicense": 0.003}, "test_logging": {"LoggingTest": 3.5700000000000003}, "test_maskedtensor": {"TestBinary": 0.6345000000000005, "TestReductions": 0.12550000000000003, "TestUnary": 0.7245000000000006}, "test_meta": {"TestMetaConverter": 0.11200000000000004}, "test_mkl_verbose": {"TestMKLVerbose": 6.750500000000001}, "test_mkldnn_fusion": {"TestMkldnnFusion": 294.697}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 6.927}, "test_mobile_optimizer": {"TestOptimizer": 1.4445}, "test_model_dump": {"TestModelDump": 0.7100000000000001}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.0015}, "test_module_tracker": {"TestModuleTracker": 0.492}, "test_monitor": {"TestMonitor": 0.5055000000000001, "TestMonitorTensorboard": 0.6785}, "test_multiprocessing": {"TestMultiprocessing": 946.8289999999998}, "test_multiprocessing_spawn": {"ErrorTest": 0.0035, "ForkTest": 0.005, "SpawnTest": 47.66700000000001}, "test_namedtensor": {"TestNamedTensor": 0.7150000000000003}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 3.205}, "test_native_functions": {"TestNativeFunctions": 0.6880000000000002}, "test_nestedtensor": {"TestNestedTensor": 0.2825000000000002}, "test_nn": {"TestAddRelu": 0.0085, "TestConstantPadNd": 0.0075, "TestFunctionalPickle": 0.004, "TestFusionEval": 0.522, "TestFusionUtils": 0.011, "TestNN": 78.44450000000003, "TestUtils": 0.008}, "test_numba_integration": {"TestNumbaIntegration": 0.012}, "test_openmp": {"TestOpenMP_ParallelFor": 6.733499999999999}, "test_ops": {"TestSelfKwarg": 0.0075}, "test_optim": {"TestDifferentiableOptimizer": 0.315, "TestLRScheduler": 1.6529999999999982, "TestSWAUtils": 0.26999999999999996}, "test_out_dtype_op": {"TestOutDtypeOp": 0.8190000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.0045000000000000005, "TestDisabledTorchFunction": 0.0045000000000000005, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.006, "TestGradCheckOverride": 0.0315, "TestGradNewOnesOverride": 0.0035, "TestIndexing": 0.016, "TestIterator": 0.003, "TestNamedTuple": 0.0045000000000000005, "TestPickle": 0.0045000000000000005, "TestRNN": 0.006, "TestResolveName": 0.1545, "TestTorchFunctionMode": 0.08100000000000004, "TestTorchFunctionOverride": 4.79099999999981, "TestTorchFunctionWarning": 0.0195, "TestWrapTorchFunction": 0.0035}, "test_package": {"DirectoryReaderTest": 0.012, "ModelTest": 0.0045000000000000005, "TestAnalyze": 0.45399999999999996, "TestDependencyAPI": 0.09600000000000004, "TestDependencyHooks": 0.0225, "TestDiGraph": 0.04000000000000001, "TestGlobGroup": 0.05800000000000001, "TestImporter": 0.025, "TestLoadBCPackages": 0.10949999999999999, "TestMangling": 0.04, "TestMisc": 0.08000000000000002, "TestPackageFX": 0.0995, "TestPackageScript": 0.5515000000000001, "TestRepackage": 0.018000000000000002, "TestResources": 0.025, "TestSaveLoad": 0.07450000000000001}, "test_per_overload_api": {"TestPerOverloadAPI": 0.478}, "test_prims": {"TestPrimsBasic": 0.024}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.21550000000000002, "TestGenericProxyTensorFake": 1.0385000000000004, "TestGenericProxyTensorReal": 0.9445000000000003, "TestGenericProxyTensorSymbolic": 1.4769999999999999, "TestRealProxyTensor": 0.037, "TestSymbolicTracing": 3.940499999999998}, "test_pruning_op": {"PruningOpTest": 0.718}, "test_public_bindings": {"TestPublicBindings": 0.489}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.009000000000000001, "TestPythonDispatch": 7.3955, "TestPythonDispatcher": 0.013500000000000002, "TestPythonRegistration": 0.385}, "test_pytree": {"TestCxxPytree": 0.02250000000000001, "TestGenericPytree": 0.7060000000000002, "TestPythonPytree": 0.12450000000000006}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.035, "TestAOMigrationNNQuantized": 0.07250000000000001, "TestAOMigrationQuantization": 0.04100000000000001, "TestAOMigrationQuantizationFx": 0.0565, "TestBackendConfig": 0.12400000000000004, "TestBiasCorrectionEager": 1.4329999999999998, "TestComparatorOps": 2.1915, "TestDeprecatedJitQuantized": 6.743499999999999, "TestDistributed": 0.049999999999999996, "TestDuplicateDQPass": 0.006, "TestDynamicQuantizedModule": 24.0165, "TestDynamicQuantizedOps": 9.1625, "TestEqualizeEager": 0.178, "TestEqualizeFx": 6.8795, "TestFXGraphMatcher": 2.8845, "TestFXGraphMatcherModels": 0.003, "TestFXNumericSuiteCoreAPIs": 44.671, "TestFXNumericSuiteCoreAPIsModels": 34.3795, "TestFXNumericSuiteNShadows": 0.03600000000000002, "TestFakeQuantize": 0.48450000000000004, "TestFakeQuantizeOps": 3.285999999999999, "TestFuseEager": 3.7935, "TestFuseFx": 3.3184999999999993, "TestFusedObsFakeQuant": 0.14650000000000002, "TestFusedObsFakeQuantModule": 0.34049999999999997, "TestFusionPasses": 0.045, "TestFxDetectInputWeightEqualization": 0.26, "TestFxDetectOutliers": 0.444, "TestFxModelReportClass": 0.7170000000000001, "TestFxModelReportDetectDynamicStatic": 0.0955, "TestFxModelReportDetector": 0.1265, "TestFxModelReportObserver": 0.33649999999999997, "TestFxModelReportVisualizer": 0.381, "TestGenerateNumericDebugHandle": 0.003, "TestGraphUtils": 0.0045000000000000005, "TestHistogramObserver": 64.95100000000001, "TestMetaDataPorting": 0.0105, "TestModelNumericsEager": 0.775, "TestNumericSuiteEager": 7.301, "TestObserver": 6.5335, "TestPT2ERepresentation": 0.012, "TestPadding": 17.932000000000002, "TestQNNPackOps": 0.018000000000000006, "TestQuantizationDocs": 0.6445, "TestQuantizeDynamicJitOps": 2.7335000000000003, "TestQuantizeDynamicJitPasses": 6.045999999999999, "TestQuantizeEagerOps": 2.549, "TestQuantizeEagerPTQDynamic": 14.778999999999998, "TestQuantizeEagerPTQStatic": 28.439500000000002, "TestQuantizeEagerQAT": 7.8055, "TestQuantizeEagerQATNumerics": 3.101, "TestQuantizeFx": 46.64949999999999, "TestQuantizeFxModels": 3.908499999999999, "TestQuantizeFxOps": 166.50550000000004, "TestQuantizeJit": 22.2185, "TestQuantizeJitOps": 276.4025, "TestQuantizeJitPasses": 9.015, "TestQuantizePT2E": 0.06050000000000004, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 0.025500000000000012, "TestQuantizePT2EQAT_ConvBn2d": 0.025500000000000012, "TestQuantizePT2EX86Inductor": 0.04650000000000003, "TestQuantizedConv": 32.386, "TestQuantizedEmbeddingOps": 1.38, "TestQuantizedFunctionalOps": 1.123, "TestQuantizedLinear": 23.830000000000002, "TestQuantizedOps": 167.87350000000006, "TestQuantizedTensor": 3.736499999999999, "TestRecordHistogramObserver": 0.068, "TestReferenceQuantizedModule": 0.092, "TestSerialization": 1.795, "TestStaticQuantizedModule": 76.8565, "TestSubgraphRewriter": 0.9850000000000002, "TestUtils": 0.0445, "TestXNNPACKQuantizer": 0.03750000000000002, "TestXNNPACKQuantizerModels": 0.0015}, "test_schema_check": {"TestSchemaCheck": 0.27400000000000013}, "test_serialization": {"TestOldSerialization": 61.14099999999999, "TestSerialization": 14.007999999999996, "TestSubclassSerialization": 0.0485}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.46599999999999997}, "test_show_pickle": {"TestShowPickle": 0.0015}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.037500000000000006, "TestSparseMeta": 6.251, "TestSparseOneOff": 0.003}, "test_sparse_csr": {"TestSparseCSRSampler": 0.8375}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_stateless": {"TestPythonOptimizeMode": 8.36, "TestStatelessDeprecation": 3.1075, "TestStatelessFunctionalAPI": 0.4790000000000001}, "test_subclass": {"TestSubclass": 0.8105000000000002}, "test_sympy_utils": {"TestSingletonInt": 0.009000000000000001, "TestSympyInterp": 13.488, "TestSympySolve": 0.30950000000000005, "TestValueRanges": 10.368499999999997}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0345, "TestTensorBoardFigure": 0.003, "TestTensorBoardNumpy": 0.012, "TestTensorBoardPyTorchNumpy": 0.379, "TestTensorBoardPytorchGraph": 0.5335000000000001, "TestTensorBoardSummary": 0.08300000000000003, "TestTensorBoardSummaryWriter": 0.0225, "TestTensorBoardUtils": 0.3015, "TestTensorBoardWriter": 0.5055000000000001, "TestTensorProtoSummary": 0.029500000000000002}, "test_tensorexpr": {"TestTensorExprFuser": 46.445499999999996}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.018000000000000002, "TestTensorExprPyBind": 0.506}, "test_testing": {"TestAssertClose": 0.23400000000000012, "TestAssertCloseContainer": 0.017, "TestAssertCloseErrorMessage": 0.11500000000000002, "TestAssertCloseQuantized": 0.024, "TestAssertCloseSparseBSC": 0.028500000000000004, "TestAssertCloseSparseBSR": 0.0375, "TestAssertCloseSparseCOO": 0.056, "TestAssertCloseSparseCSC": 0.0455, "TestAssertCloseSparseCSR": 0.044500000000000005, "TestFrameworkUtils": 0.0015, "TestImports": 8.742999999999999, "TestOpInfos": 0.009000000000000001, "TestTestParametrization": 0.09050000000000004}, "test_torch": {"TestBasicVitalSigns": 0.03, "TestTorch": 6.825999999999983}, "test_type_hints": {"TestTypeHints": 0.0015}, "test_type_info": {"TestDTypeInfo": 0.48450000000000004}, "test_typing": {"TestTyping": 0.008}, "test_utils": {"TestAssert": 0.11199999999999999, "TestBottleneck": 26.0725, "TestCheckpoint": 0.13400000000000004, "TestCollectEnv": 5.2715, "TestCppExtensionUtils": 0.008, "TestDataLoaderUtils": 23.4485, "TestExtensionUtils": 0.01, "TestHipify": 0.003, "TestHipifyTrie": 0.012, "TestONNXUtils": 0.009000000000000001, "TestRenderUtils": 0.024, "TestStandaloneCPPJIT": 19.5375, "TestTraceback": 0.023}, "test_vulkan": {"TestVulkanRewritePass": 0.0015}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.031, "WeakKeyDictionaryTestCase": 0.0465, "WeakTest": 5.8084999999999996}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 4.757, "TestXNNPACKRewritePass": 2.222, "TestXNNPACKSerDes": 6.2204999999999995}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.017}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.5395000000000001, "TestClassGetItem": 0.0045000000000000005, "TestDtypeAttributeDeletion": 0.001, "TestFromDTypeAttribute": 0.0055, "TestMisc": 0.0075, "TestPickling": 0.18000000000000005, "TestPromotion": 0.0075}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 22.4185, "TestEinsumPath": 0.0055, "TestMisc": 0.010499999999999999}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0005, "TestFinfo": 0.003, "TestHalf": 0.0015, "TestIinfo": 0.49250000000000005, "TestMisc": 0.0075, "TestPythonFloat": 0.0015, "TestRepr": 0.006, "TestSingle": 0.0015}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.005, "TestBooleanIndexing": 0.014, "TestBroadcastedAssignments": 0.0385, "TestFancyIndexingCast": 0.007, "TestFloatNonIntegerArgument": 0.020000000000000004, "TestIndexing": 0.7165000000000002, "TestMultiIndexingAutomated": 0.015500000000000002, "TestMultipleEllipsisError": 0.005, "TestNonIntegerArrayLike": 0.0015}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.045500000000000006, "TestArgmax": 1.9205000000000005, "TestArgmaxArgminCommon": 0.3085000000000002, "TestArgmin": 1.9605000000000004, "TestArrayAttributeDeletion": 0.015, "TestArrayConstruction": 0.07800000000000001, "TestArrayCreationCopyArgument": 0.029000000000000015, "TestAssignment": 0.020500000000000004, "TestAttributes": 0.031000000000000007, "TestBinop": 0.0305, "TestBool": 34.4315, "TestCequenceMethods": 0.005, "TestChoose": 0.037000000000000005, "TestClip": 0.012, "TestCompress": 0.0105, "TestConversion": 0.051500000000000004, "TestCreation": 0.006, "TestDelMisc": 0.003, "TestDot": 0.12000000000000006, "TestDtypedescr": 0.004, "TestFancyIndexing": 0.0635, "TestFlag": 0.019500000000000003, "TestFormat": 0.0105, "TestFromBuffer": 0.028500000000000004, "TestHash": 0.46299999999999997, "TestHashing": 0.006, "TestIO": 0.012, "TestInner": 0.30400000000000005, "TestLexsort": 0.0465, "TestMatmul": 0.6135000000000002, "TestMatmulOperator": 0.428, "TestMethods": 2.1970000000000005, "TestMinMax": 0.0105, "TestMinScalarType": 0.02, "TestNewaxis": 0.0075, "TestPEP3118Dtype": 0.015000000000000003, "TestPutmask": 0.026500000000000003, "TestRepeat": 0.025500000000000002, "TestResize": 0.07150000000000001, "TestRichcompareScalar": 0.0015, "TestScalarIndexing": 0.029000000000000005, "TestSortFloatMisc": 0.248, "TestStats": 0.391, "TestSubscripting": 0.0055, "TestTake": 0.060500000000000005, "TestVdot": 0.05750000000000001, "TestWarnings": 0.006, "TestWhere": 0.5265, "TestWritebackIfCopy": 0.068}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.034, "TestArgwhere": 0.0575, "TestArrayComparisons": 0.022500000000000003, "TestBaseRepr": 0.012, "TestBinaryRepr": 0.018000000000000002, "TestBoolArray": 3.9225, "TestBoolCmp": 0.2415, "TestBoolScalar": 0.021, "TestBroadcast": 0.013500000000000002, "TestClip": 0.32750000000000024, "TestConvolve": 0.035500000000000004, "TestCorrelate": 0.062000000000000006, "TestCreationFuncs": 1.4875, "TestCross": 0.07550000000000001, "TestDtypePositional": 0.005, "TestFloatExceptions": 0.02, "TestFromiter": 0.0025, "TestIndex": 0.0115, "TestIndices": 0.069, "TestIsclose": 0.12500000000000003, "TestIsscalar": 0.0045000000000000005, "TestLikeFuncs": 0.003, "TestMoveaxis": 0.02, "TestNonarrayArgs": 0.1980000000000001, "TestNonzeroAndCountNonzero": 0.36200000000000004, "TestOuterMisc": 0.009000000000000001, "TestRequire": 0.013500000000000002, "TestResize": 0.5095000000000001, "TestRoll": 0.0635, "TestRollaxis": 0.0105, "TestSeterr": 0.0145, "TestStdVar": 0.0455, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.005, "TestTensordot": 0.028499999999999998, "TestTypes": 0.028499999999999998}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.003, "TestCommonType": 0.487, "TestDocStrings": 0.0015, "TestIsSubDType": 0.018500000000000003, "TestScalarTypeNames": 0.06300000000000003}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.1845000000000001, "TestFromInt": 0.013500000000000002, "TestFromString": 0.4685}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.01, "TestBitCount": 0.004, "TestClassGetItem": 0.015000000000000005, "TestClassGetitemMisc": 0.0045000000000000005, "TestIsInteger": 0.014}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.003}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.15, "TestBaseMath": 13.603, "TestBitShifts": 0.14100000000000001, "TestComplexDivision": 0.11200000000000002, "TestConversion": 0.0925, "TestHash": 0.0045000000000000005, "TestModulus": 1.4885000000000002, "TestMultiply": 0.0005, "TestNegative": 0.0295, "TestPower": 0.187, "TestRepr": 0.0035, "TestScalarOpsMisc": 0.12500000000000006, "TestScalarSubclassingMisc": 0.11700000000000008, "TestSubtract": 0.03, "TestTypes": 21.991999999999997}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.5680000000000001, "TestAtleast2d": 0.0295, "TestAtleast3d": 0.028, "TestBlock": 0.07150000000000004, "TestConcatenate": 0.2775000000000002, "TestHstack": 0.036, "TestStackMisc": 0.031500000000000014, "TestVstack": 0.043000000000000003}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.015, "TestFFTShift": 8.782499999999999, "TestIRFFTN": 0.0075, "TestRFFTFreq": 0.015}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 4.5625, "TestFFTShift": 0.45699999999999996, "TestFFTThreadSafe": 1.0265}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.517}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.015500000000000002, "TestUnique": 0.6935}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.013500000000000002, "TestAmax": 0.0105, "TestAmin": 0.01, "TestAngle": 0.012, "TestAny": 0.014000000000000002, "TestAverage": 0.044000000000000004, "TestBincount": 0.08299999999999999, "TestCheckFinite": 0.006, "TestCopy": 0.014000000000000002, "TestCorrCoef": 0.0645, "TestCov": 0.10400000000000001, "TestCumprod": 0.043500000000000004, "TestCumsum": 0.0595, "TestDelete": 0.0315, "TestDiff": 0.1335, "TestDigitize": 0.036000000000000004, "TestExtins": 0.0145, "TestFilterwindows": 0.9940000000000007, "TestFlip": 0.063, "TestGradient": 0.23450000000000004, "TestInsert": 0.021000000000000005, "TestInterp": 0.11600000000000006, "TestKaiser": 0.0195, "TestMedian": 0.18150000000000005, "TestMeshgrid": 0.099, "TestMsort": 0.0015, "TestPercentile": 0.30700000000000016, "TestPiecewise": 0.0265, "TestProd": 0.042, "TestPtp": 0.014499999999999999, "TestQuantile": 0.12850000000000006, "TestRot90": 0.6014999999999999, "TestSelect": 0.021, "TestSinc": 0.013500000000000002, "TestSortComplex": 0.024, "TestTrapz": 0.0105, "TestTrimZeros": 0.031, "TestUnique": 0.009000000000000001, "Test_I0": 0.0255}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.7335000000000003, "TestHistogramOptimBinNums": 0.06300000000000003, "TestHistogramdd": 0.24650000000000005}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.003, "TestConcatenator": 0.0205, "TestDiagIndices": 0.008, "TestDiagIndicesFrom": 0.013500000000000002, "TestFillDiagonal": 0.043500000000000004, "TestGrid": 0.025500000000000002, "TestIndexExpression": 0.017, "TestIx_": 0.015, "TestNdIndex": 0.003, "TestNdenumerate": 0.003, "TestRavelUnravelIndex": 0.497}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.03200000000000001, "TestApplyOverAxes": 0.0045000000000000005, "TestArraySplit": 0.23450000000000004, "TestColumnStack": 0.018000000000000002, "TestDsplit": 0.02, "TestDstack": 0.030000000000000006, "TestExpandDims": 0.014000000000000002, "TestHsplit": 0.021, "TestKron": 0.02650000000000001, "TestMayShareMemory": 0.0045000000000000005, "TestPutAlongAxis": 0.0185, "TestSplit": 0.0115, "TestSqueeze": 0.04350000000000001, "TestTakeAlongAxis": 0.555, "TestTile": 0.11850000000000002, "TestVsplit": 0.0165}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.0495, "TestEye": 0.536, "TestFliplr": 0.009000000000000001, "TestFlipud": 0.009000000000000001, "TestHistogram2d": 0.06100000000000001, "TestTri": 0.1395, "TestTrilIndicesFrom": 0.005, "TestTriuIndices": 0.007, "TestTriuIndicesFrom": 0.0055, "TestVander": 0.0355}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.003, "TestCommonType": 0.4565, "TestImag": 0.019500000000000003, "TestIscomplex": 0.0105, "TestIscomplexobj": 0.009000000000000001, "TestIsfinite": 0.0305, "TestIsinf": 0.028499999999999998, "TestIsnan": 0.0305, "TestIsneginf": 0.0045000000000000005, "TestIsposinf": 0.0045000000000000005, "TestIsreal": 0.015, "TestIsrealobj": 0.003, "TestIsscalar": 0.0035, "TestMintypecode": 0.012, "TestNanToNum": 0.029000000000000005, "TestReal": 0.02, "TestRealIfClose": 0.0075}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.3165, "TestCond": 0.3135, "TestDet": 0.22450000000000003, "TestEig": 0.06150000000000001, "TestEigh": 0.043500000000000004, "TestEighCases": 0.0005, "TestEigvals": 0.12100000000000002, "TestEigvalsh": 0.0445, "TestEigvalshCases": 0.0, "TestInv": 0.07700000000000001, "TestLstsq": 0.32500000000000007, "TestMatrixRank": 0.5455000000000001, "TestMisc": 0.0205, "TestMisc2": 0.008, "TestMultiDot": 0.11650000000000002, "TestNormDouble": 1.1265, "TestNormInt64": 1.1155, "TestNormSingle": 1.1280000000000001, "TestNorm_NonSystematic": 0.006500000000000001, "TestPinv": 0.1705, "TestPinvHermitian": 0.0635, "TestQR": 6.745000000000001, "TestSVD": 0.08450000000000002, "TestSVDHermitian": 0.14300000000000002, "TestSolve": 0.5465, "TestTensorinv": 0.05299999999999999, "TestTensorsolve": 0.036000000000000004}, "torch_np/test_basic": {"TestArrayToSequence": 0.018000000000000002, "TestCopyTo": 0.0145, "TestCtorNested": 0.006, "TestDefaultDtype": 0.015000000000000001, "TestDivmod": 0.0295, "TestExport": 0.0005, "TestMisc": 0.0045000000000000005, "TestNormalizations": 0.0105, "TestOneArr": 0.7170000000000005, "TestOneArrAndAxesTuple": 0.027000000000000003, "TestOneArrAndAxis": 0.41100000000000025, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.030000000000000006, "TestPythonArgsToArray": 0.035, "TestSequenceOfArrays": 0.04800000000000002, "TestSequenceOfArraysToSingle": 0.0235, "TestShapeLikeToArray": 0.012, "TestSmokeNotImpl": 0.0035}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.6075000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.4735000000000001}, "torch_np/test_function_base": {"TestAppend": 0.47250000000000003}, "torch_np/test_ndarray_methods": {"TestAmax": 0.012, "TestAmin": 0.012, "TestArgmax": 1.6710000000000007, "TestArgmaxArgminCommon": 2.2984999999999935, "TestArgmin": 1.8715000000000006, "TestContains": 0.0045000000000000005, "TestIndexing": 0.499, "TestIter": 0.009000000000000001, "TestNoExtraMethods": 0.018000000000000002, "TestNonzero": 0.21500000000000002, "TestRavel": 0.015, "TestReshape": 0.012, "TestTranspose": 0.02}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.6255000000000004, "TestNEP50Table": 0.0075}, "torch_np/test_random": {"TestChoice": 0.018000000000000002, "TestNumpyGlobal": 0.0075, "TestScalarReturn": 0.5680000000000001, "TestShuffle": 0.029000000000000005}, "torch_np/test_reductions": {"TestAll": 0.0215, "TestAny": 0.021, "TestFlatnonzero": 0.5055, "TestGenericCumSumProd": 0.039, "TestGenericReductions": 4.093999999999952, "TestMean": 0.036, "TestSum": 0.3305}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.5195000000000001, "TestIsScalar": 0.06100000000000003}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 1.2805000000000009, "TestNdarrayDunderVsUfunc": 0.32250000000000023, "TestUfuncDtypeKwd": 0.0105, "TestUnaryUfuncs": 0.5635000000000001}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.6730000000000003}}, "inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 10.927666666666667}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardCollectiveOps": 78.19616666666667, "TestFullyShardCommunication": 17.550833333333333, "TestFullyShardPrefetch": 30.249000000000006, "TestFullyShardUnshardMultiProcess": 8.446, "TestFullyShardUnshardMultiThread": 0.020833333333333332}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 30.30716666666667}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 20.287166666666668}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 2.2986666666666666, "TestFullyShard1DTrainingCore": 126.371, "TestFullyShard2DTraining": 4.631, "TestFullyShardGradientAccumulation": 20.366333333333333, "TestFullyShardHSDPTraining": 2.315}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 15.170666666666667, "TestDTensorCompileE2E": 37.291333333333334}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 25.480833333333333}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 45.21383333333333, "TestNew2dParallelTraining": 32.25816666666667}, "distributed/test_c10d_functional_native": {"CompileTest": 116.07600000000001, "TestWithNCCL": 40.095166666666664}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 15.604833333333334, "TestMultiProc": 97.54866666666668, "TestSingleProc": 20.174666666666663}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 3.2133333333333334, "TestCollectivesMultiProc": 95.39466666666665}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 665.8081666666664, "AOTInductorTestABICompatibleCpuWithStackAllocation": 466.0738333333329, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 206.16883333333328, "AOTInductorTestABICompatibleCuda": 1443.1889999999994, "AOTInductorTestNonABICompatibleCpu": 1433.7516666666659, "AOTInductorTestNonABICompatibleCuda": 2259.352666666667}, "inductor/test_torchinductor": {"CpuTests": 1480.831, "GPUTests": 1281.4315000000004, "NanCheckerTest": 1.5813333333333333, "RNNTest": 1.8105000000000002, "SweepInputsCpuTest": 111.00949999999999, "SweepInputsGPUTest": 39.16816666666667, "TestFull": 10.713333333333333, "TritonCodeGenTests": 40.621500000000005}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 16662.409166666712}, "test_modules": {"TestModuleCUDA": 1202.723166666666}, "test_ops": {"TestCommonCUDA": 976.9911666664719, "TestCompositeComplianceCUDA": 812.5954999999943, "TestFakeTensorCUDA": 673.4958333333282, "TestMathBitsCUDA": 85.53350000000046, "TestSelfKwarg": 1.1228333333333333, "TestTagsCUDA": 2.4306666666666596}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1577.728833333258}, "test_torch": {"TestBasicVitalSigns": 0.23133333333333336, "TestDevicePrecisionCUDA": 42.481, "TestTorch": 259.48133333333294, "TestTorchDeviceTypeCUDA": 2208.122166666666, "TestVitalSignsCudaCUDA": 0.44349999999999995}}, "inductor-halide": {"inductor/test_halide": {"HalideTests": 1.8415}}, "inductor_cpp_wrapper_abi_compatible": {"inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 378.2260000000001, "TestCppWrapper": 368.59500000000014}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 456.87649999999996, "TestCudaWrapper": 428.40399999999994}}, "inductor_distributed": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 10.721499999999999}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardCollectiveOps": 89.5205, "TestFullyShardCommunication": 10.626999999999999, "TestFullyShardPrefetch": 25.903, "TestFullyShardUnshardMultiProcess": 4.3095, "TestFullyShardUnshardMultiThread": 0.016}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 25.994999999999997}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 17.564}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 39.721000000000004, "TestFullyShard1DTrainingCore": 55.908, "TestFullyShard2DTraining": 26.770000000000003, "TestFullyShardGradientAccumulation": 28.759999999999998, "TestFullyShardHSDPTraining": 14.337}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 9.1675, "TestDTensorCompileE2E": 23.610499999999995}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 24.756}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 39.5415, "TestNew2dParallelTraining": 26.564}, "distributed/test_c10d_functional_native": {"CompileTest": 114.44049999999999, "TestWithNCCL": 50.257000000000005}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 18.220000000000002, "TestMultiProc": 188.86450000000002, "TestSingleProc": 12.945}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.9150000000000005, "TestCollectivesMultiProc": 86.64550000000001}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.008, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.008, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.008, "AOTInductorTestABICompatibleCuda": 17.9375, "AOTInductorTestNonABICompatibleCpu": 0.007, "AOTInductorTestNonABICompatibleCuda": 33.767500000000005}, "inductor/test_torchinductor": {"CpuTests": 3.9495, "GPUTests": 2.6719999999999997}}, "jit_legacy": {"test_jit_fuser_legacy": {"TestFuser": 0.007388888888888889}, "test_jit_legacy": {"TestAliasAnalysis": 0.4282222222222223, "TestAsync": 0.4367222222222223, "TestAtenPow": 0.010333333333333333, "TestAutodiffJit": 0.06272222222222222, "TestAutodiffSubgraphSlicing": 0.323888888888889, "TestAwait": 0.2671666666666667, "TestBackends": 0.9266666666666666, "TestBackendsWithCompiler": 0.1873888888888889, "TestBatchMM": 0.10899999999999999, "TestBuiltins": 0.07416666666666667, "TestCUDA": 1.153, "TestClassType": 2.725055555555555, "TestComplex": 1.0526111111111114, "TestCustomOperators": 0.05238888888888891, "TestDCE": 0.02461111111111111, "TestDataParallel": 0.005444444444444444, "TestDataclasses": 4.720222222222222, "TestDeviceAnalysis": 0.19777777777777775, "TestDict": 0.5126666666666669, "TestDtypeAnalysis": 0.2016111111111111, "TestDtypeCustomRulesCPU": 1.5823333333333318, "TestEnum": 0.23783333333333334, "TestFreezing": 2.7271666666666667, "TestFrontend": 0.4521111111111111, "TestFrozenOptimizations": 10.8795, "TestFunctionalBlocks": 0.008, "TestFunctionalToInplaceActivation": 0.14155555555555555, "TestGenerator": 0.0655, "TestGetDefaultAttr": 0.020444444444444442, "TestGraphRewritePasses": 0.04988888888888889, "TestHash": 0.09061111111111113, "TestHooks": 0.8340555555555559, "TestIgnorableArgs": 0.01311111111111111, "TestIgnoreContextManager": 0.052333333333333336, "TestInplaceToFunctionalActivation": 0.06894444444444446, "TestIsinstance": 0.24422222222222234, "TestJit": 7.202055555555549, "TestJitGeneratedModule": 14.383499999999984, "TestJitProfiler": 0.0013333333333333333, "TestJitUtils": 0.02155555555555556, "TestList": 1.6768333333333338, "TestLogging": 0.06233333333333333, "TestMKLDNNReinplacing": 0.005333333333333333, "TestMisc": 0.21011111111111114, "TestMixTracingScripting": 1.5539444444444444, "TestModels": 4.231555555555555, "TestModuleAPIs": 0.16355555555555554, "TestModuleContainers": 1.5113333333333336, "TestModuleInterface": 0.59, "TestModules": 0.01761111111111111, "TestNamedTuple": 0.08666666666666667, "TestNnapiBackend": 8.200388888888888, "TestOpDecompositions": 0.022277777777777775, "TestOptimizeForMobilePreserveDebugInfo": 0.2046666666666667, "TestParametrization": 0.11661111111111112, "TestPeephole": 0.5506666666666669, "TestProducerVersion": 0.0023333333333333335, "TestProfiler": 0.7096111111111112, "TestPythonBindings": 0.03755555555555556, "TestPythonBuiltinOP": 0.44722222222222224, "TestPythonIr": 0.02888888888888889, "TestRecursiveScript": 0.8643888888888892, "TestRemoveMutation": 0.15583333333333335, "TestSaveLoad": 0.5697777777777778, "TestSaveLoadFlatbuffer": 0.6024444444444444, "TestSaveLoadForOpVersion": 2.970833333333333, "TestScript": 49.681611111111145, "TestScriptDict": 0.03266666666666667, "TestScriptList": 0.9962222222222223, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2004444444444445, "TestScriptProfile": 0.4922777777777778, "TestSlice": 0.17766666666666675, "TestSparse": 0.058444444444444445, "TestStringFormatting": 0.14172222222222228, "TestSymbolicShapeAnalysis": 1.5104999999999995, "TestTensorBuiltins": 0.11644444444444446, "TestTensorCreationOps": 0.053, "TestTensorMethods": 0.013555555555555557, "TestTorchbind": 0.1852222222222223, "TestTracer": 11.869499999999995, "TestTypeSharing": 0.6066666666666668, "TestTypesAndAnnotation": 0.14355555555555558, "TestTyping": 0.44488888888888906, "TestUnion": 0.511777777777778, "TestUnsupportedOps": 0.03777777777777778, "TestUpgraders": 0.08455555555555556, "TestWarn": 0.06322222222222222, "TestWith": 0.5515555555555556}}, "mps": {"test_metal": {"TestMetalRewritePass": 1.1053333333333333}, "test_modules": {"TestModuleCPU": 665.3843333333233, "TestModuleMPS": 474.1086666666783}, "test_mps": {"MPSLeakyReluTest": 0.3606666666666667, "MPSReluTest": 0.22533333333333336, "MatmulTest": 0.2693333333333333, "TestAdvancedIndexing": 14.111333333333329, "TestAvgPool": 0.081, "TestCommonMPS": 16.227000000000004, "TestComplex": 3.1136666666666666, "TestConsistencyCPU": 1911.8689999999942, "TestConvolutionMPS": 7.674333333333333, "TestErrorInputsMPS": 15.494666666666653, "TestFallbackWarning": 5.93, "TestGatherScatter": 0.37800000000000006, "TestLinalgMPSMPS": 56.24433333333334, "TestLogical": 1.329, "TestMPS": 112.69933333333336, "TestMemoryLeak": 0.9123333333333333, "TestNLLLoss": 1.6603333333333337, "TestNNMPS": 9.259, "TestNoRegression": 0.15333333333333332, "TestPad": 1.3033333333333335, "TestPixelShuffle": 6.572666666666667, "TestRNNMPS": 5.153333333333333, "TestSmoothL1Loss": 0.20066666666666666, "TestTopK": 2.092, "TestViewOpsMPS": 2.316333333333334}}, "multigpu": {"distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShardNDTraining": 32.27}, "distributed/_shard/sharded_tensor/test_sharded_tensor": {"TestCreateTensorFromParams": 0.258, "TestCreateTensorNoProcessGroupMode": 0.003, "TestLocalTensor": 12.634, "TestModuleHookApi": 12.783000000000001, "TestShardMetadata": 19.444, "TestShardParameter": 12.5565, "TestShardTensor": 19.1005, "TestShardedTensorChunked": 199.13950000000003, "TestShardedTensorCustomOps": 29.3145, "TestShardedTensorEnumerable": 133.144, "TestShardedTensorFromLocalShards": 88.549, "TestShardedTensorFromLocalTensor": 19.7435, "TestShardedTensorMetadata": 0.4015, "TestShardedTensorSubGroupInit": 0.06}, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": {"TestReshard": 13.440999999999999}, "distributed/_shard/sharding_plan/test_sharding_plan": {"TestShardingPlan": 20.512999999999998}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 24.859, "TestShardingSpec": 0.0435}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 12.819999999999999, "TestDTensorCompileE2E": 35.036}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 6.6625, "DistTensorRandomOpTest": 39.699000000000005}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 11.693, "TestDistributedFailure": 35.591499999999996}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 23.0015, "TestDistributedStateDictSaveLoad": 0.6495, "TestDistributedStateDictSaveLoadWithSharedTensor": 5.747999999999999}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 0.782}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.367}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 18.451499999999996}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 8.887}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 110.6315, "TestFSDPCheckpointSubmodule": 6.766500000000001}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 44.6565}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 55.702, "TestExplicitUnshard": 12.0775}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 188.52850000000004}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 7.618, "TestHooks": 48.5205, "TestNoGrad": 13.9855, "TestParamInit": 13.933499999999999, "TestParityWithDDP": 1407.0955}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 103.25450000000001}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 54.149}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 33.975}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 59.13249999999999}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 227.06349999999998}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.3845}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 50.209}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 80.8675}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 78.184}, "distributed/fsdp/test_fsdp_input": {"TestInput": 10.9875}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 13.384500000000001}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 47.623000000000005}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 81.58650000000002, "TestFSDPMiscMultiThread": 0.7400000000000002, "TestFSDPMiscWorldSize1": 0.094}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 35.528999999999996, "TestFSDPMixedPrecisionIgnoredModules": 5.312, "TestFSDPMixedPrecisionSharded": 332.3915000000002, "TestFSDPMixedPrecisionUnsharded": 16.4345, "TestFSDPTrainEval": 8.3665}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 6.984}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 7.1305}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 456.76149999999996}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 30.5505, "TestForwardOverlapWorldSizeTwo": 45.5655}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 14.091999999999999}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.65, "TestShardedGradScalerParityWithDDP": 142.181}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 1039.8309999999997, "TestFSDPStateDict4GPUs": 7.417999999999999}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 37.082499999999996}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 5.978}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 7.0785}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 55.980500000000006, "TestUnshardParamsErrors": 23.004, "TestUnshardParamsNoShard": 10.9255}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 7.0665000000000004, "TestFSDPUseOrigParamsInit": 6.917, "TestFSDPUseOrigParamsMultipleParamGroups": 204.33950000000002, "TestFSDPUseOrigParamsNoSync": 12.527, "TestFSDPUseOrigParamsParamAccess": 6.3125, "TestFSDPUseOrigParamsUnshardReshard": 31.2125, "TestFSDPUseOrigParamsWriteback": 31.014999999999997, "TestMultiTensorApply": 0.253}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 72.15950000000001}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 6.0155, "TestShardUtilsDistributedDTensor": 5.7135}, "distributed/fsdp/test_utils": {"TestUtils": 0.6244999999999999}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 5.671999999999999, "TestFSDPWrap": 160.763, "TestWrapUtils": 0.018000000000000002}, "distributed/pipelining/test_composability": {"ComposabilityTest": 32.416000000000004}, "distributed/rpc/cuda/test_tensorpipe_agent": {"TensorPipeCudaDdpComparisonTest": 7.3105, "TensorPipeCudaDistAutogradTest": 20.938, "TensorPipeCudaRemoteModuleTest": 22.0975, "TensorPipeCudaRpcTest": 6.859999999999999, "TensorPipeTensorPipeAgentCudaRpcTest": 749.7955000000001, "TensorPipeTensorPipeCudaDistAutogradTest": 24.583}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 8.777}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 58.835499999999996, "TestNew2dParallelTraining": 39.5}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 48.370000000000005}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 8.52}, "distributed/test_c10d_common": {"CommTest": 4.173500000000001, "ComputeBucketAssignmentTest": 1.4475, "LocalRankTest": 18.4545, "ProcessGroupWithDispatchedCollectivesTests": 8.7015, "PythonProcessGroupExtensionTest": 37.435, "ReduceOpTest": 1.479, "TimeoutTest": 46.9095}, "distributed/test_c10d_gloo": {"CommTest": 50.1995, "CompilerTest": 53.08300000000001, "DistributedDataParallelTest": 197.7565, "GlooProcessGroupWithDispatchedCollectivesTests": 29.292000000000005, "LargeCommTest": 14.222, "ProcessGroupGlooTest": 267.94750000000005, "ReducerTest": 0.235, "RendezvousEnvTest": 0.3915, "TimeoutTest": 4.931}, "distributed/test_c10d_nccl": {"CommTest": 102.22999999999999, "CompilerTest": 76.465, "DistributedDataParallelTest": 381.4219999999999, "LargeCommTest": 94.99849999999999, "NCCLTraceTest": 141.686, "NCCLTraceTestDumpOnTimeout": 15.763499999999999, "NCCLTraceTestTimeoutDumpOnStuckRanks": 8.636000000000001, "NcclErrorDumpTest": 28.366500000000002, "NcclErrorHandlingTest": 69.94999999999999, "NcclProcessGroupWithDispatchedCollectivesTests": 37.2575, "ProcessGroupNCCLGroupTest": 100.5705, "ProcessGroupNCCLNoGPUTest": 0.0015, "RendezvousEnvTest": 0.0495, "SparseCollective": 4.8260000000000005, "TimeoutTest": 4.531, "WorkHookTest": 31.6445}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 1.3410000000000002, "TestDistributedNNFunctionsGloo": 39.7705}, "distributed/test_c10d_spawn_nccl": {"TestDistributedNNFunctionsNccl": 48.952}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 0.0}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 32.11300000000001, "DeviceMeshTest": 72.93699999999998, "DeviceMeshTestNDim": 27.847, "InitDeviceMeshTest": 16.1055, "TestDeviceMeshGetItem": 32.5135, "TestMeshEnv": 25.865499999999997}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 36.738, "TestExpand": 0.35550000000000004, "TestFunctionalAutograd": 14.340499999999999, "TestFunctionalAutogradWithNCCL": 5.4145, "TestGradCollectives": 0.006, "TestMakeFx": 0.051500000000000004, "TestMetaCollectives": 0.002, "TestNCCLCollectivesWithWorldSize4": 48.676, "TestPgTag": 0.052000000000000005, "TestTraceableCollectives": 1.2090000000000003}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 51.6455, "ProcessGroupNCCLWrapperTest": 50.289}, "distributed/test_store": {"FileStoreTest": 4.79, "HashStoreTest": 2.7590000000000003, "InitPgWithNonUvStore": 0.8600000000000001, "LibUvTCPStoreTest": 13.6075, "PrefixFileStoreTest": 3.8569999999999998, "PrefixStoreTest": 0.027, "PrefixTCPStoreTest": 3.1470000000000002, "PythonStoreTest": 0.406, "RendezvousEnvTest": 0.397, "RendezvousFileTest": 0.77, "RendezvousTCPTest": 32.4435, "RendezvousTest": 0.7715000000000001, "TCPStoreTest": 13.565999999999999, "TestMultiThreadedWait": 2.7585000000000006, "TestPythonStore": 2.7720000000000002, "TimeoutTest": 7.9065}, "test_cuda_multigpu": {"TestCudaComm": 1.0025000000000002, "TestCudaMultiGPU": 7.537999999999999}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.4955}, "test_foreach": {"TestForeachCPU": 0.49750000000000005, "TestForeachCUDA": 0.21149999999999997}, "test_optim": {"TestOptimRenewedCPU": 0.07500000000000004, "TestOptimRenewedCUDA": 13.552499999999995}}, "nogpu_AVX512": {"backends/xeon/test_launch": {"TestTorchrun": 2.59625}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.7645}, "distributions/test_distributions": {"TestAgainstScipy": 1.65175, "TestConstraints": 0.21100000000000002, "TestDistributionShapes": 0.1817500000000001, "TestDistributions": 51.78675000000001, "TestFunctors": 0.016, "TestJit": 28.335, "TestKL": 4.332499999999999, "TestLazyLogitsInitialization": 0.01725, "TestNumericalStability": 0.10525000000000001, "TestRsample": 0.9942500000000001, "TestValidation": 0.50775}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.7865}, "dynamo/test_after_aot": {"TestAfterAot": 10.20025}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 19.00225}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.0302499999999997, "AOTAutogradCacheTests": 14.901000000000002}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.085999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.052000000000000005, "TestCustomBackendAPI": 2.5094999999999996, "TestExplainWithBackend": 15.6195, "TestOptimizations": 2.8664999999999994}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 18.25925}, "dynamo/test_base_output": {"TestBaseOutput": 0.0032500000000000003}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 8.854, "BytecodeTests": 0.6615}, "dynamo/test_compile": {"InPlaceCompilationTests": 10.55975, "PublicTorchCompilerTests": 0.003}, "dynamo/test_comptime": {"ComptimeTests": 0.9340000000000002}, "dynamo/test_config": {"ConfigTests": 0.8732500000000001}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.8717500000000007}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.38025}, "dynamo/test_decorators": {"DecoratorTests": 10.106}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.02175}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 48.492999999999995, "DynamicShapesCtxManagerTests": 6.976749999999998, "DynamicShapesExportTests": 40.988, "DynamicShapesFuncTorchHigherOrderOpTests": 139.29225, "DynamicShapesFunctionTests": 98.05874999999999, "DynamicShapesHigherOrderOpTests": 22.59375, "DynamicShapesMiscTests": 117.11500000000004, "DynamicShapesNNModuleTests": 8.761999999999999, "DynamicShapesReproTests": 135.92575000000005, "DynamicShapesSubGraphTests": 12.105500000000001, "DynamicShapesTestSDPA": 0.49725}, "dynamo/test_exc": {"ExcTests": 2.8385}, "dynamo/test_exceptions": {"ExceptionTests": 0.82325}, "dynamo/test_export": {"ExportTests": 21.421749999999996}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8452500000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.33075}, "dynamo/test_functions": {"DefaultsTests": 1.0510000000000002, "FunctionTests": 32.87950000000005}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.678}, "dynamo/test_global": {"TestGlobals": 0.8160000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.38475000000000004}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.11425, "FuncTorchHigherOrderOpTests": 10.926499999999997, "HigherOrderOpTests": 10.849999999999998, "HigherOrderOpVmapGuardTests": 5.357749999999999}, "dynamo/test_hooks": {"HooksTests": 36.84600000000002}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 6.46325, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 10.88175, "InlineInbuiltNNModulesFunctionTests": 6.33899999999999, "InlineInbuiltNNModulesHigherOrderOpTests": 10.137999999999995, "InlineInbuiltNNModulesMiscTests": 75.5437500000001, "InlineInbuiltNNModulesNNModuleTests": 5.843749999999999}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 12.1085}, "dynamo/test_interop": {"InteropTests": 0.8684999999999999}, "dynamo/test_logging": {"LoggingTests": 24.8575}, "dynamo/test_minifier": {"MinifierTests": 1.9852499999999997}, "dynamo/test_misc": {"MiscTests": 80.6980000000001, "TestTracer": 0.07550000000000001}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.004750000000000001}, "dynamo/test_modules": {"NNModuleTests": 3.981249999999997, "OptimizedModuleTest": 23.983749999999997}, "dynamo/test_nops": {"NopTests": 0.46099999999999997}, "dynamo/test_optimizers": {"End2EndTests": 0.95725}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.74675}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.8372499999999996}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.9992500000000001}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.2557500000000004}, "dynamo/test_recompiles": {"RecompileTests": 1.2677500000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.81525}, "dynamo/test_repros": {"ReproTests": 50.12774999999998}, "dynamo/test_resume": {"ResumeFunctionTests": 0.7015}, "dynamo/test_sdpa": {"TestSDPA": 0.7622500000000001}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.857}, "dynamo/test_sources": {"SourceTests": 0.756}, "dynamo/test_structured_trace": {"StructuredTraceTest": 17.02975}, "dynamo/test_subclasses": {"SubclassTests": 4.275749999999998, "TestNestedTensor": 16.508}, "dynamo/test_subgraphs": {"SubGraphTests": 3.2194999999999987}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.14325000000000002, "TraceRuleTests": 1.7422499999999999}, "dynamo/test_unspec": {"UnspecTests": 19.708749999999995}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.90825}, "dynamo/test_view": {"ViewTests": 0.96425}, "export/test_converter": {"TestConverter": 7.2675}, "export/test_db": {"ExampleTests": 4.39625}, "export/test_experimental": {"TestExperiment": 1.414}, "export/test_export": {"TestDynamismExpression": 0.67475, "TestExport": 40.18275, "TestExportCustomClass": 0.09375, "TestOneOffModelExportResult": 1.4917500000000001}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.571, "NonStrictExportTestExport": 35.4465}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.3395}, "export/test_hop": {"TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.13325}, "export/test_pass_infra": {"TestPassInfra": 1.3040000000000003}, "export/test_passes": {"TestPasses": 17.464000000000002}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.15725, "RetraceExportTestExport": 66.43875}, "export/test_schema": {"TestSchema": 0.39375}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.7805, "SerDesExportTestExport": 42.97149999999999}, "export/test_serialize": {"TestDeserialize": 10.951000000000002, "TestSaveLoad": 0.41750000000000004, "TestSchemaVersioning": 0.056, "TestSerialize": 1.5335, "TestSerializeCustomClass": 0.12}, "export/test_sparse": {"TestSparseProp": 82.91174999999986}, "export/test_tools": {"TestExportTools": 0.8275}, "export/test_torchbind": {"TestCompileTorchbind": 1.4995000000000003, "TestExportTorchbind": 2.4804999999999993, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.33899999999999997}, "export/test_unflatten": {"TestUnflatten": 4.426499999999999}, "export/test_verifier": {"TestVerifier": 1.3252500000000003}, "functorch/test_aotdispatch": {"TestAOTAutograd": 17.039999999999996, "TestAOTAutogradWithDynamo": 18.611749999999986, "TestAOTDispatch": 0.69975, "TestAOTExport": 3.0665000000000004, "TestAOTModuleSimplified": 0.8785000000000001, "TestPartitioning": 1.4265}, "functorch/test_control_flow": {"TestControlFlow": 1.0435000000000003, "TestControlFlowTraced": 152.76224999999994}, "functorch/test_dims": {"TestMin": 21.205000000000002, "TestMinFunctorchOnly": 19.870999999999995}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.14475000000000005, "TestSliceArgnums": 0.019250000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.39725}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.74775, "RandomOpTestCase": 0.11149999999999999, "ReduceTestCase": 0.11074999999999999, "TestMemoryEfficientOpAuthoring": 0.0015}, "functorch/test_minifier": {"TestMinifier": 0.609}, "functorch/test_parsing": {"TestAnonymousAxis": 0.34, "TestParsedExpression": 0.0072499999999999995, "TestParsingUtils": 0.006, "TestValidateRearrangeExpressions": 0.006}, "functorch/test_rearrange": {"TestRearrange": 0.41675000000000006}, "functorch/test_vmap": {"TestVmapAPI": 0.3505000000000002, "TestVmapOperators": 4.188999999999991}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.4744999999998423}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.384}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 13.177500000000002}, "inductor/test_binary_folding": {"FreezingCpuTests": 52.25999999999999}, "inductor/test_codecache": {"TestFxGraphCache": 56.137499999999996, "TestFxGraphCacheHashing": 0.99025, "TestUtils": 4.91775, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.33575}, "inductor/test_compile_worker": {"TestCompileWorker": 11.309999999999999}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 416.49650000000025, "TestCompiledAutograd": 255.62650000000005, "TestCustomOpWithCompiledAutograd": 0.7502500000000003}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 338.86825000000067}, "inductor/test_config": {"TestInductorConfig": 8.957}, "inductor/test_control_flow": {"CondTests": 0.11200000000000002, "WhileLoopTests": 0.00575}, "inductor/test_cpu_repro": {"CPUReproTests": 928.5175}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 15.861}, "inductor/test_debug_trace": {"TestDebugTrace": 4.906}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.00175}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 52.48275000000001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 27.06425}, "inductor/test_flex_attention": {"TestFlexAttention": 0.021000000000000008}, "inductor/test_foreach": {"ForeachTests": 24.77075000000003}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 109.08875, "SDPAPatternRewriterCpuTests": 104.78199999999998}, "inductor/test_fx_fusion": {"TestFxFusion": 0.2925}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.02075}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.29975, "TestGroupBatchFusion": 0.00175, "TestPostGradBatchLinearFusion": 0.00025}, "inductor/test_indexing": {"ExprPrinterTests": 0.062250000000000014, "TestIndexingSimplification": 0.84625}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 76.24575000000002}, "inductor/test_minifier": {"MinifierTests": 34.669000000000004}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 67.45949999999999}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 221.06775, "TestPatternMatcher": 772.6632500000002}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 24.17175}, "inductor/test_torchbind": {"TestTorchbind": 13.89725}, "inductor/test_torchinductor": {"CpuTests": 1954.3464999999992, "SweepInputsCpuTest": 166.92524999999998, "TestFull": 14.968}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2063.800749999998}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2183.030749999999}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.855}, "inductor/test_triton_kernels": {"KernelTests": 0.032000000000000015, "MutationTests": 0.0052499999999999995}, "inductor/test_utils": {"TestUtils": 0.32975}, "lazy/test_debug_util": {"DebugUtilTest": 0.403}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.41050000000000003}, "lazy/test_generator": {"LazyGeneratorTest": 0.41275}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.7545}, "lazy/test_step_closures": {"ClosuresTest": 3.3339999999999996}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.30225, "TestLazyTensor": 0.09925}, "nn/test_convolution": {"TestConvolutionNN": 20.533750000000005}, "nn/test_dropout": {"TestDropoutNN": 0.14800000000000002}, "nn/test_embedding": {"TestEmbeddingNN": 0.06975000000000003}, "nn/test_init": {"TestNNInit": 5.614249999999998}, "nn/test_lazy_modules": {"TestLazyModules": 0.5217500000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.7705, "TestLoadStateDictSwap": 0.068}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.03025, "TestModuleHookNN": 0.08975000000000002, "TestModuleHooks": 0.11850000000000002, "TestStateDictHooks": 0.04275000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.669499999999999}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5722500000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.1067500000000003}, "nn/test_pooling": {"TestAvgPool": 0.34049999999999997, "TestPoolingNN": 0.48175000000000007}, "nn/test_pruning": {"TestPruningNN": 0.13650000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.15749999999999997}, "profiler/test_memory_profiler": {"TestDataFlow": 1.9424999999999997, "TestIdentifyGradients": 0.32825000000000004, "TestMemoryProfiler": 0.376, "TestMemoryProfilerE2E": 3.902}, "profiler/test_profiler": {"TestExperimentalUtils": 5.773, "TestProfiler": 23.973, "TestProfilerCUDA": 0.00025, "TestProfilerITT": 0.006}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.44800000000000006}, "profiler/test_record_function": {"TestRecordFunction": 0.39875000000000005}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.520749999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.097, "TestBaseDataScheduler": 0.037000000000000005, "TestBaseDataSparsifier": 0.08499999999999999, "TestBaseSparsifier": 0.03175, "TestBaseStructuredSparsifier": 1.6842499999999998, "TestComposability": 2.104, "TestCubicScheduler": 0.006, "TestFPGMPruner": 0.026000000000000002, "TestFakeSparsity": 0.09075, "TestFxComposability": 1.91075, "TestNearlyDiagonalSparsifier": 0.913, "TestNormDataSparsifiers": 1.0397500000000002, "TestQuantizationUtils": 0.0235, "TestQuantizedSparseKernels": 0.33825, "TestQuantizedSparseLayers": 0.432, "TestSaliencyPruner": 0.0315, "TestScheduler": 0.01925, "TestSparsityUtilFunctions": 0.047, "TestWeightNormSparsifier": 0.33275}, "test_autocast": {"TestAutocastCPU": 1.52625, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.00775}, "test_autograd": {"TestAllowMutationOnSaved": 0.036000000000000004, "TestAutograd": 23.99575000000005, "TestAutogradComplex": 0.0075, "TestAutogradForwardMode": 0.09275000000000005, "TestAutogradForwardModeBatchedGrad": 0.022000000000000002, "TestAutogradFunctional": 12.831749999999998, "TestAutogradInferenceMode": 0.04400000000000002, "TestAutogradLogging": 0.0245, "TestMultithreadAutograd": 0.25150000000000006, "TestNestedCheckpoint": 0.5120000000000001, "TestSelectiveActivationCheckpoint": 0.0195}, "test_autograd_fallback": {"TestAutogradFallback": 0.5077500000000001}, "test_bundled_inputs": {"TestBundledInputs": 1.583}, "test_comparison_utils": {"TestComparisonUtils": 0.34775}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.00075}, "test_cpp_api_parity": {"TestCppApiParity": 4.8722499999999815}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03200000000000001, "TestMAIATensor": 0.0105, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03250000000000001, "TestMAIATensor": 0.014000000000000002, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 60.3125}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.0594999999999999}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 12.003}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.0785}, "test_custom_backend": {"TestCustomBackend": 0.10974999999999999}, "test_custom_ops": {"MiniOpTest": 0.7992500000000002, "MiniOpTestOther": 0.07800000000000001, "TestCustomOp": 3.506749999999991, "TestCustomOpAPI": 0.15175000000000005, "TestCustomOperators": 0.41775000000000007, "TestGenerateOpcheckTests": 4.23325}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.06, "TestCustomPinFn": 0.00175, "TestDataLoader": 109.38200000000003, "TestDataLoaderPersistentWorkers": 144.19200000000004, "TestDatasetRandomSplit": 0.036500000000000005, "TestDictDataLoader": 0.05449999999999999, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.00625, "TestSetAffinity": 0.08474999999999999, "TestStackDataset": 0.036500000000000005, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.02525}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.002, "TestFunctionalIterDataPipe": 7.136499999999998, "TestFunctionalMapDataPipe": 0.0445, "TestGraph": 0.019250000000000003, "TestIterDataPipeCountSampleYielded": 0.0115, "TestIterDataPipeGraphFastForward": 0.05875000000000001, "TestIterDataPipeSingletonConstraint": 0.028500000000000004, "TestIterableDataPipeBasic": 0.03425, "TestSerialization": 7.917749999999999, "TestSharding": 0.24625000000000005, "TestStreamWrapper": 0.34400000000000003, "TestTyping": 0.004750000000000001}, "test_decomp": {"HasDecompTest": 0.22424999999999998}, "test_deploy": {"TestFreezer": 0.334}, "test_dispatch": {"TestDispatch": 41.731249999999996, "TestPythonDispatcher": 0.0625}, "test_dynamic_shapes": {"TestDimConstraints": 2.6105, "TestFloorDiv": 0.013500000000000002, "TestGuardsExpressions": 0.018500000000000003, "TestPySymInt": 1.5972500000000003, "TestSymNumberMagicMethods": 2.0154999999999927}, "test_fake_tensor": {"FakeTensorConstHandling": 0.09975, "FakeTensorConverterTest": 0.030500000000000006, "FakeTensorDispatchCache": 0.092, "FakeTensorOperatorInvariants": 0.58025, "FakeTensorPropTest": 0.09425, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 1.2100000000000004, "PropagateRealTensorsFakeTensorConstHandling": 0.12275000000000003, "PropagateRealTensorsFakeTensorConverterTest": 0.030500000000000003, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.2375, "PropagateRealTensorsFakeTensorPropTest": 0.06625, "PropagateRealTensorsFakeTensorTest": 0.32400000000000007}, "test_flop_counter": {"TestFlopCounter": 0.5760000000000001}, "test_function_schema": {"TestFunctionSchema": 0.7244999999999999}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 41.853750000000005}, "test_functional_optim": {"TestFunctionalOptimParity": 0.48050000000000015}, "test_functionalization": {"TestCrossRefFunctionalization": 3.0867499999999994, "TestFunctionalization": 3.540999999999999}, "test_futures": {"TestFuture": 1.29175}, "test_fx": {"AnnotationsTest": 0.017500000000000005, "TestCSEPass": 0.3447500000000001, "TestCommonPass": 0.07949999999999999, "TestConstFold": 0.20525000000000004, "TestConstParamShapeInControlFlow": 0.055499999999999994, "TestDCE": 0.04, "TestFX": 4.121999999999998, "TestFXAPIBackwardCompatibility": 0.036, "TestFunctionalTracing": 0.4572500000000003, "TestMatcher": 0.50675, "TestPassManager": 0.030000000000000006, "TestSourceMatcher": 1.54425, "TestSubgraphRewriter": 0.37775000000000014, "TestVisionTracing": 341.6265000000001, "TypeCheckerTest": 2.3977499999999976}, "test_fx_experimental": {"TestFXExperimental": 20.81425, "TestTranslationValidation": 0.153}, "test_fx_passes": {"TestFXGraphPasses": 0.8162500000000001, "TestFXMatcherUtils": 0.11975000000000004}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5755000000000001}, "test_import_stats": {"TestImportTime": 4.9335}, "test_itt": {"TestItt": 0.34075}, "test_jit": {"TestAliasAnalysis": 0.44500000000000006, "TestAsync": 0.6727500000000002, "TestAtenPow": 0.02125, "TestAutodiffJit": 0.24450000000000002, "TestAutodiffSubgraphSlicing": 0.6390000000000002, "TestAwait": 0.35075, "TestBackends": 0.7855000000000001, "TestBackendsWithCompiler": 0.16799999999999998, "TestBatchMM": 0.09825, "TestBuiltins": 0.07325000000000001, "TestClassType": 3.359499999999999, "TestComplex": 1.0415, "TestCustomOperators": 0.05350000000000001, "TestDCE": 0.0235, "TestDataParallel": 0.002, "TestDataclasses": 8.1065, "TestDeviceAnalysis": 4.571999999999999, "TestDict": 0.4770000000000002, "TestDtypeAnalysis": 0.33825000000000005, "TestEnum": 0.35850000000000004, "TestFreezing": 3.1035000000000004, "TestFrontend": 0.5965, "TestFrozenOptimizations": 13.581999999999997, "TestFunctionalBlocks": 0.00875, "TestFunctionalToInplaceActivation": 3.20325, "TestGenerator": 0.07850000000000001, "TestGetDefaultAttr": 0.019250000000000003, "TestGraphRewritePasses": 0.05725, "TestHash": 0.097, "TestHooks": 0.9487500000000003, "TestIgnorableArgs": 0.01425, "TestIgnoreContextManager": 0.056, "TestInplaceToFunctionalActivation": 2.9124999999999996, "TestIsinstance": 0.29300000000000015, "TestJit": 7.277999999999994, "TestJitGeneratedModule": 12.60249999999997, "TestJitProfiler": 0.0015, "TestJitUtils": 0.022000000000000006, "TestList": 1.4530000000000007, "TestLogging": 0.05349999999999999, "TestMKLDNNReinplacing": 0.00625, "TestMisc": 0.23550000000000007, "TestMixTracingScripting": 1.48325, "TestModels": 2.228499999999999, "TestModuleAPIs": 0.16825, "TestModuleContainers": 1.4465000000000001, "TestModuleInterface": 0.6180000000000001, "TestModules": 0.0155, "TestNamedTuple": 0.07550000000000001, "TestNnapiBackend": 11.194749999999999, "TestOpDecompositions": 0.018750000000000003, "TestOptimizeForMobilePreserveDebugInfo": 0.18975, "TestPDT": 0.4125000000000001, "TestParametrization": 0.11150000000000002, "TestPeephole": 0.5965000000000003, "TestProducerVersion": 0.0015, "TestProfiler": 0.7230000000000001, "TestPythonBindings": 0.03875, "TestPythonBuiltinOP": 0.47950000000000004, "TestPythonIr": 0.028999999999999998, "TestRecursiveScript": 0.7667500000000003, "TestRemoveMutation": 0.1395, "TestSaveLoad": 0.8105000000000001, "TestSaveLoadFlatbuffer": 0.69825, "TestSaveLoadForOpVersion": 2.307, "TestScript": 44.928750000000015, "TestScriptDict": 0.03325, "TestScriptList": 1.2029999999999998, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2462500000000001, "TestScriptProfile": 0.42825, "TestSlice": 0.19775000000000004, "TestSparse": 0.057999999999999996, "TestStringFormatting": 0.15000000000000008, "TestSymbolicShapeAnalysis": 1.9219999999999988, "TestTensorBuiltins": 0.1015, "TestTensorCreationOps": 0.0675, "TestTensorMethods": 0.014000000000000002, "TestTorchbind": 0.13975000000000004, "TestTracer": 3.1487499999999957, "TestTypeSharing": 0.5362500000000001, "TestTypesAndAnnotation": 0.17425000000000002, "TestTyping": 0.5092500000000002, "TestUnion": 0.49675000000000025, "TestUnsupportedOps": 0.031, "TestUpgraders": 0.10025, "TestWarn": 0.064, "TestWith": 0.64075}, "test_jit_autocast": {"TestAutocast": 0.12525, "TestJitTraceAutocast": 22.009749999999997}, "test_jit_disabled": {"TestJitDisabled": 0.46925000000000006}, "test_jit_fuser_te": {"TestFuserCommon": 0.17325000000000002, "TestTEFuserDynamic": 129.30475000000004, "TestTEFuserStatic": 52.37200000000002}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.00025, "TestEnableDisableLlgaFuser": 0.0965, "TestModel": 3.1129999999999995}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2395, "TestVmapOperatorsLegacy": 1.1842500000000002}, "test_license": {"TestLicense": 0.34775}, "test_logging": {"LoggingTest": 3.496}, "test_maskedtensor": {"TestBinary": 0.4202500000000003, "TestReductions": 0.09550000000000003, "TestUnary": 0.37375000000000025}, "test_meta": {"TestMetaConverter": 0.06950000000000003}, "test_mkl_verbose": {"TestMKLVerbose": 5.66875}, "test_mkldnn_fusion": {"TestMkldnnFusion": 80.519}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.0760000000000005}, "test_mobile_optimizer": {"TestOptimizer": 3.8249999999999997}, "test_model_dump": {"TestModelDump": 1.2494999999999998}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.27825}, "test_module_tracker": {"TestModuleTracker": 0.33875}, "test_monitor": {"TestMonitor": 0.342, "TestMonitorTensorboard": 0.21825}, "test_multiprocessing": {"TestMultiprocessing": 67.49025}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.84125, "SpawnTest": 37.398250000000004}, "test_namedtensor": {"TestNamedTensor": 0.4222500000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.389}, "test_native_functions": {"TestNativeFunctions": 0.4820000000000001}, "test_nestedtensor": {"TestNestedTensor": 0.1645000000000001}, "test_nn": {"TestAddRelu": 0.004750000000000001, "TestConstantPadNd": 0.0045000000000000005, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.4305, "TestFusionUtils": 0.006, "TestNN": 55.14774999999994, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.003}, "test_openmp": {"TestOpenMP_ParallelFor": 6.66525}, "test_ops": {"TestSelfKwarg": 0.0045000000000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.24725000000000005, "TestLRScheduler": 1.2647500000000007, "TestSWAUtils": 0.21549999999999997}, "test_out_dtype_op": {"TestOutDtypeOp": 0.40275000000000005}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.0022500000000000003, "TestDisabledUserWarnings": 0.0022500000000000003, "TestEinsumOverride": 0.0305, "TestGradCheckOverride": 0.025750000000000002, "TestGradNewOnesOverride": 0.0022500000000000003, "TestIndexing": 0.0105, "TestIterator": 0.0015, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.003, "TestResolveName": 0.12825, "TestTorchFunctionMode": 0.04125000000000002, "TestTorchFunctionOverride": 2.5172499999998923, "TestTorchFunctionWarning": 0.018750000000000003, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.05025, "ModelTest": 0.0, "TestAnalyze": 0.32425000000000004, "TestDependencyAPI": 0.06275000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.018000000000000006, "TestGlobGroup": 0.025500000000000012, "TestImporter": 0.013750000000000002, "TestLoadBCPackages": 0.08675, "TestMangling": 0.019250000000000003, "TestMisc": 0.05775000000000001, "TestPackageFX": 0.07899999999999999, "TestPackageScript": 2.3694999999999986, "TestRepackage": 0.013, "TestResources": 0.013750000000000002, "TestSaveLoad": 0.043750000000000004}, "test_per_overload_api": {"TestPerOverloadAPI": 0.34625000000000006}, "test_prims": {"TestPrimsBasic": 0.018250000000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.13, "TestGenericProxyTensorFake": 2.815, "TestGenericProxyTensorReal": 2.8874999999999993, "TestGenericProxyTensorSymbolic": 21.73875, "TestRealProxyTensor": 0.0195, "TestSymbolicTracing": 4.344999999999999}, "test_pruning_op": {"PruningOpTest": 0.577}, "test_public_bindings": {"TestPublicBindings": 7.68225}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.32225000000000015, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.269}, "test_pytree": {"TestCxxPytree": 0.022750000000000006, "TestGenericPytree": 0.49850000000000017, "TestPythonPytree": 0.07950000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.018000000000000006, "TestAOMigrationNNQuantized": 0.06975000000000002, "TestAOMigrationQuantization": 0.024000000000000007, "TestAOMigrationQuantizationFx": 0.026500000000000003, "TestBackendConfig": 0.059750000000000025, "TestBiasCorrectionEager": 1.66475, "TestComparatorOps": 1.8777499999999998, "TestDeprecatedJitQuantized": 5.4635, "TestDistributed": 0.0315, "TestDuplicateDQPass": 3.5580000000000003, "TestDynamicQuantizedModule": 49.582499999999996, "TestDynamicQuantizedOps": 29.109000000000005, "TestEqualizeEager": 0.1335, "TestEqualizeFx": 6.99225, "TestFXGraphMatcher": 2.3979999999999997, "TestFXGraphMatcherModels": 11.82025, "TestFXNumericSuiteCoreAPIs": 33.826499999999996, "TestFXNumericSuiteCoreAPIsModels": 48.325500000000005, "TestFXNumericSuiteNShadows": 44.6365, "TestFakeQuantize": 0.38075, "TestFakeQuantizeOps": 2.2245, "TestFuseEager": 3.295, "TestFuseFx": 2.6079999999999988, "TestFusedObsFakeQuant": 0.098, "TestFusedObsFakeQuantModule": 0.24050000000000005, "TestFusionPasses": 0.025, "TestFxDetectInputWeightEqualization": 0.21600000000000003, "TestFxDetectOutliers": 0.30574999999999997, "TestFxModelReportClass": 0.59075, "TestFxModelReportDetectDynamicStatic": 0.07425000000000001, "TestFxModelReportDetector": 0.22400000000000003, "TestFxModelReportObserver": 0.24125000000000002, "TestFxModelReportVisualizer": 0.239, "TestGenerateNumericDebugHandle": 0.9157500000000001, "TestGraphUtils": 2.55725, "TestHistogramObserver": 43.76, "TestMetaDataPorting": 7.918500000000002, "TestModelNumericsEager": 1.44425, "TestNumericSuiteEager": 10.138, "TestObserver": 4.2372499999999995, "TestPT2ERepresentation": 33.742, "TestPadding": 27.158749999999998, "TestQNNPackOps": 6.148999999999999, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.2584999999999997, "TestQuantizeDynamicJitPasses": 5.71325, "TestQuantizeEagerOps": 1.9117499999999996, "TestQuantizeEagerPTQDynamic": 9.06325, "TestQuantizeEagerPTQStatic": 33.77975, "TestQuantizeEagerQAT": 12.502, "TestQuantizeEagerQATNumerics": 2.328, "TestQuantizeFx": 48.64775, "TestQuantizeFxModels": 7.016500000000001, "TestQuantizeFxOps": 134.31675, "TestQuantizeJit": 24.6875, "TestQuantizeJitOps": 288.27175000000005, "TestQuantizeJitPasses": 6.198749999999999, "TestQuantizePT2E": 59.29174999999999, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 374.94975, "TestQuantizePT2EQAT_ConvBn2d": 379.33175, "TestQuantizePT2EX86Inductor": 98.265, "TestQuantizedConv": 61.05525, "TestQuantizedEmbeddingOps": 1.8235000000000001, "TestQuantizedFunctionalOps": 4.07775, "TestQuantizedLinear": 25.7345, "TestQuantizedOps": 123.43050000000002, "TestQuantizedTensor": 2.2372499999999995, "TestRecordHistogramObserver": 0.04025, "TestReferenceQuantizedModule": 0.05625000000000001, "TestSerialization": 1.964, "TestStaticQuantizedModule": 85.4315, "TestSubgraphRewriter": 1.06075, "TestUtils": 0.025500000000000002, "TestXNNPACKQuantizer": 50.007, "TestXNNPACKQuantizerModels": 3.9165}, "test_schema_check": {"TestSchemaCheck": 0.13900000000000007}, "test_serialization": {"TestOldSerialization": 39.20925, "TestSerialization": 13.109000000000016, "TestSubclassSerialization": 0.03175000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.33625}, "test_show_pickle": {"TestShowPickle": 0.39}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.03475, "TestSparseMeta": 4.803499999999999, "TestSparseOneOff": 0.0022500000000000003}, "test_sparse_csr": {"TestSparseCSRSampler": 0.6395}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.003}, "test_stateless": {"TestPythonOptimizeMode": 4.99925, "TestStatelessDeprecation": 2.32775, "TestStatelessFunctionalAPI": 0.27875000000000005}, "test_subclass": {"TestSubclass": 0.5837500000000002}, "test_sympy_utils": {"TestSingletonInt": 0.0075, "TestSympyInterp": 11.629249999999999, "TestSympySolve": 0.3945, "TestValueRanges": 7.819499999999998}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.027000000000000003, "TestTensorBoardFigure": 0.0025, "TestTensorBoardNumpy": 0.005, "TestTensorBoardPyTorchNumpy": 0.23475000000000001, "TestTensorBoardPytorchGraph": 37.209250000000004, "TestTensorBoardSummary": 0.054500000000000014, "TestTensorBoardSummaryWriter": 0.011000000000000001, "TestTensorBoardUtils": 0.29675000000000007, "TestTensorBoardWriter": 0.13374999999999998, "TestTensorProtoSummary": 0.01225}, "test_tensorexpr": {"TestTensorExprFuser": 68.25625000000002}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.01325, "TestTensorExprPyBind": 1.1345000000000003}, "test_testing": {"TestAssertClose": 0.15575000000000008, "TestAssertCloseContainer": 0.00775, "TestAssertCloseErrorMessage": 0.06925000000000002, "TestAssertCloseQuantized": 0.020750000000000005, "TestAssertCloseSparseBSC": 0.019750000000000004, "TestAssertCloseSparseBSR": 0.019750000000000004, "TestAssertCloseSparseCOO": 0.02475, "TestAssertCloseSparseCSC": 0.02025, "TestAssertCloseSparseCSR": 0.0205, "TestFrameworkUtils": 16.329749999999997, "TestImports": 16.20875, "TestOpInfos": 0.004750000000000001, "TestTestParametrization": 0.03825000000000001}, "test_torch": {"TestBasicVitalSigns": 0.017, "TestTorch": 7.210499999999989}, "test_type_hints": {"TestTypeHints": 0.34825}, "test_type_info": {"TestDTypeInfo": 0.34975}, "test_typing": {"TestTyping": 102.40950000000007}, "test_utils": {"TestAssert": 0.0795, "TestBottleneck": 11.93425, "TestCheckpoint": 0.10425000000000001, "TestCollectEnv": 1.254, "TestCppExtensionUtils": 0.04475, "TestDataLoaderUtils": 0.28125, "TestExtensionUtils": 0.006, "TestHipify": 0.0015, "TestHipifyTrie": 0.009000000000000001, "TestONNXUtils": 0.005, "TestRenderUtils": 0.019, "TestStandaloneCPPJIT": 3.2144999999999997, "TestTraceback": 0.01225}, "test_vulkan": {"TestVulkanRewritePass": 0.003}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.025500000000000002, "WeakKeyDictionaryTestCase": 0.024, "WeakTest": 5.467999999999998}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 4.88625, "TestXNNPACKRewritePass": 1.68775, "TestXNNPACKSerDes": 5.342}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.00275}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.36150000000000004, "TestClassGetItem": 0.00075, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.002, "TestMisc": 0.00375, "TestPickling": 0.13725, "TestPromotion": 0.0015}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 18.871250000000003, "TestEinsumPath": 0.00075, "TestMisc": 0.00625}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0015, "TestHalf": 0.00025, "TestIinfo": 0.3632500000000001, "TestMisc": 0.0025, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.0075, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.009000000000000001, "TestIndexing": 0.5080000000000001, "TestMultiIndexingAutomated": 0.009000000000000001, "TestMultipleEllipsisError": 0.003, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.022000000000000006, "TestArgmax": 1.292000000000001, "TestArgmaxArgminCommon": 0.07650000000000004, "TestArgmin": 1.3680000000000008, "TestArrayAttributeDeletion": 0.00775, "TestArrayConstruction": 0.047750000000000015, "TestArrayCreationCopyArgument": 0.00025, "TestAssignment": 0.01125, "TestAttributes": 0.028500000000000004, "TestBinop": 0.021, "TestBool": 28.788750000000007, "TestCequenceMethods": 0.003, "TestChoose": 0.022000000000000006, "TestClip": 0.0075, "TestCompress": 0.0045000000000000005, "TestConversion": 0.041, "TestCreation": 0.0015, "TestDelMisc": 0.0015, "TestDot": 0.08550000000000003, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.019500000000000003, "TestFormat": 0.006, "TestFromBuffer": 0.014000000000000002, "TestHash": 0.21175, "TestHashing": 0.0035, "TestIO": 0.0015, "TestInner": 0.24975, "TestLexsort": 0.02275, "TestMatmul": 0.49600000000000016, "TestMatmulOperator": 0.35750000000000004, "TestMethods": 1.6767500000000006, "TestMinMax": 0.007, "TestMinScalarType": 0.007, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.014000000000000002, "TestRepeat": 0.0155, "TestResize": 0.05550000000000001, "TestRichcompareScalar": 0.0005, "TestScalarIndexing": 0.025750000000000002, "TestSortFloatMisc": 0.1997500000000001, "TestStats": 0.2755, "TestSubscripting": 0.0022500000000000003, "TestTake": 0.04200000000000001, "TestVdot": 0.044250000000000005, "TestWarnings": 0.0022500000000000003, "TestWhere": 0.41250000000000003, "TestWritebackIfCopy": 0.03325}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.02475, "TestArgwhere": 0.033, "TestArrayComparisons": 0.015, "TestBaseRepr": 0.006, "TestBinaryRepr": 0.009000000000000001, "TestBoolArray": 2.63, "TestBoolCmp": 0.20275, "TestBoolScalar": 0.01075, "TestBroadcast": 0.0075, "TestClip": 0.22400000000000012, "TestConvolve": 0.02125, "TestCorrelate": 0.064, "TestCreationFuncs": 1.2525000000000002, "TestCross": 0.0595, "TestDtypePositional": 0.0022500000000000003, "TestFloatExceptions": 0.0105, "TestFromiter": 0.0, "TestIndex": 0.008, "TestIndices": 0.046250000000000006, "TestIsclose": 0.10075, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.0105, "TestNonarrayArgs": 0.13825000000000007, "TestNonzeroAndCountNonzero": 0.28875000000000006, "TestOuterMisc": 0.006, "TestRequire": 0.006, "TestResize": 0.36225000000000007, "TestRoll": 0.03875, "TestRollaxis": 0.006, "TestSeterr": 0.0085, "TestStdVar": 0.0335, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0015, "TestTensordot": 0.018000000000000002, "TestTypes": 0.01725}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.334, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.12300000000000008, "TestFromInt": 0.01, "TestFromString": 0.40125}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.001, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.00075, "TestIsInteger": 0.00125}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0005}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.12875000000000003, "TestBaseMath": 11.012999999999998, "TestBitShifts": 0.11975, "TestComplexDivision": 0.07275000000000001, "TestConversion": 0.06075000000000001, "TestHash": 0.002, "TestModulus": 1.21775, "TestMultiply": 0.0, "TestNegative": 0.0225, "TestPower": 0.16375, "TestRepr": 0.0015, "TestScalarOpsMisc": 0.061000000000000026, "TestScalarSubclassingMisc": 0.015000000000000003, "TestSubtract": 0.0225, "TestTypes": 17.95775}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.35075, "TestAtleast2d": 0.019500000000000003, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.033250000000000016, "TestConcatenate": 0.19325000000000012, "TestHstack": 0.021000000000000005, "TestStackMisc": 0.004750000000000001, "TestVstack": 0.024000000000000004}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.01225, "TestFFTShift": 7.29675, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.012}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.4970000000000003, "TestFFTShift": 0.33725000000000005, "TestFFTThreadSafe": 0.91325}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.36125}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.006250000000000003, "TestUnique": 0.55925}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0075, "TestAmin": 0.0075, "TestAngle": 0.012, "TestAny": 0.009000000000000001, "TestAverage": 0.031, "TestBincount": 0.05549999999999999, "TestCheckFinite": 0.003, "TestCopy": 0.009750000000000002, "TestCorrCoef": 0.0505, "TestCov": 0.07600000000000001, "TestCumprod": 0.03875, "TestCumsum": 0.04975, "TestDelete": 0.0225, "TestDiff": 0.09425, "TestDigitize": 0.020750000000000005, "TestExtins": 0.008, "TestFilterwindows": 0.7347500000000006, "TestFlip": 0.04025000000000001, "TestGradient": 0.178, "TestInsert": 0.012, "TestInterp": 0.053750000000000034, "TestKaiser": 0.012, "TestMedian": 0.12900000000000003, "TestMeshgrid": 0.06775000000000002, "TestMsort": 0.0, "TestPercentile": 0.08050000000000004, "TestPiecewise": 0.012, "TestProd": 0.037000000000000005, "TestPtp": 0.012, "TestQuantile": 0.023000000000000007, "TestRot90": 0.39775000000000005, "TestSelect": 0.01, "TestSinc": 0.0105, "TestSortComplex": 0.0125, "TestTrapz": 0.0075, "TestTrimZeros": 0.013250000000000001, "TestUnique": 0.006, "Test_I0": 0.02075}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4870000000000001, "TestHistogramOptimBinNums": 0.039000000000000014, "TestHistogramdd": 0.182}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0015, "TestConcatenator": 0.009250000000000001, "TestDiagIndices": 0.006, "TestDiagIndicesFrom": 0.009000000000000001, "TestFillDiagonal": 0.0315, "TestGrid": 0.01075, "TestIndexExpression": 0.013500000000000002, "TestIx_": 0.009000000000000001, "TestNdIndex": 0.0015, "TestNdenumerate": 0.00175, "TestRavelUnravelIndex": 0.36400000000000005}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.019250000000000003, "TestApplyOverAxes": 0.002, "TestArraySplit": 0.20075000000000004, "TestColumnStack": 0.0125, "TestDsplit": 0.012, "TestDstack": 0.022000000000000002, "TestExpandDims": 0.009750000000000002, "TestHsplit": 0.015500000000000002, "TestKron": 0.014499999999999999, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.012, "TestSplit": 0.008, "TestSqueeze": 0.0335, "TestTakeAlongAxis": 0.3935, "TestTile": 0.1015, "TestVsplit": 0.0115}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.39725, "TestFliplr": 0.006, "TestFlipud": 0.006, "TestHistogram2d": 0.04050000000000001, "TestTri": 0.10225000000000001, "TestTrilIndicesFrom": 0.0022500000000000003, "TestTriuIndices": 0.00375, "TestTriuIndicesFrom": 0.00175, "TestVander": 0.021249999999999998}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.002, "TestCommonType": 0.36124999999999996, "TestImag": 0.015, "TestIscomplex": 0.006500000000000001, "TestIscomplexobj": 0.0045000000000000005, "TestIsfinite": 0.02075, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.0205, "TestIsneginf": 0.0035, "TestIsposinf": 0.008499999999999999, "TestIsreal": 0.0105, "TestIsrealobj": 0.00175, "TestIsscalar": 0.00275, "TestMintypecode": 0.0072499999999999995, "TestNanToNum": 0.022250000000000002, "TestReal": 0.0165, "TestRealIfClose": 0.005}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.20325000000000004, "TestCond": 0.26075, "TestDet": 0.1855, "TestEig": 0.046750000000000014, "TestEigh": 0.03250000000000001, "TestEighCases": 0.0, "TestEigvals": 0.10225000000000001, "TestEigvalsh": 0.028000000000000004, "TestEigvalshCases": 0.0, "TestInv": 0.06000000000000001, "TestLstsq": 0.255, "TestMatrixRank": 0.46625000000000005, "TestMisc": 0.026000000000000002, "TestMisc2": 0.003, "TestMultiDot": 0.066, "TestNormDouble": 0.956, "TestNormInt64": 0.948, "TestNormSingle": 0.95525, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.13875, "TestPinvHermitian": 0.05225, "TestQR": 0.49275, "TestSVD": 0.06050000000000001, "TestSVDHermitian": 0.11700000000000002, "TestSolve": 0.40750000000000003, "TestTensorinv": 0.0215, "TestTensorsolve": 0.004}, "torch_np/test_basic": {"TestArrayToSequence": 0.009000000000000001, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.0045000000000000005, "TestDefaultDtype": 0.0085, "TestDivmod": 0.019500000000000003, "TestExport": 0.0, "TestMisc": 0.0015, "TestNormalizations": 0.00675, "TestOneArr": 0.3702500000000003, "TestOneArrAndAxesTuple": 0.013500000000000002, "TestOneArrAndAxis": 0.20375000000000013, "TestOneArrAndShape": 0.02200000000000001, "TestOneArrToScalar": 0.013500000000000002, "TestPythonArgsToArray": 0.0165, "TestSequenceOfArrays": 0.02400000000000001, "TestSequenceOfArraysToSingle": 0.01175, "TestShapeLikeToArray": 0.006, "TestSmokeNotImpl": 0.0015}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.49025000000000013}, "torch_np/test_dtype": {"TestConvertDType": 0.41750000000000004}, "torch_np/test_function_base": {"TestAppend": 0.34299999999999997}, "torch_np/test_ndarray_methods": {"TestAmax": 0.009000000000000001, "TestAmin": 0.009000000000000001, "TestArgmax": 1.3152500000000011, "TestArgmaxArgminCommon": 0.07150000000000004, "TestArgmin": 1.384000000000001, "TestContains": 0.003, "TestIndexing": 0.34975, "TestIter": 0.006, "TestNoExtraMethods": 0.009000000000000001, "TestNonzero": 0.171, "TestRavel": 0.009000000000000001, "TestReshape": 0.006500000000000001, "TestTranspose": 0.01125}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.021, "TestNEP50Table": 0.0025}, "torch_np/test_random": {"TestChoice": 0.015, "TestNumpyGlobal": 0.0045000000000000005, "TestScalarReturn": 0.38325, "TestShuffle": 0.016250000000000004}, "torch_np/test_reductions": {"TestAll": 0.01425, "TestAny": 0.01525, "TestFlatnonzero": 0.3235, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.555249999999938, "TestMean": 0.025, "TestSum": 0.25825}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.39925, "TestIsScalar": 0.04550000000000003}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.7415000000000005, "TestNdarrayDunderVsUfunc": 0.2410000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.381}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5170000000000001}}, "nogpu_NO_AVX2": {"backends/xeon/test_launch": {"TestTorchrun": 2.74475}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.8327500000000001}, "distributions/test_distributions": {"TestAgainstScipy": 1.6795, "TestConstraints": 0.21550000000000002, "TestDistributionShapes": 0.18800000000000008, "TestDistributions": 54.43975000000001, "TestFunctors": 0.0165, "TestJit": 29.626999999999995, "TestKL": 4.5482499999999995, "TestLazyLogitsInitialization": 0.018750000000000003, "TestNumericalStability": 0.10750000000000001, "TestRsample": 1.02175, "TestValidation": 0.51275}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.8455000000000001}, "dynamo/test_after_aot": {"TestAfterAot": 10.341000000000001}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 20.148000000000003}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.03775, "AOTAutogradCacheTests": 14.813500000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.250749999999998}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.055, "TestCustomBackendAPI": 2.5865, "TestExplainWithBackend": 16.4945, "TestOptimizations": 2.9844999999999993}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 19.109499999999997}, "dynamo/test_base_output": {"TestBaseOutput": 0.00425}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 9.337499999999999, "BytecodeTests": 0.7090000000000001}, "dynamo/test_compile": {"InPlaceCompilationTests": 11.210249999999998, "PublicTorchCompilerTests": 0.004}, "dynamo/test_comptime": {"ComptimeTests": 0.9510000000000002}, "dynamo/test_config": {"ConfigTests": 0.9252499999999999}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.9665000000000004}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.386}, "dynamo/test_decorators": {"DecoratorTests": 10.795499999999999}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.0225}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 52.501, "DynamicShapesCtxManagerTests": 7.567999999999999, "DynamicShapesExportTests": 43.67674999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 140.48724999999996, "DynamicShapesFunctionTests": 101.94725000000003, "DynamicShapesHigherOrderOpTests": 24.162999999999993, "DynamicShapesMiscTests": 124.14725000000004, "DynamicShapesNNModuleTests": 9.7195, "DynamicShapesReproTests": 145.31350000000003, "DynamicShapesSubGraphTests": 12.876750000000001, "DynamicShapesTestSDPA": 0.53025}, "dynamo/test_exc": {"ExcTests": 2.9935}, "dynamo/test_exceptions": {"ExceptionTests": 0.8752500000000001}, "dynamo/test_export": {"ExportTests": 23.21475}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8905000000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.3635}, "dynamo/test_functions": {"DefaultsTests": 1.1905000000000001, "FunctionTests": 34.7515000000001}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.7584999999999997}, "dynamo/test_global": {"TestGlobals": 0.8900000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.41425}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.11050000000000001, "FuncTorchHigherOrderOpTests": 11.679749999999999, "HigherOrderOpTests": 11.722749999999998, "HigherOrderOpVmapGuardTests": 5.693250000000001}, "dynamo/test_hooks": {"HooksTests": 38.89625}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 7.039999999999999, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 11.463749999999997, "InlineInbuiltNNModulesFunctionTests": 6.941249999999991, "InlineInbuiltNNModulesHigherOrderOpTests": 10.840499999999997, "InlineInbuiltNNModulesMiscTests": 77.8807500000001, "InlineInbuiltNNModulesNNModuleTests": 6.2464999999999975}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 12.75275}, "dynamo/test_interop": {"InteropTests": 0.9205}, "dynamo/test_logging": {"LoggingTests": 27.010750000000005}, "dynamo/test_minifier": {"MinifierTests": 2.1122499999999995}, "dynamo/test_misc": {"MiscTests": 85.12025000000014, "TestTracer": 0.086}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.00525}, "dynamo/test_modules": {"NNModuleTests": 4.224999999999998, "OptimizedModuleTest": 24.57625}, "dynamo/test_nops": {"NopTests": 0.4895}, "dynamo/test_optimizers": {"End2EndTests": 1.024}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.7935000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.9429999999999998}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.05275}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.3065000000000002}, "dynamo/test_recompiles": {"RecompileTests": 1.4005}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.8530000000000001}, "dynamo/test_repros": {"ReproTests": 56.42175}, "dynamo/test_resume": {"ResumeFunctionTests": 0.74675}, "dynamo/test_sdpa": {"TestSDPA": 0.7927500000000001}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.88575}, "dynamo/test_sources": {"SourceTests": 0.80525}, "dynamo/test_structured_trace": {"StructuredTraceTest": 17.748999999999995}, "dynamo/test_subclasses": {"SubclassTests": 4.571749999999998, "TestNestedTensor": 17.46725}, "dynamo/test_subgraphs": {"SubGraphTests": 3.4702499999999983}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.15175, "TraceRuleTests": 1.7859999999999996}, "dynamo/test_unspec": {"UnspecTests": 20.885499999999993}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.9730000000000001}, "dynamo/test_view": {"ViewTests": 1.0294999999999999}, "export/test_converter": {"TestConverter": 7.629750000000001}, "export/test_db": {"ExampleTests": 4.7205}, "export/test_experimental": {"TestExperiment": 1.48075}, "export/test_export": {"TestDynamismExpression": 0.6920000000000001, "TestExport": 43.05274999999999, "TestExportCustomClass": 0.10500000000000001, "TestOneOffModelExportResult": 1.66875}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.5905, "NonStrictExportTestExport": 37.98299999999999}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.362}, "export/test_hop": {"TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.14200000000000002}, "export/test_pass_infra": {"TestPassInfra": 1.3467500000000001}, "export/test_passes": {"TestPasses": 18.716}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.2095, "RetraceExportTestExport": 66.75674999999998}, "export/test_schema": {"TestSchema": 0.42200000000000004}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.8137500000000001, "SerDesExportTestExport": 47.29375}, "export/test_serialize": {"TestDeserialize": 11.508750000000003, "TestSaveLoad": 0.47625, "TestSchemaVersioning": 0.0485, "TestSerialize": 1.6010000000000004, "TestSerializeCustomClass": 0.13575}, "export/test_sparse": {"TestSparseProp": 90.36424999999991}, "export/test_tools": {"TestExportTools": 0.8745}, "export/test_torchbind": {"TestCompileTorchbind": 1.5730000000000004, "TestExportTorchbind": 2.6732499999999995, "TestRegisterFakeClass": 0.006500000000000001}, "export/test_tree_utils": {"TestTreeUtils": 0.363}, "export/test_unflatten": {"TestUnflatten": 4.67175}, "export/test_verifier": {"TestVerifier": 1.4217500000000003}, "functorch/test_aotdispatch": {"TestAOTAutograd": 18.163499999999996, "TestAOTAutogradWithDynamo": 19.846499999999992, "TestAOTDispatch": 0.725, "TestAOTExport": 3.4659999999999997, "TestAOTModuleSimplified": 0.9420000000000001, "TestPartitioning": 1.495}, "functorch/test_control_flow": {"TestControlFlow": 1.1102500000000002, "TestControlFlowTraced": 163.48174999999998}, "functorch/test_dims": {"TestMin": 23.421750000000003, "TestMinFunctorchOnly": 22.3645}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.14325000000000004, "TestSliceArgnums": 0.019500000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.41975}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.786, "RandomOpTestCase": 0.11399999999999999, "ReduceTestCase": 0.11925, "TestMemoryEfficientOpAuthoring": 0.0025}, "functorch/test_minifier": {"TestMinifier": 0.6552499999999999}, "functorch/test_parsing": {"TestAnonymousAxis": 0.36024999999999996, "TestParsedExpression": 0.008, "TestParsingUtils": 0.006500000000000001, "TestValidateRearrangeExpressions": 0.007}, "functorch/test_rearrange": {"TestRearrange": 0.4357500000000001}, "functorch/test_vmap": {"TestVmapAPI": 0.40675000000000017, "TestVmapOperators": 4.281999999999991}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.462499999999837}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.964500000000001}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 14.2725}, "inductor/test_binary_folding": {"FreezingCpuTests": 55.054500000000004}, "inductor/test_codecache": {"TestFxGraphCache": 58.80549999999998, "TestFxGraphCacheHashing": 1.011, "TestUtils": 5.17775, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.3565}, "inductor/test_compile_worker": {"TestCompileWorker": 11.95625}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 433.84175000000033, "TestCompiledAutograd": 266.55125000000004, "TestCustomOpWithCompiledAutograd": 0.7777500000000004}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 351.7090000000007}, "inductor/test_config": {"TestInductorConfig": 9.435749999999999}, "inductor/test_control_flow": {"CondTests": 0.1235, "WhileLoopTests": 0.006}, "inductor/test_cpu_repro": {"CPUReproTests": 985.1710000000003}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0035}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 16.521250000000002}, "inductor/test_debug_trace": {"TestDebugTrace": 5.0485}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0025}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 54.28}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 28.60625}, "inductor/test_flex_attention": {"TestFlexAttention": 0.021000000000000008}, "inductor/test_foreach": {"ForeachTests": 26.02775000000003}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 115.062, "SDPAPatternRewriterCpuTests": 110.17250000000001}, "inductor/test_fx_fusion": {"TestFxFusion": 0.29750000000000004}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.022}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.3085, "TestGroupBatchFusion": 0.00125, "TestPostGradBatchLinearFusion": 0.0005}, "inductor/test_indexing": {"ExprPrinterTests": 0.06650000000000002, "TestIndexingSimplification": 0.889}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 80.62075000000002}, "inductor/test_minifier": {"MinifierTests": 36.98975}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 71.78575000000001}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 232.921, "TestPatternMatcher": 810.1795}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 25.41325}, "inductor/test_torchbind": {"TestTorchbind": 14.6425}, "inductor/test_torchinductor": {"CpuTests": 2047.4832499999986, "SweepInputsCpuTest": 174.26299999999998, "TestFull": 15.6195}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2157.202749999998}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2283.7172499999997}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.90425}, "inductor/test_triton_kernels": {"KernelTests": 0.03775000000000002, "MutationTests": 0.0055}, "inductor/test_utils": {"TestUtils": 0.36624999999999996}, "lazy/test_debug_util": {"DebugUtilTest": 0.426}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.43899999999999995}, "lazy/test_generator": {"LazyGeneratorTest": 0.43925000000000003}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.8580000000000001}, "lazy/test_step_closures": {"ClosuresTest": 3.372}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.28450000000000003, "TestLazyTensor": 0.09749999999999999}, "nn/test_convolution": {"TestConvolutionNN": 21.277749999999997}, "nn/test_dropout": {"TestDropoutNN": 0.21225000000000002}, "nn/test_embedding": {"TestEmbeddingNN": 0.07325000000000004}, "nn/test_init": {"TestNNInit": 5.821499999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.5762500000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.82925, "TestLoadStateDictSwap": 0.06975}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.03075, "TestModuleHookNN": 0.09375000000000003, "TestModuleHooks": 0.12100000000000001, "TestStateDictHooks": 0.04400000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.84925}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5810000000000002}, "nn/test_parametrization": {"TestNNParametrization": 1.2822500000000003}, "nn/test_pooling": {"TestAvgPool": 0.3395, "TestPoolingNN": 0.50825}, "nn/test_pruning": {"TestPruningNN": 0.13975000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.17024999999999998}, "profiler/test_memory_profiler": {"TestDataFlow": 1.8459999999999996, "TestIdentifyGradients": 0.315, "TestMemoryProfiler": 0.378, "TestMemoryProfilerE2E": 4.516249999999999}, "profiler/test_profiler": {"TestExperimentalUtils": 5.912499999999998, "TestProfiler": 26.32275, "TestProfilerCUDA": 0.00125, "TestProfilerITT": 0.006}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.4727500000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.43450000000000005}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.276249999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.11325, "TestBaseDataScheduler": 0.0435, "TestBaseDataSparsifier": 0.09275, "TestBaseSparsifier": 0.0345, "TestBaseStructuredSparsifier": 1.8639999999999997, "TestComposability": 2.1334999999999997, "TestCubicScheduler": 0.00675, "TestFPGMPruner": 0.02875, "TestFakeSparsity": 0.10850000000000001, "TestFxComposability": 1.9749999999999999, "TestNearlyDiagonalSparsifier": 0.912, "TestNormDataSparsifiers": 1.06325, "TestQuantizationUtils": 0.02425, "TestQuantizedSparseKernels": 0.39349999999999996, "TestQuantizedSparseLayers": 0.4925, "TestSaliencyPruner": 0.0345, "TestScheduler": 0.021249999999999998, "TestSparsityUtilFunctions": 0.05025, "TestWeightNormSparsifier": 0.38025}, "test_autocast": {"TestAutocastCPU": 3.22925, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.00875}, "test_autograd": {"TestAllowMutationOnSaved": 0.04100000000000001, "TestAutograd": 25.71925000000006, "TestAutogradComplex": 0.0075, "TestAutogradForwardMode": 0.10975000000000004, "TestAutogradForwardModeBatchedGrad": 0.0245, "TestAutogradFunctional": 13.364749999999997, "TestAutogradInferenceMode": 0.04500000000000002, "TestAutogradLogging": 0.02025, "TestMultithreadAutograd": 0.278, "TestNestedCheckpoint": 0.5307500000000002, "TestSelectiveActivationCheckpoint": 0.0205}, "test_autograd_fallback": {"TestAutogradFallback": 0.5280000000000001}, "test_bundled_inputs": {"TestBundledInputs": 2.455999999999999}, "test_comparison_utils": {"TestComparisonUtils": 0.3705}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_cpp_api_parity": {"TestCppApiParity": 5.265999999999984}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03425000000000001, "TestMAIATensor": 0.0115, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03350000000000001, "TestMAIATensor": 0.01575, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 63.486000000000004}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.14375}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 12.435250000000003}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.1412499999999999}, "test_custom_backend": {"TestCustomBackend": 0.11424999999999999}, "test_custom_ops": {"MiniOpTest": 0.8642500000000003, "MiniOpTestOther": 0.08225000000000002, "TestCustomOp": 3.6869999999999905, "TestCustomOpAPI": 0.16800000000000004, "TestCustomOperators": 0.43125, "TestGenerateOpcheckTests": 4.498}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.06725, "TestCustomPinFn": 0.00275, "TestDataLoader": 113.52975, "TestDataLoaderPersistentWorkers": 130.31925, "TestDatasetRandomSplit": 0.038250000000000006, "TestDictDataLoader": 0.059250000000000004, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.00675, "TestSetAffinity": 0.091, "TestStackDataset": 0.041499999999999995, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.028500000000000004}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.0022500000000000003, "TestFunctionalIterDataPipe": 7.381499999999998, "TestFunctionalMapDataPipe": 0.045, "TestGraph": 0.02075, "TestIterDataPipeCountSampleYielded": 0.015000000000000001, "TestIterDataPipeGraphFastForward": 0.05750000000000001, "TestIterDataPipeSingletonConstraint": 0.028500000000000004, "TestIterableDataPipeBasic": 0.037500000000000006, "TestSerialization": 8.4795, "TestSharding": 0.26875000000000004, "TestStreamWrapper": 0.3665, "TestTyping": 0.0055}, "test_decomp": {"HasDecompTest": 0.23199999999999998}, "test_deploy": {"TestFreezer": 0.37875000000000003}, "test_dispatch": {"TestDispatch": 42.55799999999999, "TestPythonDispatcher": 0.07025}, "test_dynamic_shapes": {"TestDimConstraints": 2.7225, "TestFloorDiv": 0.0145, "TestGuardsExpressions": 0.020499999999999997, "TestPySymInt": 1.6849999999999992, "TestSymNumberMagicMethods": 2.1417499999999934}, "test_fake_tensor": {"FakeTensorConstHandling": 0.10800000000000001, "FakeTensorConverterTest": 0.03425, "FakeTensorDispatchCache": 0.094, "FakeTensorOperatorInvariants": 0.6185, "FakeTensorPropTest": 0.098, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 2.186, "PropagateRealTensorsFakeTensorConstHandling": 0.186, "PropagateRealTensorsFakeTensorConverterTest": 0.03225, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.25075000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.06899999999999999, "PropagateRealTensorsFakeTensorTest": 0.3430000000000001}, "test_flop_counter": {"TestFlopCounter": 0.7705}, "test_function_schema": {"TestFunctionSchema": 0.8615}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 45.423}, "test_functional_optim": {"TestFunctionalOptimParity": 0.516}, "test_functionalization": {"TestCrossRefFunctionalization": 3.659499999999998, "TestFunctionalization": 3.9052499999999983}, "test_futures": {"TestFuture": 1.3242500000000001}, "test_fx": {"AnnotationsTest": 0.018750000000000006, "TestCSEPass": 0.36025000000000007, "TestCommonPass": 0.08625, "TestConstFold": 0.21550000000000008, "TestConstParamShapeInControlFlow": 0.05925, "TestDCE": 0.0415, "TestFX": 4.908499999999995, "TestFXAPIBackwardCompatibility": 0.039999999999999994, "TestFunctionalTracing": 0.46100000000000035, "TestMatcher": 0.5335000000000001, "TestPassManager": 0.032, "TestSourceMatcher": 1.5772500000000003, "TestSubgraphRewriter": 0.3932500000000001, "TestVisionTracing": 409.80075, "TypeCheckerTest": 3.3084999999999996}, "test_fx_experimental": {"TestFXExperimental": 25.349250000000005, "TestTranslationValidation": 0.16049999999999998}, "test_fx_passes": {"TestFXGraphPasses": 0.9007500000000003, "TestFXMatcherUtils": 0.1365}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.6137500000000002}, "test_import_stats": {"TestImportTime": 5.28025}, "test_itt": {"TestItt": 0.36375}, "test_jit": {"TestAliasAnalysis": 0.472, "TestAsync": 0.4277500000000001, "TestAtenPow": 0.01025, "TestAutodiffJit": 0.087, "TestAutodiffSubgraphSlicing": 0.36975000000000013, "TestAwait": 0.2652500000000001, "TestBackends": 0.8280000000000001, "TestBackendsWithCompiler": 0.1805, "TestBatchMM": 0.11375, "TestBuiltins": 0.07575000000000001, "TestClassType": 3.5462499999999992, "TestComplex": 1.1667500000000004, "TestCustomOperators": 0.054250000000000013, "TestDCE": 0.025, "TestDataParallel": 0.0025, "TestDataclasses": 5.524249999999999, "TestDeviceAnalysis": 5.190499999999998, "TestDict": 0.49800000000000016, "TestDtypeAnalysis": 0.19474999999999998, "TestEnum": 0.31700000000000006, "TestFreezing": 3.1050000000000004, "TestFrontend": 0.5595, "TestFrozenOptimizations": 15.271249999999997, "TestFunctionalBlocks": 0.009250000000000001, "TestFunctionalToInplaceActivation": 3.21, "TestGenerator": 0.086, "TestGetDefaultAttr": 0.019250000000000003, "TestGraphRewritePasses": 0.049, "TestHash": 0.10824999999999999, "TestHooks": 0.8950000000000002, "TestIgnorableArgs": 0.016, "TestIgnoreContextManager": 0.052750000000000005, "TestInplaceToFunctionalActivation": 3.1407499999999997, "TestIsinstance": 0.2970000000000001, "TestJit": 7.078749999999989, "TestJitGeneratedModule": 13.84924999999998, "TestJitProfiler": 0.0015, "TestJitUtils": 0.024500000000000004, "TestList": 1.5250000000000006, "TestLogging": 0.05925, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.23675000000000007, "TestMixTracingScripting": 1.57575, "TestModels": 2.2437499999999986, "TestModuleAPIs": 0.1705, "TestModuleContainers": 1.7355, "TestModuleInterface": 0.7227500000000002, "TestModules": 0.0175, "TestNamedTuple": 0.08375000000000002, "TestNnapiBackend": 12.693, "TestOpDecompositions": 0.019750000000000004, "TestOptimizeForMobilePreserveDebugInfo": 0.22825000000000004, "TestPDT": 0.4192500000000001, "TestParametrization": 0.11475000000000002, "TestPeephole": 0.6177500000000002, "TestProducerVersion": 0.0015, "TestProfiler": 0.81225, "TestPythonBindings": 0.04675, "TestPythonBuiltinOP": 0.49550000000000005, "TestPythonIr": 0.03475, "TestRecursiveScript": 0.8167500000000002, "TestRemoveMutation": 0.17025, "TestSaveLoad": 0.7827500000000001, "TestSaveLoadFlatbuffer": 0.6850000000000002, "TestSaveLoadForOpVersion": 3.16775, "TestScript": 47.15975000000003, "TestScriptDict": 0.0335, "TestScriptList": 0.8932500000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.27075000000000005, "TestScriptProfile": 0.4445, "TestSlice": 0.21200000000000005, "TestSparse": 0.0675, "TestStringFormatting": 0.15725000000000006, "TestSymbolicShapeAnalysis": 1.9542499999999987, "TestTensorBuiltins": 0.093, "TestTensorCreationOps": 0.057499999999999996, "TestTensorMethods": 0.0155, "TestTorchbind": 0.17575000000000005, "TestTracer": 3.3364999999999956, "TestTypeSharing": 0.5690000000000002, "TestTypesAndAnnotation": 0.16225000000000003, "TestTyping": 0.47975000000000023, "TestUnion": 0.5797500000000003, "TestUnsupportedOps": 0.03325, "TestUpgraders": 0.11025000000000001, "TestWarn": 0.07, "TestWith": 0.7455}, "test_jit_autocast": {"TestAutocast": 0.13525, "TestJitTraceAutocast": 22.963500000000003}, "test_jit_disabled": {"TestJitDisabled": 0.49350000000000005}, "test_jit_fuser_te": {"TestFuserCommon": 0.20124999999999998, "TestTEFuserDynamic": 135.72150000000005, "TestTEFuserStatic": 54.97500000000003}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.10500000000000001, "TestModel": 4.0017499999999995}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.23475, "TestVmapOperatorsLegacy": 1.1947500000000002}, "test_license": {"TestLicense": 0.38725}, "test_logging": {"LoggingTest": 3.69025}, "test_maskedtensor": {"TestBinary": 0.4320000000000003, "TestReductions": 0.10425000000000004, "TestUnary": 0.37775000000000025}, "test_meta": {"TestMetaConverter": 0.07950000000000004}, "test_mkl_verbose": {"TestMKLVerbose": 5.8950000000000005}, "test_mkldnn_fusion": {"TestMkldnnFusion": 93.01225}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.3975}, "test_mobile_optimizer": {"TestOptimizer": 4.0925}, "test_model_dump": {"TestModelDump": 1.3940000000000001}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.30175}, "test_module_tracker": {"TestModuleTracker": 0.37124999999999997}, "test_monitor": {"TestMonitor": 0.3755, "TestMonitorTensorboard": 0.19875}, "test_multiprocessing": {"TestMultiprocessing": 69.33324999999999}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.92025, "SpawnTest": 39.704750000000004}, "test_namedtensor": {"TestNamedTensor": 0.5117500000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.39475}, "test_native_functions": {"TestNativeFunctions": 0.5172500000000001}, "test_nestedtensor": {"TestNestedTensor": 0.1875000000000001}, "test_nn": {"TestAddRelu": 0.007, "TestConstantPadNd": 0.00575, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.44399999999999995, "TestFusionUtils": 0.006, "TestNN": 65.01175000000009, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.006}, "test_openmp": {"TestOpenMP_ParallelFor": 6.188}, "test_ops": {"TestSelfKwarg": 0.0045000000000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.26075000000000004, "TestLRScheduler": 1.3567500000000008, "TestSWAUtils": 0.23099999999999998}, "test_out_dtype_op": {"TestOutDtypeOp": 0.42200000000000004}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.03225, "TestGradCheckOverride": 0.026749999999999996, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.009000000000000001, "TestIterator": 0.002, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.003, "TestResolveName": 0.13125, "TestTorchFunctionMode": 0.04575000000000003, "TestTorchFunctionOverride": 2.53699999999989, "TestTorchFunctionWarning": 0.0195, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.06275, "ModelTest": 0.0, "TestAnalyze": 0.35125, "TestDependencyAPI": 0.06750000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.019500000000000003, "TestGlobGroup": 0.027500000000000014, "TestImporter": 0.015000000000000003, "TestLoadBCPackages": 0.09275, "TestMangling": 0.022250000000000006, "TestMisc": 0.05875000000000001, "TestPackageFX": 0.08675, "TestPackageScript": 2.8659999999999997, "TestRepackage": 0.01225, "TestResources": 0.015, "TestSaveLoad": 0.046}, "test_per_overload_api": {"TestPerOverloadAPI": 0.364}, "test_prims": {"TestPrimsBasic": 0.02475}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.20475, "TestGenericProxyTensorFake": 3.11875, "TestGenericProxyTensorReal": 3.3089999999999993, "TestGenericProxyTensorSymbolic": 22.4625, "TestRealProxyTensor": 0.03475, "TestSymbolicTracing": 4.930999999999999}, "test_pruning_op": {"PruningOpTest": 0.60375}, "test_public_bindings": {"TestPublicBindings": 7.984499999999999}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.3347500000000001, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.277}, "test_pytree": {"TestCxxPytree": 0.02550000000000001, "TestGenericPytree": 0.5062500000000001, "TestPythonPytree": 0.08375000000000005}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.018000000000000002, "TestAOMigrationNNQuantized": 0.07725000000000001, "TestAOMigrationQuantization": 0.028250000000000004, "TestAOMigrationQuantizationFx": 0.029000000000000005, "TestBackendConfig": 0.06600000000000003, "TestBiasCorrectionEager": 2.72175, "TestComparatorOps": 1.7705, "TestDeprecatedJitQuantized": 5.7372499999999995, "TestDistributed": 0.03275, "TestDuplicateDQPass": 4.17675, "TestDynamicQuantizedModule": 65.594, "TestDynamicQuantizedOps": 39.09025, "TestEqualizeEager": 0.11000000000000001, "TestEqualizeFx": 7.602500000000001, "TestFXGraphMatcher": 2.4799999999999995, "TestFXGraphMatcherModels": 12.761, "TestFXNumericSuiteCoreAPIs": 35.17, "TestFXNumericSuiteCoreAPIsModels": 51.15375, "TestFXNumericSuiteNShadows": 49.18900000000001, "TestFakeQuantize": 0.36524999999999996, "TestFakeQuantizeOps": 2.5214999999999987, "TestFuseEager": 3.64175, "TestFuseFx": 2.8374999999999995, "TestFusedObsFakeQuant": 0.10175000000000001, "TestFusedObsFakeQuantModule": 0.28975000000000006, "TestFusionPasses": 0.026250000000000002, "TestFxDetectInputWeightEqualization": 0.36775, "TestFxDetectOutliers": 0.3465, "TestFxModelReportClass": 0.60675, "TestFxModelReportDetectDynamicStatic": 0.07550000000000001, "TestFxModelReportDetector": 0.237, "TestFxModelReportObserver": 0.2455, "TestFxModelReportVisualizer": 0.2575, "TestGenerateNumericDebugHandle": 1.00075, "TestGraphUtils": 2.87175, "TestHistogramObserver": 45.39574999999999, "TestMetaDataPorting": 8.398, "TestModelNumericsEager": 1.3405, "TestNumericSuiteEager": 11.3355, "TestObserver": 4.8895, "TestPT2ERepresentation": 35.564750000000004, "TestPadding": 30.633499999999998, "TestQNNPackOps": 8.399, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.564, "TestQuantizeDynamicJitPasses": 6.294499999999999, "TestQuantizeEagerOps": 1.9782499999999996, "TestQuantizeEagerPTQDynamic": 9.9595, "TestQuantizeEagerPTQStatic": 36.50875, "TestQuantizeEagerQAT": 15.184249999999999, "TestQuantizeEagerQATNumerics": 2.4777499999999995, "TestQuantizeFx": 54.90825000000001, "TestQuantizeFxModels": 8.657499999999999, "TestQuantizeFxOps": 153.45225000000005, "TestQuantizeJit": 25.87575, "TestQuantizeJitOps": 298.51650000000006, "TestQuantizeJitPasses": 6.6595, "TestQuantizePT2E": 63.654250000000005, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 401.42225, "TestQuantizePT2EQAT_ConvBn2d": 406.68724999999995, "TestQuantizePT2EX86Inductor": 104.01825, "TestQuantizedConv": 79.2185, "TestQuantizedEmbeddingOps": 2.3840000000000003, "TestQuantizedFunctionalOps": 6.1819999999999995, "TestQuantizedLinear": 28.8325, "TestQuantizedOps": 150.83325000000002, "TestQuantizedTensor": 2.3594999999999993, "TestRecordHistogramObserver": 0.0415, "TestReferenceQuantizedModule": 0.0605, "TestSerialization": 2.45775, "TestStaticQuantizedModule": 107.6765, "TestSubgraphRewriter": 1.1540000000000001, "TestUtils": 0.025, "TestXNNPACKQuantizer": 51.07899999999999, "TestXNNPACKQuantizerModels": 4.33375}, "test_schema_check": {"TestSchemaCheck": 0.15450000000000008}, "test_serialization": {"TestOldSerialization": 59.30175000000003, "TestSerialization": 13.963750000000026, "TestSubclassSerialization": 0.038000000000000006}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.36824999999999997}, "test_show_pickle": {"TestShowPickle": 0.43}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.03875, "TestSparseMeta": 4.97725, "TestSparseOneOff": 0.00275}, "test_sparse_csr": {"TestSparseCSRSampler": 0.64925}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_stateless": {"TestPythonOptimizeMode": 5.4775, "TestStatelessDeprecation": 2.51325, "TestStatelessFunctionalAPI": 0.2935000000000001}, "test_subclass": {"TestSubclass": 0.6122500000000002}, "test_sympy_utils": {"TestSingletonInt": 0.0075, "TestSympyInterp": 11.932499999999997, "TestSympySolve": 0.44400000000000006, "TestValueRanges": 8.009499999999996}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.026750000000000003, "TestTensorBoardFigure": 0.0025, "TestTensorBoardNumpy": 0.006, "TestTensorBoardPyTorchNumpy": 0.2465, "TestTensorBoardPytorchGraph": 46.766, "TestTensorBoardSummary": 0.06925, "TestTensorBoardSummaryWriter": 0.01025, "TestTensorBoardUtils": 0.22475, "TestTensorBoardWriter": 0.1345, "TestTensorProtoSummary": 0.013500000000000002}, "test_tensorexpr": {"TestTensorExprFuser": 70.36124999999998}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.0125, "TestTensorExprPyBind": 1.2352500000000002}, "test_testing": {"TestAssertClose": 0.1625000000000001, "TestAssertCloseContainer": 0.009000000000000001, "TestAssertCloseErrorMessage": 0.07075000000000002, "TestAssertCloseQuantized": 0.03875, "TestAssertCloseSparseBSC": 0.021, "TestAssertCloseSparseBSR": 0.021, "TestAssertCloseSparseCOO": 0.027500000000000004, "TestAssertCloseSparseCSC": 0.021, "TestAssertCloseSparseCSR": 0.022, "TestFrameworkUtils": 17.5555, "TestImports": 17.00925, "TestOpInfos": 0.006500000000000001, "TestTestParametrization": 0.040500000000000015}, "test_torch": {"TestBasicVitalSigns": 0.035750000000000004, "TestTorch": 7.864999999999988}, "test_type_hints": {"TestTypeHints": 0.35724999999999996}, "test_type_info": {"TestDTypeInfo": 0.3835}, "test_typing": {"TestTyping": 107.04975000000005}, "test_utils": {"TestAssert": 0.083, "TestBottleneck": 13.033, "TestCheckpoint": 0.12200000000000003, "TestCollectEnv": 1.322, "TestCppExtensionUtils": 0.04525, "TestDataLoaderUtils": 0.32625000000000004, "TestExtensionUtils": 0.006, "TestHipify": 0.0015, "TestHipifyTrie": 0.009750000000000002, "TestONNXUtils": 0.00575, "TestRenderUtils": 0.0195, "TestStandaloneCPPJIT": 3.4825, "TestTraceback": 0.013000000000000001}, "test_vulkan": {"TestVulkanRewritePass": 0.0035}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.028000000000000004, "WeakKeyDictionaryTestCase": 0.0285, "WeakTest": 5.953249999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 6.34875, "TestXNNPACKRewritePass": 1.9705, "TestXNNPACKSerDes": 6.911249999999999}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.00275}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.384, "TestClassGetItem": 0.00125, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.002, "TestMisc": 0.0055000000000000005, "TestPickling": 0.14200000000000002, "TestPromotion": 0.002}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 19.386000000000003, "TestEinsumPath": 0.0015, "TestMisc": 0.0072499999999999995}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0025, "TestHalf": 0.001, "TestIinfo": 0.39825, "TestMisc": 0.0035, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.0085, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.009000000000000001, "TestIndexing": 0.5332500000000002, "TestMultiIndexingAutomated": 0.009000000000000001, "TestMultipleEllipsisError": 0.00425, "TestNonIntegerArrayLike": 0.0005}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.0315, "TestArgmax": 1.325000000000001, "TestArgmaxArgminCommon": 0.07650000000000004, "TestArgmin": 1.401250000000001, "TestArrayAttributeDeletion": 0.00975, "TestArrayConstruction": 0.049750000000000016, "TestArrayCreationCopyArgument": 0.0005, "TestAssignment": 0.013250000000000001, "TestAttributes": 0.029750000000000006, "TestBinop": 0.0215, "TestBool": 29.354750000000003, "TestCequenceMethods": 0.003, "TestChoose": 0.02525, "TestClip": 0.0075, "TestCompress": 0.0055, "TestConversion": 0.0425, "TestCreation": 0.0015, "TestDelMisc": 0.002, "TestDot": 0.08875000000000004, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.020000000000000004, "TestFormat": 0.006500000000000001, "TestFromBuffer": 0.017500000000000005, "TestHash": 0.22199999999999998, "TestHashing": 0.00425, "TestIO": 0.0015, "TestInner": 0.2615, "TestLexsort": 0.023, "TestMatmul": 0.5210000000000001, "TestMatmulOperator": 0.36225000000000007, "TestMethods": 1.7170000000000005, "TestMinMax": 0.0075, "TestMinScalarType": 0.0075, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.0005, "TestPutmask": 0.015, "TestRepeat": 0.01625, "TestResize": 0.05700000000000001, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.026500000000000003, "TestSortFloatMisc": 0.20225, "TestStats": 0.298, "TestSubscripting": 0.00275, "TestTake": 0.047000000000000014, "TestVdot": 0.04725, "TestWarnings": 0.003, "TestWhere": 0.42850000000000005, "TestWritebackIfCopy": 0.03625}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.02525, "TestArgwhere": 0.034, "TestArrayComparisons": 0.018500000000000003, "TestBaseRepr": 0.011, "TestBinaryRepr": 0.0155, "TestBoolArray": 2.6152499999999996, "TestBoolCmp": 0.20625000000000002, "TestBoolScalar": 0.011, "TestBroadcast": 0.008, "TestClip": 0.23550000000000013, "TestConvolve": 0.020999999999999998, "TestCorrelate": 0.05499999999999999, "TestCreationFuncs": 1.2937500000000002, "TestCross": 0.07750000000000001, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.01075, "TestFromiter": 0.0, "TestIndex": 0.011000000000000001, "TestIndices": 0.0495, "TestIsclose": 0.10275000000000001, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.015, "TestNonarrayArgs": 0.14500000000000007, "TestNonzeroAndCountNonzero": 0.3105000000000001, "TestOuterMisc": 0.006500000000000001, "TestRequire": 0.006500000000000001, "TestResize": 0.3885, "TestRoll": 0.0395, "TestRollaxis": 0.006, "TestSeterr": 0.009000000000000001, "TestStdVar": 0.035750000000000004, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0025, "TestTensordot": 0.018000000000000002, "TestTypes": 0.017750000000000002}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.3715, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.1485000000000001, "TestFromInt": 0.009500000000000001, "TestFromString": 0.39975}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.002, "TestBitCount": 0.0, "TestClassGetItem": 0.0005, "TestClassGetitemMisc": 0.0015, "TestIsInteger": 0.001}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.00125}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.128, "TestBaseMath": 11.34075, "TestBitShifts": 0.11699999999999999, "TestComplexDivision": 0.07750000000000001, "TestConversion": 0.084, "TestHash": 0.0015, "TestModulus": 1.2385000000000002, "TestMultiply": 0.00075, "TestNegative": 0.02375, "TestPower": 0.18775000000000003, "TestRepr": 0.0025, "TestScalarOpsMisc": 0.07625000000000004, "TestScalarSubclassingMisc": 0.015500000000000003, "TestSubtract": 0.0235, "TestTypes": 18.27275}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.38875000000000004, "TestAtleast2d": 0.0205, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.03600000000000002, "TestConcatenate": 0.21075000000000013, "TestHstack": 0.022250000000000002, "TestStackMisc": 0.0085, "TestVstack": 0.02375}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.013499999999999998, "TestFFTShift": 8.13875, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.013249999999999998}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.6149999999999998, "TestFFTShift": 0.3715, "TestFFTThreadSafe": 0.97}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.4035}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.008000000000000004, "TestUnique": 0.6275000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0105, "TestAmin": 0.0095, "TestAngle": 0.013, "TestAny": 0.009000000000000001, "TestAverage": 0.03425, "TestBincount": 0.065, "TestCheckFinite": 0.003, "TestCopy": 0.0105, "TestCorrCoef": 0.07375000000000001, "TestCov": 0.08025000000000002, "TestCumprod": 0.03875000000000001, "TestCumsum": 0.05825, "TestDelete": 0.0235, "TestDiff": 0.097, "TestDigitize": 0.022000000000000006, "TestExtins": 0.008, "TestFilterwindows": 0.7422500000000005, "TestFlip": 0.04100000000000001, "TestGradient": 0.17675000000000002, "TestInsert": 0.014, "TestInterp": 0.07150000000000004, "TestKaiser": 0.013500000000000002, "TestMedian": 0.13225000000000003, "TestMeshgrid": 0.07125000000000001, "TestMsort": 0.0, "TestPercentile": 0.08200000000000005, "TestPiecewise": 0.015500000000000002, "TestProd": 0.038, "TestPtp": 0.015000000000000001, "TestQuantile": 0.022750000000000006, "TestRot90": 0.43700000000000006, "TestSelect": 0.012, "TestSinc": 0.0105, "TestSortComplex": 0.013750000000000002, "TestTrapz": 0.00775, "TestTrimZeros": 0.015250000000000003, "TestUnique": 0.006, "Test_I0": 0.023}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.5165000000000001, "TestHistogramOptimBinNums": 0.04250000000000001, "TestHistogramdd": 0.16075}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0015, "TestConcatenator": 0.009500000000000001, "TestDiagIndices": 0.006500000000000001, "TestDiagIndicesFrom": 0.009500000000000001, "TestFillDiagonal": 0.034, "TestGrid": 0.012, "TestIndexExpression": 0.013500000000000002, "TestIx_": 0.009000000000000001, "TestNdIndex": 0.0015, "TestNdenumerate": 0.0015, "TestRavelUnravelIndex": 0.3875}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.020250000000000004, "TestApplyOverAxes": 0.0025, "TestArraySplit": 0.21250000000000002, "TestColumnStack": 0.013000000000000001, "TestDsplit": 0.012, "TestDstack": 0.023, "TestExpandDims": 0.011, "TestHsplit": 0.017, "TestKron": 0.019250000000000003, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.014499999999999999, "TestSplit": 0.009000000000000001, "TestSqueeze": 0.045250000000000005, "TestTakeAlongAxis": 0.4295, "TestTile": 0.10550000000000001, "TestVsplit": 0.0115}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.41250000000000003, "TestFliplr": 0.007, "TestFlipud": 0.006, "TestHistogram2d": 0.042, "TestTri": 0.11275000000000002, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.004750000000000001, "TestTriuIndicesFrom": 0.003, "TestVander": 0.02425}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.002, "TestCommonType": 0.37775000000000003, "TestImag": 0.016, "TestIscomplex": 0.008, "TestIscomplexobj": 0.007, "TestIsfinite": 0.021, "TestIsinf": 0.0315, "TestIsnan": 0.021, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.01225, "TestIsrealobj": 0.0025, "TestIsscalar": 0.003, "TestMintypecode": 0.019000000000000003, "TestNanToNum": 0.020750000000000005, "TestReal": 0.021, "TestRealIfClose": 0.006500000000000001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.24775000000000003, "TestCond": 0.27025, "TestDet": 0.19425, "TestEig": 0.04825000000000001, "TestEigh": 0.03475000000000001, "TestEighCases": 0.0, "TestEigvals": 0.11000000000000001, "TestEigvalsh": 0.03300000000000001, "TestEigvalshCases": 0.0, "TestInv": 0.0655, "TestLstsq": 0.26025, "TestMatrixRank": 0.47625, "TestMisc": 0.03025, "TestMisc2": 0.00425, "TestMultiDot": 0.06925, "TestNormDouble": 0.9804999999999999, "TestNormInt64": 0.97925, "TestNormSingle": 1.0, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.13925, "TestPinvHermitian": 0.05675, "TestQR": 0.5202500000000001, "TestSVD": 0.06150000000000001, "TestSVDHermitian": 0.12100000000000002, "TestSolve": 0.434, "TestTensorinv": 0.025999999999999995, "TestTensorsolve": 0.0055000000000000005}, "torch_np/test_basic": {"TestArrayToSequence": 0.010000000000000002, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.004750000000000001, "TestDefaultDtype": 0.010499999999999999, "TestDivmod": 0.020500000000000004, "TestExport": 0.00025, "TestMisc": 0.002, "TestNormalizations": 0.0075, "TestOneArr": 0.38300000000000023, "TestOneArrAndAxesTuple": 0.013750000000000002, "TestOneArrAndAxis": 0.21625000000000014, "TestOneArrAndShape": 0.02275000000000001, "TestOneArrToScalar": 0.019000000000000003, "TestPythonArgsToArray": 0.017, "TestSequenceOfArrays": 0.03125000000000001, "TestSequenceOfArraysToSingle": 0.014750000000000001, "TestShapeLikeToArray": 0.008, "TestSmokeNotImpl": 0.0015}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5227500000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.45625000000000004}, "torch_np/test_function_base": {"TestAppend": 0.36524999999999996}, "torch_np/test_ndarray_methods": {"TestAmax": 0.01, "TestAmin": 0.009500000000000001, "TestArgmax": 1.2670000000000008, "TestArgmaxArgminCommon": 0.07600000000000004, "TestArgmin": 1.522000000000001, "TestContains": 0.003, "TestIndexing": 0.3675, "TestIter": 0.006, "TestNoExtraMethods": 0.009500000000000001, "TestNonzero": 0.17625000000000002, "TestRavel": 0.009000000000000001, "TestReshape": 0.006, "TestTranspose": 0.012}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.0195, "TestNEP50Table": 0.0025}, "torch_np/test_random": {"TestChoice": 0.01575, "TestNumpyGlobal": 0.00575, "TestScalarReturn": 0.41250000000000003, "TestShuffle": 0.016500000000000004}, "torch_np/test_reductions": {"TestAll": 0.0155, "TestAny": 0.0165, "TestFlatnonzero": 0.363, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.6559999999999384, "TestMean": 0.026500000000000003, "TestSum": 0.26425}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.397, "TestIsScalar": 0.03750000000000002}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.8460000000000005, "TestNdarrayDunderVsUfunc": 0.2450000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.41550000000000004}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5665000000000002}}}, "linux-focal-cuda11.8-py3.10-gcc9": {"distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": {"TestFullyShardAutograd": 16.699}, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormMultiThread": 6.7763333333333335, "TestClipGradNormWorldSize2": 7.085666666666666, "TestClipGradNormWorldSize4": 4.412333333333333}, "distributed/_composable/fsdp/test_fully_shard_collectives": {"TestFullyShardCollectives": 81.51899999999999}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 6.949333333333333, "TestFullyShardCollectiveOps": 92.87, "TestFullyShardCommunication": 10.094666666666667, "TestFullyShardPrefetch": 17.275333333333332, "TestFullyShardUnshard": 4.8806666666666665, "TestFullyShardUnshardMultiProcess": 5.246666666666667, "TestFullyShardUnshardMultiThread": 0.022333333333333334}, "distributed/_composable/fsdp/test_fully_shard_compile": {"TestFullyShardCompile": 5.213, "TestFullyShardCompileCompute": 0.001}, "distributed/_composable/fsdp/test_fully_shard_extensions": {"TestFullyShardAllGatherExtensionsMultiProcess": 9.370666666666667, "TestFullyShardAllGatherExtensionsMultiThread": 1.6166666666666665}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 19.640333333333334}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.154, "TestFullyShardDeviceTensor": 0.11633333333333333, "TestFullyShardHSDPBroadcast": 0.6456666666666667, "TestFullyShardLazyInit": 0.067, "TestFullyShardManagedModulesAndStates": 0.02866666666666667, "TestFullyShardMeshArg": 0.008, "TestFullyShardMetaDeviceInit": 4.438666666666667, "TestFullyShardParamModuleInfos": 0.013000000000000003, "TestFullyShardProcessGroupInit": 0.7639999999999999, "TestFullyShardShardedParameterDTensor": 0.09200000000000001, "TestFullyShardShardedParameterTensor": 0.075}, "distributed/_composable/fsdp/test_fully_shard_memory": {"TestFullyShardMemory": 6.178999999999999}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionCasts": 0.8713333333333334, "TestFullyShardMixedPrecisionTraining": 20.31233333333333}, "distributed/_composable/fsdp/test_fully_shard_overlap": {"TestFullyShardOverlap": 21.275}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.15533333333333335}, "distributed/_composable/fsdp/test_fully_shard_state_dict": {"TestFullyShardStateDict": 11.610999999999999, "TestFullyShardStateDictMultiProcess": 16.626, "TestFullyShardStateDictMultiThread": 0.23}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 22.539, "TestFullyShard1DTrainingCore": 99.44866666666667, "TestFullyShard2DTraining": 39.714, "TestFullyShardCastAfterInit": 0.515, "TestFullyShardCustomForwardMethod": 5.2796666666666665, "TestFullyShardForwardInputs": 0.122, "TestFullyShardGradientAccumulation": 20.67866666666667, "TestFullyShardHSDPTraining": 19.736666666666665, "TestFullyShardNDTraining": 4.712666666666666, "TestFullyShardRegisteredParams": 1.2076666666666667, "TestFullyShardSharedParams": 6.849666666666667, "test_fully_shard_training": 0.001}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 0.001}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 27.268999999999995}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 4.903666666666666}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 21.977666666666664}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 9.848666666666666}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 12.726666666666667}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 4.705333333333333}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 0.24433333333333332}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 42.01066666666666}, "distributed/_composable/test_contract": {"TestContract": 0.311}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 7.818666666666666, "ReplicateTest": 26.075}, "distributed/_composable/test_replicate_with_compiler": {"DDP_TP_Test": 0.001, "ReplicateTest": 72.45400000000001}, "distributed/_shard/sharded_optim/test_sharded_optim": {"TestShardedOptimizer": 7.687333333333332}, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": {"TestShardedTensorBinaryOps": 15.212666666666669}, "distributed/_shard/sharded_tensor/ops/test_embedding": {"TestShardedEmbedding": 7.683333333333334}, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": {"TestShardedEmbeddingBag": 7.678333333333335}, "distributed/_shard/sharded_tensor/ops/test_init": {"TestShardedTensorNNInit": 11.499666666666668}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 18.68766666666667}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.302}, "distributed/_shard/sharded_tensor/test_sharded_tensor": {"TestCreateTensorFromParams": 0.08266666666666667, "TestCreateTensorNoProcessGroupMode": 0.004, "TestLocalTensor": 7.5263333333333335, "TestModuleHookApi": 7.493333333333333, "TestShardMetadata": 7.526666666666666, "TestShardParameter": 7.529333333333334, "TestShardTensor": 11.171333333333335, "TestShardedTensorChunked": 82.25266666666664, "TestShardedTensorCustomOps": 11.173000000000002, "TestShardedTensorEnumerable": 52.150666666666666, "TestShardedTensorFromLocalShards": 37.29866666666667, "TestShardedTensorFromLocalTensor": 7.425666666666667, "TestShardedTensorMetadata": 0.3459999999999999, "TestShardedTensorSubGroupInit": 0.023333333333333334}, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": {"TestReshard": 7.723333333333333}, "distributed/_shard/sharding_plan/test_sharding_plan": {"TestShardingPlan": 11.33}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 12.241666666666667, "TestShardingSpec": 0.043333333333333335}, "distributed/_shard/test_sharder": {"TestCustomSharder": 7.646333333333334}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 0.42266666666666675}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.4546666666666667}, "distributed/_tensor/experimental/test_local_map": {"TestLocalMap": 18.352999999999998}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 16.148666666666667}, "distributed/_tensor/test_api": {"DTensorAPITest": 30.302666666666667}, "distributed/_tensor/test_attention": {"RingAttentionTest": 3.834666666666666}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 38.12733333333333}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 35.07533333333334}, "distributed/_tensor/test_device_mesh": {"DeviceMeshCollectiveTest": 15.107999999999997, "DeviceMeshTest": 15.860000000000001, "DeviceMeshTestNDim": 6.028333333333332, "InitDeviceMeshTest": 9.042333333333334, "TestDeviceMeshGetItem": 18.085333333333327}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 40.105333333333334, "DTensorTest": 84.12233333333334, "TestDTensorPlacementTypes": 3.949666666666667}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 2.94, "TestDTensorCompileE2E": 18.361666666666668, "TestDTensorCompileWithNativeFunCol": 0.30700000000000005}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 14.106}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 13.707999999999998}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 22.510666666666665, "DTensorInitOpsTest": 4.677333333333333}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 49.76766666666666}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 40.940999999999995}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.10333333333333333, "TestEinsumDims": 0.2783333333333334, "TestEinsumStrategies": 0.05499999999999999}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 53.68233333333333}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.5526666666666666}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 4.709, "DistTensorRandomOpTest": 24.834999999999997}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 5.420333333333335, "RedistributeTest": 38.061}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 109.23300000000005}, "distributed/_tensor/test_utils": {"Test2DStridedLocalShard": 7.559, "UtilTest": 14.523000000000001}, "distributed/_tensor/test_view_ops": {"TestViewOps": 24.350666666666665}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.30033333333333334}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 0.334}, "distributed/_tools/test_mod_tracker": {"TestModTracker": 0.3213333333333333}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 29.76833333333333}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 54.63499999999999}, "distributed/algorithms/test_join": {"TestJoin": 40.94166666666667}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ELoadAndSave": 15.452333333333334, "TestE2ESaveAndLoad": 43.291, "TestNoCPU": 4.345}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 3.810333333333333}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 3.779666666666666}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 4.638999999999999}, "distributed/checkpoint/fsdp/test_fsdp_dsd": {"TestFullyShardWithDistributedStateDict": 10.054666666666668}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 9.047333333333333, "TestDistributedFailure": 22.010666666666665}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.38866666666666666}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.2936666666666667}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 4.8180000000000005}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 19.380333333333333, "TestDTensorReshardPlacementChange": 8.327666666666666}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 18.547666666666668, "TestDistributedStateDictSaveLoad": 0.4013333333333333, "TestDistributedStateDictSaveLoadWithSharedTensor": 4.447333333333333}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 30.051666666666666, "TestDistributedStateDictSaveLoad": 0.389, "TestDistributedStateDictSaveLoadWithSharedTensor": 7.322666666666667}, "distributed/checkpoint/test_format_utils": {"TestFormatUtils": 12.131666666666666}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 8.528}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 9.722999999999999}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 5.081}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.397, "TestFSSpecWithDist": 9.292666666666667}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 14.613666666666667}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.29433333333333334}, "distributed/checkpoint/test_planner": {"TestLoadPlanner": 0.10133333333333333, "TestPlannerHelpers": 0.0030000000000000005, "TestSavePlan": 0.3133333333333333}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 3.775}, "distributed/checkpoint/test_state_dict": {"TestNoComm": 4.247333333333334, "TestStateDict": 126.07833333333333}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 19.221666666666668}, "distributed/checkpoint/test_torch_save_to_dcp": {"TestTorchSaveToDCP": 8.446666666666667}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 9.692333333333334}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.30866666666666664}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.314, "TestTensorProperties": 0.002}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.3113333333333333, "RdzvEventLibTest": 0.055000000000000014}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.30833333333333335}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.31866666666666665, "StartProcessesListTest": 20.477, "StartProcessesTest": 15.755, "StdTest": 0.006000000000000001}, "distributed/elastic/test_control_plane": {"WorkerServerTest": 5.404}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 13.307333333333332}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.13133333333333333, "LocalTimerTest": 3.9463333333333335, "MultiprocessingRequestQueueTest": 1.4510000000000003}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 2.3686666666666665}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.35766666666666663}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.3256666666666667, "UtilTest": 0.04966666666666667}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 0.521}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.29433333333333334}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 14.396}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 8.107}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 75.0, "TestFSDPCheckpointSubmodule": 4.646333333333334}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 36.36833333333333}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 37.32266666666667, "TestExplicitUnshard": 9.491666666666665}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 126.23266666666667}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 5.814, "TestHooks": 32.452666666666666, "TestNoGrad": 9.491999999999999, "TestParamInit": 9.292000000000002, "TestParityWithDDP": 844.9549999999999}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 69.58733333333333}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 36.28666666666666}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 31.09766666666667}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 47.943666666666665}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 151.45399999999998}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.31833333333333336}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 43.38966666666666}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 46.76933333333333}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 60.958999999999996}, "distributed/fsdp/test_fsdp_input": {"TestInput": 8.881}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 13.491333333333335}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 36.966}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 64.11999999999999, "TestFSDPMiscMultiThread": 0.43833333333333346, "TestFSDPMiscWorldSize1": 0.057666666666666665}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 26.872, "TestFSDPMixedPrecisionIgnoredModules": 4.310666666666666, "TestFSDPMixedPrecisionSharded": 260.1990000000001, "TestFSDPMixedPrecisionUnsharded": 13.332666666666666, "TestFSDPTrainEval": 7.7506666666666675}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 4.800333333333334}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 4.839666666666666}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 319.8316666666667}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 15.850333333333333, "TestForwardOverlapWorldSizeTwo": 28.751}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 9.552999999999999}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.37799999999999995, "TestShardedGradScalerParityWithDDP": 113.257}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 809.5456666666668, "TestFSDPStateDict4GPUs": 4.412}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 13.474333333333332}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 4.7043333333333335}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 4.8100000000000005}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 44.43266666666667, "TestUnshardParamsErrors": 17.68133333333333, "TestUnshardParamsNoShard": 8.955}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 4.8453333333333335, "TestFSDPUseOrigParamsInit": 4.745333333333334, "TestFSDPUseOrigParamsMultipleParamGroups": 113.48799999999999, "TestFSDPUseOrigParamsNoSync": 9.859000000000002, "TestFSDPUseOrigParamsParamAccess": 5.013333333333334, "TestFSDPUseOrigParamsUnshardReshard": 26.26, "TestFSDPUseOrigParamsWriteback": 24.528999999999996, "TestMultiTensorApply": 0.09533333333333334}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 28.350666666666665}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 4.782666666666667, "TestShardUtilsDistributedDTensor": 4.512666666666667}, "distributed/fsdp/test_utils": {"TestUtils": 0.397}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 4.182333333333333, "TestFSDPWrap": 111.38033333333333, "TestWrapUtils": 0.018}, "distributed/launcher/test_run": {"ElasticLaunchTest": 38.56033333333333}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.32466666666666666}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 166.2396666666667, "TestZeroRedundancyOptimizerSingleRank": 34.50266666666667}, "distributed/pipeline/sync/skip/test_api": {"test_api": 0.007}, "distributed/pipeline/sync/skip/test_gpipe": {"test_gpipe": 1.381}, "distributed/pipeline/sync/skip/test_inspect_skip_layout": {"test_inspect_skip_layout": 0.009000000000000001}, "distributed/pipeline/sync/skip/test_leak": {"test_leak": 0.5536666666666666}, "distributed/pipeline/sync/skip/test_portal": {"TestTensorLife": 0.007, "test_portal": 0.11233333333333334}, "distributed/pipeline/sync/skip/test_stash_pop": {"test_stash_pop": 0.012666666666666672}, "distributed/pipeline/sync/skip/test_tracker": {"test_tracker": 0.16766666666666666}, "distributed/pipeline/sync/skip/test_verify_skippables": {"test_verify_skippables": 0.012666666666666668}, "distributed/pipeline/sync/test_balance": {"test_balance": 5.221333333333333}, "distributed/pipeline/sync/test_bugs": {"test_bugs": 2.302333333333334}, "distributed/pipeline/sync/test_checkpoint": {"test_checkpoint": 0.5806666666666667}, "distributed/pipeline/sync/test_copy": {"test_copy": 1.0119999999999998}, "distributed/pipeline/sync/test_deferred_batch_norm": {"test_deferred_batch_norm": 1.1553333333333335}, "distributed/pipeline/sync/test_dependency": {"test_dependency": 0.112}, "distributed/pipeline/sync/test_inplace": {"test_inplace": 0.11699999999999999}, "distributed/pipeline/sync/test_microbatch": {"test_microbatch": 0.013000000000000005}, "distributed/pipeline/sync/test_phony": {"test_phony": 0.007}, "distributed/pipeline/sync/test_pipe": {"test_pipe": 2.124999999999999}, "distributed/pipeline/sync/test_pipeline": {"test_pipeline": 0.0030000000000000005}, "distributed/pipeline/sync/test_stream": {"TestCurrentStream": 0.002, "TestDefaultStream": 0.002, "TestGetDevice": 0.002, "TestNewStream": 0.10466666666666669, "TestRecordStream": 0.274, "TestUseDevice": 0.002, "TestUseStream": 0.002, "TestWaitStream": 0.77}, "distributed/pipeline/sync/test_transparency": {"test_transparency": 0.4046666666666667}, "distributed/pipeline/sync/test_worker": {"test_worker": 0.015}, "distributed/pipelining/test_backward": {"StageBackwardTests": 0.31466666666666665}, "distributed/pipelining/test_chunkspec": {"ChunkSpecTests": 0.7903333333333333}, "distributed/pipelining/test_microbatch": {"MicrobatchTests": 0.7799999999999999}, "distributed/pipelining/test_pipe": {"PipeTests": 1.3229999999999997}, "distributed/pipelining/test_schedule": {"ScheduleTest": 6.583000000000001, "TestSchedulePlan": 1.1176666666666668}, "distributed/pipelining/test_stage": {"StageTest": 3.844666666666667}, "distributed/pipelining/test_stage_backward": {"StageBackwardTests": 0.3113333333333333}, "distributed/pipelining/test_transformer": {"TransformerTests": 1.202}, "distributed/pipelining/test_unflatten": {"UnflattenTests": 0.944}, "distributed/rpc/cuda/test_tensorpipe_agent": {"TensorPipeCudaDdpComparisonTest": 4.4606666666666674, "TensorPipeCudaDistAutogradTest": 15.501, "TensorPipeCudaRemoteModuleTest": 18.411666666666665, "TensorPipeCudaRpcTest": 5.133, "TensorPipePipeWithDDPTest": 33.809666666666665, "TensorPipeTensorPipeAgentCudaRpcTest": 626.208, "TensorPipeTensorPipeCudaDistAutogradTest": 13.426}, "distributed/rpc/test_share_memory": {"TestRPCPickler": 4.293666666666667}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 3.748666666666667}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"Test2dParallelIntegration": 27.977666666666664, "TestNew2dParallelStateDict": 24.77066666666666, "TestNew2dParallelTraining": 17.921}, "distributed/tensor/parallel/test_micro_pipeline_tp": {"MicroPipelineTPTest": 0.014000000000000005, "test_micro_pipeline_tp": 0.0}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 38.23433333333333}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 33.758}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 3.813}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 40.779333333333334}, "distributed/tensor/parallel/test_view_sharding_dim_change": {"TPViewShardingDimChangeTest": 3.918333333333333}, "distributed/test_c10d_common": {"CommTest": 3.9086666666666665, "ComputeBucketAssignmentTest": 1.2220000000000002, "LocalRankTest": 16.104333333333333, "ProcessGroupWithDispatchedCollectivesTests": 7.896333333333334, "PythonProcessGroupExtensionTest": 29.298000000000002, "ReduceOpTest": 1.2216666666666667, "TimeoutTest": 31.337666666666667}, "distributed/test_c10d_functional_native": {"C10DFunctionalNativeCompileTest": 0.012000000000000004, "C10DFunctionalNativeTest": 44.874, "CompileTest": 0.011000000000000003, "TestWithNCCL": 50.13766666666667}, "distributed/test_c10d_gloo": {"CommTest": 44.085, "CompilerTest": 45.159, "DistributedDataParallelTest": 166.28900000000002, "GlooProcessGroupWithDispatchedCollectivesTests": 26.756666666666664, "LargeCommTest": 12.390666666666668, "ProcessGroupGlooTest": 223.00900000000001, "ReducerTest": 0.25533333333333336, "RendezvousEnvTest": 0.32433333333333336, "TimeoutTest": 3.347}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 17.680666666666667}, "distributed/test_c10d_nccl": {"CommTest": 93.93466666666666, "CompilerTest": 64.01233333333333, "DistributedDataParallelTest": 338.3353333333334, "LargeCommTest": 62.06366666666667, "NCCLTraceTest": 122.748, "NCCLTraceTestDumpOnTimeout": 20.580333333333332, "NCCLTraceTestTimeoutDumpOnIdleRanks": 10.965666666666666, "NCCLTraceTestTimeoutDumpOnStuckRanks": 10.317, "NcclErrorDumpTest": 20.580000000000002, "NcclErrorHandlingTest": 28.311333333333334, "NcclProcessGroupWithDispatchedCollectivesTests": 35.68866666666667, "ProcessGroupNCCLGroupTest": 87.70366666666668, "ProcessGroupNCCLNoGPUTest": 0.001, "ProcessGroupNCCLTest": 217.939, "RendezvousEnvTest": 0.043000000000000003, "SparseCollective": 4.795333333333333, "TimeoutTest": 3.032, "WorkHookTest": 25.350333333333335}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 43.14633333333333}, "distributed/test_c10d_ops_nccl": {"ProcessGroupNCCLOpTest": 9.232000000000001}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 78.43366666666667, "TestDDPWithWorkWrapper": 77.63133333333333}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 1.1486666666666667, "TestDistributedNNFunctionsGloo": 33.12433333333333}, "distributed/test_c10d_spawn_nccl": {"TestDistributedNNFunctionsNccl": 44.49666666666667}, "distributed/test_c10d_spawn_ucc": {"TestDistributedNNFunctionsUcc": 23.312}, "distributed/test_c10d_ucc": {"CommTest": 29.427333333333333, "CompilerTest": 46.14833333333333, "DistributedDataParallelTest": 143.1026666666667, "ProcessGroupUCCTest": 27.559, "RendezvousEnvTest": 0.31033333333333335, "TimeoutTest": 3.3260000000000005, "UccProcessGroupWithDispatchedCollectivesTests": 7.928}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 4.0103333333333335}, "distributed/test_control_collectives": {"TestCollectives": 0.3626666666666667}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 0.002}, "distributed/test_data_parallel": {"TestDataParallel": 2.0226666666666664, "TestDataParallelDeviceTypeCUDA": 0.08033333333333333}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 24.404333333333337, "DeviceMeshCollectiveTestWithNativeFunCol": 10.055, "DeviceMeshTest": 46.35166666666667, "DeviceMeshTestNDim": 20.954, "DeviceMeshTestWithNativeFunCol": 19.403333333333332, "InitDeviceMeshTest": 12.285000000000002, "TestDeviceMeshGetItem": 24.605333333333338, "TestMeshEnv": 17.649}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 5147.238999999987}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 15.648000000000001, "TestMultiProc": 22.200666666666674, "TestSingleProc": 8.790666666666667}, "distributed/test_fake_pg": {"TestFakePG": 0.7839999999999999}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 17.817000000000004, "TestExpand": 0.3106666666666667, "TestFunctionalAutograd": 14.319666666666665, "TestFunctionalAutogradWithNCCL": 4.513333333333333, "TestGradCollectives": 0.004666666666666667, "TestMakeFx": 0.044333333333333336, "TestMetaCollectives": 0.002, "TestNCCLCollectivesWithWorldSize4": 18.429333333333336, "TestOpWaitiness": 15.440333333333333, "TestPgTag": 0.04066666666666666, "TestTraceableCollectives": 0.17066666666666672}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.0446666666666657, "TestCollectivesMultiProc": 5.078333333333336}, "distributed/test_launcher": {"TestDistributedLaunch": 1.3230000000000002}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.25, "TestCollectivesWithWrapper": 0.3506666666666667}, "distributed/test_nccl": {"TestNCCLCUDA": 0.4523333333333333}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 38.98, "ProcessGroupNCCLWrapperTest": 41.026}, "distributed/test_store": {"FileStoreTest": 3.4316666666666666, "HashStoreTest": 1.9836666666666665, "InitPgWithNonUvStore": 0.6263333333333333, "InitPgWithUvStore": 0.646, "LibUvTCPStoreTest": 9.517333333333333, "PrefixFileStoreTest": 2.744666666666666, "PrefixStoreTest": 0.004, "PrefixTCPStoreTest": 2.3059999999999996, "PythonStoreTest": 0.2933333333333333, "RendezvousEnvTest": 0.29433333333333334, "RendezvousFileTest": 0.586, "RendezvousTCPTest": 21.772333333333336, "RendezvousTest": 0.5790000000000001, "TCPStoreTest": 9.507666666666665, "TestMultiThreadedWait": 1.485, "TestPythonStore": 2.026, "TimeoutTest": 5.302}, "distributed/test_symmetric_memory": {"SymmetricMemoryTest": 0.001}}}, "linux-focal-cuda11.8-py3.10-gcc9-debug": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 3.4989999999999997}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.722}, "distributions/test_distributions": {"TestAgainstScipy": 2.5665, "TestConstraints": 0.3185, "TestDistributionShapes": 0.2565000000000002, "TestDistributions": 71.375, "TestFunctors": 0.018000000000000002, "TestJit": 38.5165, "TestKL": 4.940999999999999, "TestLazyLogitsInitialization": 0.026000000000000002, "TestNumericalStability": 0.14550000000000005, "TestRsample": 1.348, "TestValidation": 0.788}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 1.073}, "dynamo/test_after_aot": {"TestAfterAot": 9.965}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.7210000000000001}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 26.40549999999999}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.6435, "AOTAutogradCacheTests": 18.332000000000004}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.503}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.075, "TestCustomBackendAPI": 3.5899999999999994, "TestExplainWithBackend": 19.0345, "TestOptimizations": 3.6034999999999995}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 22.534999999999997}, "dynamo/test_base_output": {"TestBaseOutput": 0.009000000000000001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.434}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 8.7035, "BytecodeTests": 0.8965000000000001}, "dynamo/test_compile": {"InPlaceCompilationTests": 11.5105, "PublicTorchCompilerTests": 0.0045000000000000005}, "dynamo/test_comptime": {"ComptimeTests": 1.2545000000000002}, "dynamo/test_config": {"ConfigTests": 1.221}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.30800000000000005, "CppGuardManagerFuncTorchHigherOrderOpTests": 15.389999999999999, "CppGuardManagerFunctionTests": 32.26300000000005, "CppGuardManagerHigherOrderOpTests": 9.517999999999995, "CppGuardManagerMiscTests": 57.17200000000003, "CppGuardManagerReproTests": 50.58700000000002}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.7544999999999984}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 6.418}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.48150000000000004}, "dynamo/test_decorators": {"DecoratorTests": 10.4585}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0045000000000000005, "TestDeviceGuard": 0.028000000000000004}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 63.63550000000001, "DynamicShapesCtxManagerTests": 13.941, "DynamicShapesExportTests": 58.12400000000001, "DynamicShapesFuncTorchHigherOrderOpTests": 149.90300000000002, "DynamicShapesFunctionTests": 126.59400000000005, "DynamicShapesHigherOrderOpTests": 31.918, "DynamicShapesMiscTests": 169.48749999999995, "DynamicShapesNNModuleTests": 12.903, "DynamicShapesReproTests": 185.77349999999998, "DynamicShapesSubGraphTests": 17.204, "DynamicShapesTestSDPA": 0.7045}, "dynamo/test_exc": {"ExcTests": 3.8999999999999995}, "dynamo/test_exceptions": {"ExceptionTests": 1.062}, "dynamo/test_export": {"ExportTests": 30.344499999999996}, "dynamo/test_export_mutations": {"MutationExportTests": 1.1945000000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.405}, "dynamo/test_functions": {"DefaultsTests": 1.4665000000000001, "FunctionTests": 58.349500000000205}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 2.2005}, "dynamo/test_global": {"TestGlobals": 1.0645000000000002}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.4735000000000001}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.14950000000000002, "FuncTorchHigherOrderOpTests": 15.613499999999995, "HigherOrderOpTests": 15.270499999999998, "HigherOrderOpVmapGuardTests": 7.6355}, "dynamo/test_hooks": {"HooksTests": 49.715000000000025}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 16.321, "InlineInbuiltNNModulesExportTests": 39.41599999999998, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 15.783500000000004, "InlineInbuiltNNModulesFunctionTests": 19.356999999999996, "InlineInbuiltNNModulesHigherOrderOpTests": 14.6525, "InlineInbuiltNNModulesMiscTests": 103.41450000000016, "InlineInbuiltNNModulesNNModuleTests": 8.818499999999998}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 13.4175}, "dynamo/test_interop": {"InteropTests": 1.1840000000000002}, "dynamo/test_logging": {"LoggingTests": 30.283500000000004}, "dynamo/test_minifier": {"MinifierTests": 4.614500000000001}, "dynamo/test_misc": {"MiscTests": 105.15400000000024, "TestTracer": 0.106}, "dynamo/test_model_output": {"TestHFPretrained": 0.0025, "TestModelOutput": 0.02250000000000001}, "dynamo/test_modules": {"NNModuleTests": 5.614499999999996, "OptimizedModuleTest": 29.919999999999995}, "dynamo/test_nops": {"NopTests": 0.5765}, "dynamo/test_optimizers": {"End2EndTests": 1.293, "OptimizerTests": 3.7255000000000003}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.9730000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 2.5324999999999998}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.3130000000000002}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.8424999999999998}, "dynamo/test_recompiles": {"RecompileTests": 1.7409999999999997}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 1.0530000000000002}, "dynamo/test_replay_record": {"ReplayRecordTests": 1.0566666666666666}, "dynamo/test_repros": {"ReproTests": 82.97400000000005}, "dynamo/test_resume": {"ResumeFunctionTests": 0.8965}, "dynamo/test_sdpa": {"TestSDPA": 1.0055}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 1.109}, "dynamo/test_sources": {"SourceTests": 0.9905}, "dynamo/test_structured_trace": {"StructuredTraceTest": 21.8785}, "dynamo/test_subclasses": {"SubclassTests": 5.701499999999998, "TestNestedTensor": 19.962000000000003}, "dynamo/test_subgraphs": {"SubGraphTests": 4.465499999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.203, "TraceRuleTests": 2.3339999999999996}, "dynamo/test_triton_kernels": {"KernelTests": 0.18300000000000013, "MutationTests": 0.0075, "NoOptimizationKernelTests": 0.18150000000000013, "no_opt_test_class": 0.18350000000000014}, "dynamo/test_unspec": {"UnspecTests": 23.767999999999994}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 1.1545}, "dynamo/test_view": {"ViewTests": 1.2489999999999999}, "export/test_converter": {"TestConverter": 10.33}, "export/test_db": {"ExampleTests": 6.553499999999999}, "export/test_experimental": {"TestExperiment": 1.991}, "export/test_export": {"TestDynamismExpression": 0.9245, "TestExport": 53.137499999999974, "TestExportCustomClass": 0.128, "TestOneOffModelExportResult": 2.107}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.8360000000000001, "NonStrictExportTestExport": 47.528499999999994}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.5930000000000001, "PreDispatchExportTestExport": 34.83800000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.4185}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.859}, "export/test_hop": {"TestHOPCUDA": 5.629, "TestHOPGeneric": 0.0055}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.004, "TestLift": 0.1865, "TestLiftUnlift": 0.0235}, "export/test_pass_infra": {"TestPassInfra": 1.7385000000000002}, "export/test_passes": {"TestPasses": 25.443}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.6565, "RetraceExportTestExport": 81.69349999999997}, "export/test_safeguard": {"TestSafeguard": 1.08}, "export/test_schema": {"TestSchema": 0.49849999999999994}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.33099999999999996, "SerDesExportPreDispatchTestExport": 27.264999999999997, "SerDesExportTestDynamismExpression": 1.0614999999999999, "SerDesExportTestExport": 55.79350000000001}, "export/test_serialize": {"TestDeserialize": 16.0555, "TestOpVersioning": 0.006, "TestSaveLoad": 0.618, "TestSchemaVersioning": 0.061, "TestSerialize": 2.141, "TestSerializeCustomClass": 0.1685}, "export/test_sparse": {"TestSparseProp": 118.92699999999999}, "export/test_tools": {"TestExportTools": 1.1400000000000001}, "export/test_torchbind": {"TestCompileTorchbind": 2.1195000000000004, "TestExportTorchbind": 3.5755, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.41200000000000003}, "export/test_unflatten": {"TestUnflatten": 6.0765}, "export/test_upgrade": {"TestUpgrade": 0.556}, "export/test_verifier": {"TestVerifier": 1.9435}, "functorch/test_aotdispatch": {"TestAOTAutograd": 27.309500000000003, "TestAOTAutogradWithDynamo": 30.797499999999996, "TestAOTDispatch": 1.0925, "TestAOTExport": 4.787999999999999, "TestAOTModuleSimplified": 1.2865, "TestPartitioning": 6.631500000000001}, "functorch/test_control_flow": {"TestControlFlow": 1.6734999999999998, "TestControlFlowTraced": 210.80400000000003}, "functorch/test_dims": {"TestMin": 21.845999999999993, "TestMinFunctorchOnly": 20.8665}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.1730000000000001, "TestAutogradFunctionVmapAPICUDA": 0.035500000000000004, "TestCompileTransformsCUDA": 7.0275, "TestComposabilityCUDA": 0.2905000000000001, "TestExamplesCorrectnessCUDA": 6.801499999999999, "TestFunctionalizeCUDA": 0.20800000000000007, "TestGradTransformCUDA": 1.9524999999999992, "TestHelpersCUDA": 0.0225, "TestHessianCUDA": 0.11499999999999999, "TestHigherOrderOperatorInteractionCUDA": 0.052000000000000005, "TestJacCUDA": 1.3435000000000006, "TestJvpCUDA": 0.11250000000000002, "TestLinearizeCUDA": 0.523, "TestMakeFunctional": 0.13250000000000003, "TestSliceArgnums": 0.030000000000000006, "TestVmapJvpInplaceViewCUDA": 0.034, "TestVmapOfGradCUDA": 0.7895000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.48}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.5925, "RandomOpTestCase": 0.165, "ReduceTestCase": 0.156, "TestMemoryEfficientOpAuthoring": 14.417000000000002}, "functorch/test_minifier": {"TestMinifier": 0.7995000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 7597.761999999997}, "functorch/test_parsing": {"TestAnonymousAxis": 0.4325, "TestParsedExpression": 0.009000000000000001, "TestParsingUtils": 0.01, "TestValidateRearrangeExpressions": 0.0105}, "functorch/test_rearrange": {"TestRearrange": 0.5425000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 1.9465000000000008, "TestTransformFailureCUDA": 0.2015, "TestVmapAPI": 0.5585000000000001, "TestVmapBatchedGradientCUDA": 0.41400000000000003, "TestVmapDeviceTypeCUDA": 0.0435, "TestVmapNestedTensorCUDA": 0.07850000000000001, "TestVmapOperators": 5.473999999999996, "TestVmapOperatorsOpInfoCUDA": 632.8669999999995}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 5.421999999999826}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.8755}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 17.936}, "inductor/test_binary_folding": {"FreezingCpuTests": 75.2285}, "inductor/test_codecache": {"TestFxGraphCache": 75.14649999999995, "TestFxGraphCacheHashing": 1.5419999999999998, "TestUtils": 7.0695, "test_codecache": 0.001}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.42699999999999994}, "inductor/test_compile_worker": {"TestCompileWorker": 14.6435}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 434.6315000000002, "TestAutogradWithCompiledAutograd": 618.9110000000007, "TestCompiledAutograd": 367.81, "TestCustomOpWithCompiledAutograd": 3.8099999999999907}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 0.15150000000000008, "CompiledOptimizerTests": 497.71499999999946}, "inductor/test_config": {"TestInductorConfig": 12.635499999999999}, "inductor/test_control_flow": {"CondTests": 0.05250000000000003, "WhileLoopTests": 0.027000000000000014}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 401.78650000000005, "TestCppWrapper": 400.54150000000004}, "inductor/test_cpu_repro": {"CPUReproTests": 1232.3600000000001}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0045000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 22.953}, "inductor/test_debug_trace": {"TestDebugTrace": 6.98}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.006500000000000001}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 75.21}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0035}, "inductor/test_extension_backend": {"ExtensionBackendTests": 37.279}, "inductor/test_flex_attention": {"TestFlexAttention": 0.1530000000000001, "TestTemplatedSDPA": 0.055000000000000035}, "inductor/test_foreach": {"ForeachTests": 36.15250000000029}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 155.89299999999997, "SDPAPatternRewriterCpuTests": 150.71099999999998}, "inductor/test_fx_fusion": {"TestFxFusion": 0.386}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.028499999999999998}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.348, "TestGroupBatchFusion": 0.0025, "TestPostGradBatchLinearFusion": 0.0015}, "inductor/test_indexing": {"ExprPrinterTests": 0.08499999999999999, "TestIndexingSimplification": 1.1440000000000001}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 100.71699999999998}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0023333333333333335}, "inductor/test_minifier": {"MinifierTests": 48.996500000000005}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 91.1395}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 177.606, "TestPatternMatcher": 886.7375}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.033000000000000015}, "inductor/test_profiler": {"DynamoProfilerTests": 0.005}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 36.903999999999996}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.02900000000000002}, "inductor/test_torchbind": {"TestTorchbind": 12.9395}, "inductor/test_torchinductor": {"CpuTests": 2839.302, "SweepInputsCpuTest": 248.214, "TestFull": 21.807}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2995.9390000000003}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 3168.0549999999994, "TestInductorDynamicCUDA": 0.13900000000000004}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 24.73750000000005}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 1.089}, "inductor/test_triton_kernels": {"KernelTests": 0.22950000000000015, "MutationTests": 0.025500000000000012, "NoOptimizationKernelTests": 0.14433333333333342, "no_opt_test_class": 0.1450000000000001}, "inductor/test_utils": {"TestUtils": 0.40850000000000003}, "lazy/test_debug_util": {"DebugUtilTest": 0.5375}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.5375}, "lazy/test_generator": {"LazyGeneratorTest": 0.5115000000000001}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.872}, "lazy/test_step_closures": {"ClosuresTest": 3.4119999999999995}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.336, "TestLazyTensor": 0.137}, "nn/test_convolution": {"TestConvolutionNN": 37.05550000000001, "TestConvolutionNNDeviceTypeCUDA": 29.848500000000215}, "nn/test_dropout": {"TestDropoutNN": 0.21400000000000002, "TestDropoutNNDeviceTypeCUDA": 1.323}, "nn/test_embedding": {"TestEmbeddingNN": 0.21150000000000002, "TestEmbeddingNNDeviceTypeCUDA": 27.857999999999976}, "nn/test_init": {"TestNNInit": 6.847999999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.5820000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.0310000000000001, "TestLoadStateDictSwap": 0.10950000000000001}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.04, "TestModuleHookNN": 0.11649999999999999, "TestModuleHooks": 0.14750000000000002, "TestStateDictHooks": 0.05650000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 10.072, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.3935}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.8045}, "nn/test_parametrization": {"TestNNParametrization": 1.4935000000000003, "TestNNParametrizationDeviceCUDA": 0.1995}, "nn/test_pooling": {"TestAvgPool": 0.5740000000000001, "TestPoolingNN": 1.086, "TestPoolingNNDeviceTypeCUDA": 15.231499999999999}, "nn/test_pruning": {"TestPruningNN": 0.1765000000000001}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.36}, "profiler/test_memory_profiler": {"TestDataFlow": 1.895, "TestIdentifyGradients": 0.527, "TestMemoryProfiler": 0.49450000000000005, "TestMemoryProfilerE2E": 5.1175}, "profiler/test_profiler": {"TestExecutionTrace": 7.585, "TestExperimentalUtils": 5.420499999999999, "TestProfiler": 28.821999999999996, "TestProfilerCUDA": 10.02, "TestProfilerITT": 0.003, "TestRecordFunction": 0.055, "TestTorchTidyProfiler": 5.79}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.6375000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.5465}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.6579999999999995}, "test_ao_sparsity": {"TestActivationSparsifier": 0.103, "TestBaseDataScheduler": 0.057, "TestBaseDataSparsifier": 0.14600000000000002, "TestBaseSparsifier": 0.046, "TestBaseStructuredSparsifier": 5.143000000000001, "TestComposability": 3.7575, "TestCubicScheduler": 0.01, "TestFPGMPruner": 0.1205, "TestFakeSparsity": 0.129, "TestFxComposability": 3.1510000000000002, "TestNearlyDiagonalSparsifier": 1.5865, "TestNormDataSparsifiers": 1.6315, "TestQuantizationUtils": 0.0315, "TestQuantizedSparseKernels": 0.381, "TestQuantizedSparseLayers": 0.5249999999999999, "TestSaliencyPruner": 0.054, "TestScheduler": 0.024499999999999997, "TestSparsityUtilFunctions": 0.0685, "TestWeightNormSparsifier": 0.6425000000000001}, "test_autocast": {"TestAutocastCPU": 3.7175, "TestAutocastGPU": 0.181, "TestTorchAutocast": 0.0105}, "test_autograd": {"TestAllowMutationOnSaved": 0.052500000000000005, "TestAutograd": 33.5104999999999, "TestAutogradComplex": 0.009000000000000001, "TestAutogradDeviceTypeCUDA": 2.1094999999999993, "TestAutogradForwardMode": 0.12500000000000006, "TestAutogradForwardModeBatchedGrad": 0.030500000000000003, "TestAutogradFunctional": 22.921999999999997, "TestAutogradInferenceMode": 0.059000000000000025, "TestAutogradLogging": 0.0245, "TestAutogradMultipleDispatchCUDA": 0.036500000000000005, "TestMultithreadAutograd": 0.43900000000000006, "TestNestedCheckpoint": 0.8675000000000002, "TestSelectiveActivationCheckpoint": 0.07600000000000001}, "test_autograd_fallback": {"TestAutogradFallback": 0.6250000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 236.31150000000173}, "test_bundled_inputs": {"TestBundledInputs": 1.9719999999999995}, "test_comparison_utils": {"TestComparisonUtils": 0.42700000000000005}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_complex": {"TestComplexTensorCUDA": 0.15850000000000003}, "test_content_store": {"TestContentStoreCUDA": 0.14700000000000002}, "test_cpp_api_parity": {"TestCppApiParity": 17.859999999999914}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.30500000000000005, "TestMAIATensor": 0.012, "TestORTTensor": 0.014, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0055, "TestTorchLibrary": 0.1005}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.2925, "TestMAIATensor": 0.012, "TestORTTensor": 0.014, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.098}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 128.4565}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0075}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 12.591000000000008}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0015}, "test_cuda": {"TestBlockStateAbsorption": 9.565999999999999, "TestCuda": 120.67650000000009, "TestCudaMallocAsync": 36.848, "TestCudaOptimsCUDA": 4.758499999999998}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 9.8205, "TestCuda": 124.0325000000001, "TestCudaMallocAsync": 48.021000000000015, "TestCudaOptimsCUDA": 6.506999999999998}, "test_cuda_multigpu": {"TestCudaComm": 0.050500000000000024, "TestCudaMultiGPU": 0.9675}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.281, "TestVisibleDeviceParses": 0.037000000000000005}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0045000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.523, "TestEventHandler": 0.039000000000000014, "TestMessages": 0.006}, "test_cuda_trace": {"TestCudaTrace": 1.6269999999999998}, "test_custom_backend": {"TestCustomBackend": 0.1665}, "test_custom_ops": {"MiniOpTest": 1.0965000000000005, "MiniOpTestOther": 0.11100000000000003, "TestCustomOp": 4.36999999999999, "TestCustomOpAPI": 0.22050000000000003, "TestCustomOpTestingCUDA": 3.1500000000000004, "TestCustomOperators": 0.6220000000000001, "TestGenerateOpcheckTests": 5.7725}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.002, "TestConcatDataset": 0.019500000000000003, "TestConvAfterFork": 0.045, "TestCustomPinFn": 0.17450000000000002, "TestDataLoader": 143.51100000000002, "TestDataLoaderDeviceTypeCUDA": 23.4355, "TestDataLoaderPersistentWorkers": 161.04049999999998, "TestDatasetRandomSplit": 0.0495, "TestDictDataLoader": 0.05500000000000001, "TestIndividualWorkerQueue": 0.003, "TestNamedTupleDataLoader": 0.0075, "TestSetAffinity": 0.056, "TestStackDataset": 0.05650000000000001, "TestStringDataLoader": 0.073, "TestTensorDataset": 0.039}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.012, "TestDataChunk": 0.0105, "TestDataFramesPipes": 0.009000000000000001, "TestFunctionalIterDataPipe": 8.195999999999998, "TestFunctionalMapDataPipe": 0.058499999999999996, "TestGraph": 0.022000000000000002, "TestIterDataPipeCountSampleYielded": 0.0195, "TestIterDataPipeGraphFastForward": 0.0965, "TestIterDataPipeSingletonConstraint": 0.043500000000000004, "TestIterableDataPipeBasic": 0.04650000000000001, "TestSerialization": 10.5045, "TestSharding": 0.24350000000000005, "TestStreamWrapper": 0.43699999999999994, "TestTyping": 0.015000000000000003}, "test_decomp": {"DecompOneOffTestsCUDA": 0.057999999999999996, "HasDecompTest": 0.532, "TestDecompCUDA": 15289.847}, "test_deploy": {"TestFreezer": 0.4105}, "test_dispatch": {"TestDispatch": 60.44100000000001, "TestPythonDispatcher": 0.0495}, "test_dlpack": {"TestTorchDlPackCUDA": 0.5210000000000004}, "test_dynamic_shapes": {"TestDimConstraints": 3.7784999999999997, "TestFloorDiv": 0.015, "TestGuardsExpressions": 0.027, "TestPySymInt": 2.2689999999999984, "TestSymNumberMagicMethods": 2.9889999999999937}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 4.487999999999997, "TestExpandedWeightHelperFunctionCUDA": 0.17650000000000002, "TestExpandedWeightModuleCUDA": 20.3035}, "test_fake_tensor": {"FakeTensorConstHandling": 0.10450000000000004, "FakeTensorConverterTest": 0.0415, "FakeTensorDispatchCache": 0.15650000000000003, "FakeTensorOpInfoTestCUDA": 0.16099999999999998, "FakeTensorOperatorInvariants": 0.7705, "FakeTensorPropTest": 0.136, "FakeTensorSerialization": 0.009000000000000001, "FakeTensorTest": 14.745500000000007, "PropagateRealTensorsFakeTensorConstHandling": 0.16150000000000003, "PropagateRealTensorsFakeTensorConverterTest": 0.039, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.30300000000000005, "PropagateRealTensorsFakeTensorPropTest": 0.09749999999999999, "PropagateRealTensorsFakeTensorTest": 28.132500000000014}, "test_flop_counter": {"TestFlopCounter": 0.743}, "test_foreach": {"TestForeachCUDA": 310.30450000001804}, "test_function_schema": {"TestFunctionSchema": 1.096}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 31.436500000000002}, "test_functional_optim": {"TestFunctionalOptimParity": 0.643}, "test_functionalization": {"TestCrossRefFunctionalization": 3.551, "TestFunctionalization": 4.184999999999998}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 5.0765}, "test_futures": {"TestFuture": 1.4085}, "test_fx": {"AnnotationsTest": 0.023000000000000003, "TestCSEPass": 0.48150000000000004, "TestCommonPass": 0.3040000000000001, "TestConstFold": 0.274, "TestConstParamShapeInControlFlow": 0.07200000000000001, "TestDCE": 0.05, "TestFX": 4.75799999999999, "TestFXAPIBackwardCompatibility": 0.0465, "TestFunctionalTracing": 0.6260000000000004, "TestMatcher": 0.6795, "TestOperatorSignaturesCUDA": 1.9944999999999995, "TestPassManager": 0.044, "TestSourceMatcher": 2.2169999999999996, "TestSubgraphRewriter": 0.5075000000000003, "TestVisionTracing": 444.6165000000001, "TypeCheckerTest": 3.3889999999999985}, "test_fx_experimental": {"TestFXExperimental": 28.467499999999998, "TestNormalizeOperatorsCUDA": 3.7059999999999826, "TestTranslationValidation": 0.22549999999999998}, "test_fx_passes": {"TestFXGraphPasses": 1.0895000000000004, "TestFXMatcherUtils": 0.14850000000000005}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.778}, "test_import_stats": {"TestImportTime": 6.7505}, "test_indexing": {"NumpyTestsCUDA": 0.07500000000000002, "TestIndexingCUDA": 2.6954999999999982}, "test_itt": {"TestItt": 0.448}, "test_jit": {"TestAliasAnalysis": 0.5245000000000001, "TestAsync": 0.56, "TestAtenPow": 0.013, "TestAutodiffJit": 0.10299999999999998, "TestAutodiffSubgraphSlicing": 0.4495000000000001, "TestAwait": 0.3350000000000001, "TestBackends": 1.13, "TestBackendsWithCompiler": 0.22299999999999998, "TestBatchMM": 0.1285, "TestBuiltins": 0.09, "TestCUDA": 1.1420000000000001, "TestClassType": 3.763000000000001, "TestComplex": 1.3580000000000003, "TestCustomOperators": 0.06400000000000003, "TestDCE": 0.028499999999999998, "TestDataParallel": 0.0075, "TestDataclasses": 7.0155, "TestDeviceAnalysis": 6.469500000000001, "TestDict": 0.6765000000000003, "TestDtypeAnalysis": 0.25100000000000006, "TestEnum": 0.31400000000000006, "TestFreezing": 3.5839999999999996, "TestFrontend": 0.64, "TestFrozenOptimizations": 16.7525, "TestFunctionalBlocks": 0.01, "TestFunctionalToInplaceActivation": 3.8505000000000003, "TestGenerator": 0.097, "TestGetDefaultAttr": 0.0235, "TestGraphRewritePasses": 0.066, "TestHash": 0.11549999999999999, "TestHooks": 1.0780000000000005, "TestIgnorableArgs": 0.016, "TestIgnoreContextManager": 0.062, "TestInplaceToFunctionalActivation": 3.4925, "TestIsinstance": 0.3315000000000001, "TestJit": 8.841999999999992, "TestJitGeneratedModule": 17.83250000000003, "TestJitProfiler": 0.0015, "TestJitUtils": 0.025500000000000002, "TestList": 1.9480000000000004, "TestLogging": 0.07600000000000001, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.25550000000000006, "TestMixTracingScripting": 1.9755000000000003, "TestModels": 8.863, "TestModuleAPIs": 0.193, "TestModuleContainers": 1.8679999999999999, "TestModuleInterface": 0.772, "TestModules": 0.0225, "TestNamedTuple": 0.10299999999999998, "TestNnapiBackend": 10.838000000000001, "TestOpDecompositions": 0.025, "TestOptimizeForMobilePreserveDebugInfo": 0.23000000000000004, "TestParametrization": 0.129, "TestPeephole": 0.6605000000000003, "TestProducerVersion": 0.003, "TestProfiler": 0.8765000000000001, "TestPythonBindings": 0.0455, "TestPythonBuiltinOP": 0.5870000000000001, "TestPythonIr": 0.035, "TestRecursiveScript": 1.0680000000000003, "TestRemoveMutation": 0.19050000000000003, "TestSaveLoad": 0.7075000000000001, "TestSaveLoadFlatbuffer": 0.7795000000000001, "TestSaveLoadForOpVersion": 3.3594999999999997, "TestScript": 64.79500000000007, "TestScriptDict": 0.037500000000000006, "TestScriptList": 1.2605000000000002, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.24550000000000005, "TestScriptProfile": 0.6114999999999999, "TestSlice": 0.2370000000000001, "TestSparse": 0.0695, "TestStringFormatting": 0.17650000000000005, "TestSymbolicShapeAnalysis": 1.826999999999999, "TestTensorBuiltins": 0.15400000000000003, "TestTensorCreationOps": 0.066, "TestTensorMethods": 0.017, "TestTorchbind": 0.2790000000000001, "TestTracer": 7.365999999999989, "TestTypeSharing": 0.7250000000000002, "TestTypesAndAnnotation": 0.1925, "TestTyping": 0.5860000000000003, "TestUnion": 0.6620000000000003, "TestUnsupportedOps": 0.0425, "TestUpgraders": 0.09400000000000001, "TestWarn": 0.079, "TestWith": 0.526}, "test_jit_autocast": {"TestAutocast": 2.1069999999999993, "TestJitTraceAutocast": 51.586}, "test_jit_disabled": {"TestJitDisabled": 0.6204999999999999}, "test_jit_fuser_te": {"TestFuserCommon": 0.235, "TestNNCOpInfoCUDA": 29.234500000000715, "TestTEFuserDynamic": 626.1280000000003, "TestTEFuserStatic": 520.1245000000001}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0015, "TestEnableDisableLlgaFuser": 0.11399999999999999, "TestFusionPatternCUDA": 0.007, "TestModel": 0.0095, "TestOpCUDA": 0.0075}, "test_jiterator": {"TestPythonJiteratorCUDA": 39.68549999999989}, "test_legacy_vmap": {"TestVmapAPI": 1.463999999999999, "TestVmapAPILegacy": 1.4775, "TestVmapBatchedGradientCUDA": 0.4560000000000002, "TestVmapBatchedGradientLegacyCUDA": 0.7095000000000002, "TestVmapOperators": 1.325, "TestVmapOperatorsLegacy": 1.6729999999999998}, "test_license": {"TestLicense": 0.4225}, "test_linalg": {"TestLinalgCUDA": 523.0890000000019}, "test_logging": {"LoggingTest": 4.58}, "test_masked": {"TestMaskedCUDA": 55.64900000000012}, "test_maskedtensor": {"TestBasicsCUDA": 0.335, "TestBinary": 0.5465000000000004, "TestOperatorsCUDA": 10.58999999999994, "TestReductions": 0.12400000000000003, "TestUnary": 0.4095000000000003}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.025500000000000012, "TestMatmulCudaCUDA": 72.78399999999999, "TestMixedDtypesLinearCudaCUDA": 0.0005}, "test_meta": {"TestMetaCUDA": 4070.8894999999115, "TestMetaConverter": 0.328}, "test_mkl_verbose": {"TestMKLVerbose": 7.5794999999999995}, "test_mkldnn_fusion": {"TestMkldnnFusion": 61.85900000000001}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 6.667999999999999}, "test_mobile_optimizer": {"TestOptimizer": 4.974500000000001}, "test_model_dump": {"TestModelDump": 1.9734999999999998}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.4195}, "test_module_init": {"TestModuleInitCUDA": 2.0479999999999974}, "test_module_tracker": {"TestModuleTracker": 0.40850000000000003}, "test_modules": {"TestModuleCUDA": 858.8549999999881}, "test_monitor": {"TestMonitor": 0.461, "TestMonitorTensorboard": 0.23299999999999998}, "test_multiprocessing": {"TestMultiprocessing": 158.38899999999998}, "test_multiprocessing_spawn": {"ErrorTest": 0.0045000000000000005, "ForkTest": 0.9970000000000001, "SpawnTest": 48.88900000000001}, "test_namedtensor": {"TestNamedTensor": 1.1935000000000002}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 3.053}, "test_native_functions": {"TestNativeFunctions": 0.6405000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 1.1095000000000006}, "test_nestedtensor": {"TestNestedTensor": 0.24850000000000014, "TestNestedTensorAutogradCUDA": 1.8779999999999997, "TestNestedTensorDeviceTypeCUDA": 2.1554999999999955, "TestNestedTensorSubclassCUDA": 2.5994999999999973}, "test_nn": {"TestAddRelu": 0.006, "TestConstantPadNd": 0.006, "TestFunctionalPickle": 0.003, "TestFusionEval": 0.5745, "TestFusionUtils": 0.009000000000000001, "TestNN": 94.32200000000024, "TestNNDeviceTypeCUDA": 201.11249999999362, "TestUtils": 0.006}, "test_numba_integration": {"TestNumbaIntegration": 0.1905}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.3120000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 7.2195}, "test_ops": {"TestCommonCUDA": 5920.565999999966, "TestCompositeComplianceCUDA": 1500.960499999995, "TestFakeTensorCUDA": 1675.6914999999983, "TestMathBitsCUDA": 177.60000000000014, "TestSelfKwarg": 0.017, "TestTagsCUDA": 4.585500000000003}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1814.5209999999875}, "test_ops_gradients": {"TestBwdGradientsCUDA": 2517.927499999999}, "test_ops_jit": {"TestJitCUDA": 1794.3759999999982}, "test_optim": {"TestDifferentiableOptimizer": 0.3565, "TestLRScheduler": 1.6139999999999985, "TestOptim": 99.89866666666667, "TestOptimRenewedCUDA": 379.059, "TestSWAUtils": 1.2240000000000002}, "test_out_dtype_op": {"TestOutDtypeOp": 0.6935000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.0045000000000000005, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.006, "TestGradCheckOverride": 0.04, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.015, "TestIterator": 0.003, "TestNamedTuple": 0.003, "TestPickle": 0.0045000000000000005, "TestRNN": 0.0045000000000000005, "TestResolveName": 0.216, "TestTorchFunctionMode": 0.07200000000000004, "TestTorchFunctionOverride": 4.77499999999981, "TestTorchFunctionWarning": 0.0205, "TestWrapTorchFunction": 0.003}, "test_package": {"DirectoryReaderTest": 0.068, "ModelTest": 0.0045000000000000005, "TestAnalyze": 0.4275, "TestDependencyAPI": 0.07950000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.03600000000000001, "TestGlobGroup": 0.04350000000000002, "TestImporter": 0.018000000000000002, "TestLoadBCPackages": 0.1015, "TestMangling": 0.033, "TestMisc": 0.054000000000000006, "TestPackageFX": 0.10750000000000001, "TestPackageScript": 3.172999999999999, "TestRepackage": 0.0105, "TestResources": 0.017, "TestSaveLoad": 0.05499999999999999}, "test_per_overload_api": {"TestPerOverloadAPI": 0.41750000000000004}, "test_prims": {"TestDecompCUDA": 0.22250000000000003, "TestPrimsBasic": 0.05, "TestPrimsCUDA": 0.4485000000000001, "TestRefsCUDA": 0.018000000000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.2, "TestGenericProxyTensorFake": 3.6534999999999993, "TestGenericProxyTensorReal": 3.8390000000000004, "TestGenericProxyTensorSymbolic": 30.177499999999995, "TestRealProxyTensor": 0.027000000000000003, "TestSymbolicTracing": 6.516}, "test_pruning_op": {"PruningOpTest": 0.726}, "test_public_bindings": {"TestPublicBindings": 9.804499999999999}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.0345, "TestPythonDispatch": 0.36450000000000016, "TestPythonDispatcher": 0.0105, "TestPythonRegistration": 2.5104999999999995, "TestWrapperSubclassAliasingCUDA": 0.22450000000000003}, "test_pytree": {"TestCxxPytree": 0.02250000000000001, "TestGenericPytree": 0.6010000000000001, "TestPythonPytree": 0.10700000000000005}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.033, "TestAOMigrationNNQuantized": 0.08200000000000002, "TestAOMigrationQuantization": 0.031, "TestAOMigrationQuantizationFx": 0.0565, "TestBackendConfig": 0.07100000000000001, "TestBiasCorrectionEager": 1.3195000000000001, "TestBits": 0.005, "TestBitsCUDA": 0.0385, "TestComparatorOps": 2.1685, "TestDeprecatedJitQuantized": 5.6665, "TestDistributed": 0.0405, "TestDuplicateDQPass": 6.0809999999999995, "TestDynamicQuantizedModule": 38.548500000000004, "TestDynamicQuantizedOps": 17.7945, "TestEqualizeEager": 0.15650000000000003, "TestEqualizeFx": 6.965, "TestFXGraphMatcher": 3.2505, "TestFXGraphMatcherModels": 16.142000000000003, "TestFXNumericSuiteCoreAPIs": 47.210499999999996, "TestFXNumericSuiteCoreAPIsModels": 68.15350000000001, "TestFXNumericSuiteNShadows": 59.355999999999995, "TestFakeQuantize": 0.47750000000000004, "TestFakeQuantizeOps": 39.173500000000004, "TestFloat8DtypeCUDA": 0.659, "TestFuseEager": 4.272499999999999, "TestFuseFx": 3.2824999999999998, "TestFusedObsFakeQuant": 0.48800000000000004, "TestFusedObsFakeQuantModule": 0.5045, "TestFusionPasses": 0.036000000000000004, "TestFxDetectInputWeightEqualization": 0.308, "TestFxDetectOutliers": 0.4195, "TestFxModelReportClass": 0.8550000000000001, "TestFxModelReportDetectDynamicStatic": 0.11399999999999999, "TestFxModelReportDetector": 0.3275, "TestFxModelReportObserver": 0.3975, "TestFxModelReportVisualizer": 0.367, "TestGenerateNumericDebugHandle": 1.359, "TestGraphUtils": 3.5855, "TestHistogramObserver": 66.086, "TestMetaDataPorting": 13.607, "TestModelNumericsEager": 0.9125, "TestNumericSuiteEager": 11.981, "TestObserver": 6.3255, "TestPT2ERepresentation": 50.997499999999995, "TestPadding": 16.790999999999997, "TestQNNPackOps": 4.4110000000000005, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 3.0315000000000003, "TestQuantizeDynamicJitPasses": 7.6165, "TestQuantizeEagerOps": 2.7895, "TestQuantizeEagerPTQDynamic": 12.310500000000001, "TestQuantizeEagerPTQStatic": 37.968, "TestQuantizeEagerQAT": 11.834500000000002, "TestQuantizeEagerQATNumerics": 3.1645, "TestQuantizeFx": 46.576, "TestQuantizeFxModels": 17.209999999999997, "TestQuantizeFxOps": 176.82800000000003, "TestQuantizeJit": 34.81750000000001, "TestQuantizeJitOps": 393.8734999999999, "TestQuantizeJitPasses": 9.453000000000001, "TestQuantizePT2E": 150.92350000000002, "TestQuantizePT2EQAT": 772.365, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 1325.549, "TestQuantizePT2EQAT_ConvBn2d": 1327.8415, "TestQuantizePT2EX86Inductor": 268.19199999999995, "TestQuantizedConv": 52.8755, "TestQuantizedEmbeddingOps": 1.1995, "TestQuantizedFunctionalOps": 1.943, "TestQuantizedLinear": 22.212000000000003, "TestQuantizedOps": 140.1495, "TestQuantizedTensor": 4.5415, "TestRecordHistogramObserver": 0.05, "TestReferenceQuantizedModule": 0.06999999999999999, "TestSerialization": 2.0324999999999998, "TestStaticQuantizedModule": 69.52, "TestSubgraphRewriter": 0.974, "TestUtils": 0.0275, "TestXNNPACKQuantizer": 80.323, "TestXNNPACKQuantizerModels": 5.868}, "test_reductions": {"TestReductionsCUDA": 203.6894999999931}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 25.062000000000005}, "test_schema_check": {"TestSchemaCheck": 0.1900000000000001, "TestSchemaCheckModeOpInfoCUDA": 494.74799999998953}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 4.6839999999999975}, "test_serialization": {"TestBothSerializationCUDA": 0.18, "TestOldSerialization": 40.814, "TestSerialization": 17.616, "TestSubclassSerialization": 0.052000000000000005}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.44799999999999995}, "test_shape_ops": {"TestShapeOpsCUDA": 2.194999999999999}, "test_show_pickle": {"TestShowPickle": 0.4445}, "test_sort_and_select": {"TestSortAndSelectCUDA": 8.854499999999991}, "test_sparse": {"TestSparseAnyCUDA": 900.7559999999986, "TestSparseCUDA": 66.66550000000001, "TestSparseLegacyAndDeprecation": 0.2505, "TestSparseMaskedReductionsCUDA": 4.5175, "TestSparseMeta": 7.3134999999999994, "TestSparseOneOff": 0.2895, "TestSparseUnaryUfuncsCUDA": 11.50399999999993}, "test_sparse_csr": {"TestSparseCSRCUDA": 286.8254999999978, "TestSparseCSRSampler": 1.103, "TestSparseCompressedCUDA": 220.45249999999987, "TestSparseCompressedTritonKernelsCUDA": 0.015000000000000003}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005, "TestCUSPARSELTCUDA": 0.056000000000000036, "TestSparseSemiStructuredCUDA": 0.1470000000000001, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.04200000000000002, "TestSparseSemiStructuredCUTLASSCUDA": 0.02400000000000001, "TestSparseSemiStructuredTrainingCUDA": 0.030000000000000016}, "test_spectral_ops": {"TestFFTCUDA": 31.861499999999953}, "test_stateless": {"TestPythonOptimizeMode": 6.215999999999999, "TestStatelessDeprecation": 3.028, "TestStatelessFunctionalAPI": 0.38000000000000017}, "test_subclass": {"TestSubclass": 0.7815000000000002}, "test_sympy_utils": {"TestNumbers": 0.044000000000000004, "TestSingletonInt": 0.009000000000000001, "TestSympyInterp": 16.5435, "TestSympySolve": 0.4650000000000001, "TestValueRanges": 11.761500000000002}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 1.0770000000000008, "TestLikeTensorCreationCUDA": 0.018000000000000002, "TestRandomTensorCreationCUDA": 0.5615000000000001, "TestTensorCreationCUDA": 140.47949999999946}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.034, "TestTensorBoardFigure": 0.003, "TestTensorBoardNumpy": 0.012, "TestTensorBoardPyTorchNumpy": 0.35050000000000003, "TestTensorBoardPytorchGraph": 46.3055, "TestTensorBoardSummary": 0.05700000000000002, "TestTensorBoardSummaryWriter": 0.013500000000000002, "TestTensorBoardUtils": 0.2535, "TestTensorBoardWriter": 0.1175, "TestTensorProtoSummary": 0.021}, "test_tensorexpr": {"TestTensorExprFuser": 212.12150000000003}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.0165, "TestTensorExprPyBind": 1.4065000000000003}, "test_testing": {"TestAssertClose": 0.17250000000000007, "TestAssertCloseContainer": 0.0115, "TestAssertCloseErrorMessage": 0.10200000000000001, "TestAssertCloseMultiDeviceCUDA": 0.015, "TestAssertCloseQuantized": 0.020499999999999997, "TestAssertCloseSparseBSC": 0.028500000000000004, "TestAssertCloseSparseBSR": 0.029500000000000005, "TestAssertCloseSparseCOO": 0.03900000000000001, "TestAssertCloseSparseCSC": 0.029, "TestAssertCloseSparseCSR": 0.029000000000000005, "TestFrameworkUtils": 22.547, "TestImports": 21.7335, "TestMakeTensorCUDA": 3.2489999999999744, "TestOpInfoSampleFunctionsCUDA": 6.937999999999906, "TestOpInfos": 0.006, "TestTestParametrization": 0.051500000000000025, "TestTestParametrizationDeviceTypeCUDA": 6.439999999999997, "TestTestingCUDA": 1.1335000000000002}, "test_torch": {"TestBasicVitalSigns": 0.0405, "TestDevicePrecisionCUDA": 0.13400000000000004, "TestTorch": 10.124499999999976, "TestTorchDeviceTypeCUDA": 217.69549999999964, "TestVitalSignsCudaCUDA": 0.003}, "test_transformers": {"TestAttnBiasCUDA": 3.2135, "TestAttnMasksCUDA": 0.8620000000000001, "TestSDPACUDA": 4.519499999999846, "TestSDPACudaOnlyCUDA": 222.6215000000091, "TestSDPAFailureModesCUDA": 0.10900000000000006, "TestTransformersCUDA": 8.145499999999998}, "test_type_hints": {"TestTypeHints": 0.42699999999999994}, "test_type_info": {"TestDTypeInfo": 0.4465}, "test_type_promotion": {"TestTypePromotionCUDA": 15.15949999999996}, "test_typing": {"TestTyping": 131.68949999999995}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 882.0534999999168}, "test_utils": {"TestAssert": 0.11199999999999999, "TestBottleneck": 18.918, "TestCheckpoint": 0.31800000000000006, "TestCollectEnv": 1.7839999999999998, "TestCppExtensionUtils": 0.048, "TestDataLoaderUtils": 0.27, "TestDeviceUtilsCUDA": 26.315500000000746, "TestExtensionUtils": 0.006, "TestHipify": 0.003, "TestHipifyTrie": 0.012, "TestONNXUtils": 0.006, "TestRenderUtils": 0.021, "TestStandaloneCPPJIT": 3.9459999999999997, "TestTraceback": 0.015}, "test_view_ops": {"TestOldViewOpsCUDA": 29.75549999999999, "TestViewOpsCUDA": 1.8455000000000001}, "test_vulkan": {"TestVulkanRewritePass": 0.0015}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.026999999999999996, "WeakKeyDictionaryTestCase": 0.0335, "WeakTest": 6.953999999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 3.473, "TestXNNPACKRewritePass": 1.4615, "TestXNNPACKSerDes": 4.3469999999999995}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0105}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.47350000000000003, "TestClassGetItem": 0.003, "TestDtypeAttributeDeletion": 0.001, "TestFromDTypeAttribute": 0.0045000000000000005, "TestMisc": 0.006, "TestPickling": 0.21750000000000003, "TestPromotion": 0.007}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 28.42, "TestEinsumPath": 0.0025, "TestMisc": 0.009000000000000001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0015, "TestFinfo": 0.003, "TestHalf": 0.0015, "TestIinfo": 0.45799999999999996, "TestMisc": 0.0075, "TestPythonFloat": 0.0025, "TestRepr": 0.006, "TestSingle": 0.0015}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.009000000000000001, "TestBroadcastedAssignments": 0.025500000000000002, "TestFancyIndexingCast": 0.006, "TestFloatNonIntegerArgument": 0.015, "TestIndexing": 0.6750000000000003, "TestMultiIndexingAutomated": 0.015, "TestMultipleEllipsisError": 0.003, "TestNonIntegerArrayLike": 0.0015}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.04050000000000001, "TestArgmax": 1.977, "TestArgmaxArgminCommon": 0.3060000000000002, "TestArgmin": 2.0444999999999998, "TestArrayAttributeDeletion": 0.012, "TestArrayConstruction": 0.08250000000000002, "TestArrayCreationCopyArgument": 0.012000000000000002, "TestArrayInterface": 0.022000000000000002, "TestAssignment": 0.023000000000000007, "TestAttributes": 0.03950000000000001, "TestBinop": 0.037500000000000006, "TestBool": 49.56450000000002, "TestCequenceMethods": 0.003, "TestChoose": 0.04200000000000001, "TestClip": 0.012, "TestCompress": 0.009000000000000001, "TestConversion": 0.076, "TestCreation": 0.007, "TestDelMisc": 0.003, "TestDot": 0.12700000000000006, "TestDtypedescr": 0.003, "TestFancyIndexing": 0.055499999999999994, "TestFlag": 0.021500000000000005, "TestFormat": 0.009000000000000001, "TestFromBuffer": 0.026500000000000003, "TestHash": 0.2915, "TestHashing": 0.006, "TestIO": 0.0075, "TestInner": 0.4375, "TestLexsort": 0.03600000000000001, "TestMatmul": 0.8550000000000002, "TestMatmulOperator": 0.5860000000000001, "TestMethods": 2.8015000000000003, "TestMinMax": 0.009000000000000001, "TestMinScalarType": 0.013000000000000001, "TestNewaxis": 0.0075, "TestPEP3118Dtype": 0.0095, "TestPutmask": 0.020999999999999998, "TestRepeat": 0.025500000000000002, "TestResize": 0.093, "TestRichcompareScalar": 0.0015, "TestScalarIndexing": 0.04050000000000001, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.3025000000000001, "TestStats": 0.4655, "TestSubscripting": 0.003, "TestTake": 0.067, "TestVdot": 0.07300000000000001, "TestViewDtype": 0.006, "TestWarnings": 0.003, "TestWhere": 0.5875, "TestWritebackIfCopy": 0.046000000000000006}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.037500000000000006, "TestArgwhere": 0.053000000000000005, "TestArrayComparisons": 0.0225, "TestBaseRepr": 0.01, "TestBinaryRepr": 0.016, "TestBoolArray": 3.495, "TestBoolCmp": 0.3465, "TestBoolScalar": 0.014500000000000002, "TestBroadcast": 0.015000000000000003, "TestClip": 0.3490000000000002, "TestConvolve": 0.036500000000000005, "TestCorrelate": 0.0615, "TestCreationFuncs": 2.233, "TestCross": 0.097, "TestDtypePositional": 0.003, "TestFloatExceptions": 0.018000000000000002, "TestFromiter": 0.003, "TestIndex": 0.0095, "TestIndices": 0.07650000000000001, "TestIsclose": 0.165, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0045000000000000005, "TestMoveaxis": 0.015, "TestNonarrayArgs": 0.2110000000000001, "TestNonzeroAndCountNonzero": 0.47550000000000003, "TestOuterMisc": 0.0095, "TestRequire": 0.012, "TestResize": 0.4585, "TestRoll": 0.05950000000000001, "TestRollaxis": 0.0075, "TestSeterr": 0.012, "TestStdVar": 0.05399999999999999, "TestStdVarComplex": 0.024, "TestStringFunction": 0.003, "TestTensordot": 0.025500000000000002, "TestTypes": 0.028000000000000004}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.003, "TestCommonType": 0.4035, "TestDocStrings": 0.0015, "TestIsSubDType": 0.0155, "TestScalarTypeNames": 0.03850000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.18000000000000013, "TestFromInt": 0.012, "TestFromString": 0.4375}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.004, "TestBitCount": 0.002, "TestClassGetItem": 0.0055, "TestClassGetitemMisc": 0.0045000000000000005, "TestIsInteger": 0.003}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0015}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.20400000000000001, "TestBaseMath": 19.2585, "TestBitShifts": 0.18250000000000002, "TestComplexDivision": 0.1215, "TestConversion": 0.11150000000000002, "TestHash": 0.0035, "TestModulus": 2.0155, "TestMultiply": 0.0015, "TestNegative": 0.037500000000000006, "TestPower": 0.2625, "TestRepr": 0.003, "TestScalarOpsMisc": 0.10150000000000006, "TestScalarSubclassingMisc": 0.11800000000000008, "TestSubtract": 0.037000000000000005, "TestTypes": 30.7905}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.4435, "TestAtleast2d": 0.027000000000000003, "TestAtleast3d": 0.024, "TestBlock": 0.050000000000000024, "TestConcatenate": 0.2565000000000002, "TestHstack": 0.03150000000000001, "TestStackMisc": 0.032500000000000015, "TestVstack": 0.03600000000000001}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.022, "TestFFTShift": 12.431999999999999, "TestIRFFTN": 0.0055, "TestRFFTFreq": 0.021}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 5.193, "TestFFTShift": 0.4365, "TestFFTThreadSafe": 1.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.47850000000000004}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0045000000000000005, "TestUnique": 0.6920000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.012, "TestAmax": 0.012, "TestAmin": 0.012, "TestAngle": 0.018000000000000002, "TestAny": 0.012, "TestAverage": 0.05650000000000001, "TestBincount": 0.0765, "TestCheckFinite": 0.006, "TestCopy": 0.014000000000000002, "TestCorrCoef": 0.06350000000000001, "TestCov": 0.11650000000000002, "TestCumprod": 0.0605, "TestCumsum": 0.0805, "TestDelete": 0.0325, "TestDiff": 0.138, "TestDigitize": 0.03300000000000001, "TestExtins": 0.0105, "TestFilterwindows": 1.0645000000000007, "TestFlip": 0.05850000000000001, "TestGradient": 0.2685, "TestInsert": 0.019500000000000003, "TestInterp": 0.08550000000000005, "TestKaiser": 0.021, "TestMedian": 0.21000000000000002, "TestMeshgrid": 0.10600000000000001, "TestMsort": 0.0015, "TestPercentile": 0.2680000000000002, "TestPiecewise": 0.022, "TestProd": 0.059, "TestPtp": 0.018000000000000002, "TestQuantile": 0.059500000000000025, "TestRot90": 0.533, "TestSelect": 0.018000000000000002, "TestSinc": 0.0165, "TestSortComplex": 0.021, "TestTrapz": 0.0115, "TestTrimZeros": 0.023, "TestUnique": 0.007, "Test_I0": 0.028000000000000004}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.6590000000000003, "TestHistogramOptimBinNums": 0.051000000000000024, "TestHistogramdd": 0.2695000000000001}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.003, "TestConcatenator": 0.0175, "TestDiagIndices": 0.009000000000000001, "TestDiagIndicesFrom": 0.015, "TestFillDiagonal": 0.0475, "TestGrid": 0.021, "TestIndexExpression": 0.0205, "TestIx_": 0.015, "TestNdIndex": 0.003, "TestNdenumerate": 0.003, "TestRavelUnravelIndex": 0.47350000000000003}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.031000000000000007, "TestApplyOverAxes": 0.0035, "TestArraySplit": 0.3360000000000001, "TestColumnStack": 0.018500000000000003, "TestDsplit": 0.021, "TestDstack": 0.030000000000000006, "TestExpandDims": 0.015000000000000001, "TestHsplit": 0.026000000000000002, "TestKron": 0.03450000000000001, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.02, "TestSplit": 0.0135, "TestSqueeze": 0.0645, "TestTakeAlongAxis": 0.527, "TestTile": 0.17049999999999998, "TestVsplit": 0.018000000000000002}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.05500000000000001, "TestEye": 0.5205000000000001, "TestFliplr": 0.0105, "TestFlipud": 0.009000000000000001, "TestHistogram2d": 0.063, "TestTri": 0.169, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.0045000000000000005, "TestTriuIndicesFrom": 0.003, "TestVander": 0.034}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.003, "TestCommonType": 0.4605, "TestImag": 0.0235, "TestIscomplex": 0.009000000000000001, "TestIscomplexobj": 0.009000000000000001, "TestIsfinite": 0.021, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.021, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.015, "TestIsrealobj": 0.003, "TestIsscalar": 0.0035, "TestMintypecode": 0.009000000000000001, "TestNanToNum": 0.030000000000000006, "TestReal": 0.028000000000000004, "TestRealIfClose": 0.0075}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.24950000000000008, "TestCond": 0.42800000000000005, "TestDet": 0.29600000000000004, "TestEig": 0.06300000000000001, "TestEigh": 0.049000000000000016, "TestEighCases": 0.0, "TestEigvals": 0.10600000000000001, "TestEigvalsh": 0.04200000000000001, "TestEigvalshCases": 0.0, "TestInv": 0.0945, "TestLstsq": 0.40650000000000003, "TestMatrixRank": 0.78, "TestMisc": 0.0315, "TestMisc2": 0.006, "TestMultiDot": 0.09050000000000001, "TestNormDouble": 1.6035000000000004, "TestNormInt64": 1.618, "TestNormSingle": 1.6664999999999999, "TestNorm_NonSystematic": 0.006500000000000001, "TestPinv": 0.21600000000000003, "TestPinvHermitian": 0.0665, "TestQR": 0.9050000000000001, "TestSVD": 0.08450000000000002, "TestSVDHermitian": 0.18350000000000002, "TestSolve": 0.505, "TestTensorinv": 0.0325, "TestTensorsolve": 0.0105}, "torch_np/test_basic": {"TestArrayToSequence": 0.018000000000000002, "TestCopyTo": 0.0105, "TestCtorNested": 0.006, "TestDefaultDtype": 0.012, "TestDivmod": 0.028000000000000004, "TestExport": 0.0005, "TestMisc": 0.273, "TestNormalizations": 0.009000000000000001, "TestOneArr": 0.6990000000000005, "TestOneArrAndAxesTuple": 0.027000000000000003, "TestOneArrAndAxis": 0.3975000000000003, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.027000000000000003, "TestPythonArgsToArray": 0.030000000000000006, "TestSequenceOfArrays": 0.04800000000000002, "TestSequenceOfArraysToSingle": 0.021, "TestShapeLikeToArray": 0.012, "TestSmokeNotImpl": 0.003}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.6495000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.5815000000000001}, "torch_np/test_function_base": {"TestAppend": 0.44199999999999995}, "torch_np/test_ndarray_methods": {"TestAmax": 0.015, "TestAmin": 0.015, "TestArgmax": 1.8640000000000003, "TestArgmaxArgminCommon": 0.3055000000000002, "TestArgmin": 2.0400000000000005, "TestContains": 0.003, "TestIndexing": 0.41850000000000004, "TestIter": 0.009000000000000001, "TestNoExtraMethods": 0.018000000000000002, "TestNonzero": 0.3025, "TestRavel": 0.012, "TestReshape": 0.0075, "TestTranspose": 0.0165}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.11350000000000006, "TestNEP50Table": 0.006500000000000001}, "torch_np/test_random": {"TestChoice": 0.019500000000000003, "TestNumpyGlobal": 0.006, "TestScalarReturn": 0.5395000000000001, "TestShuffle": 0.019500000000000003}, "torch_np/test_reductions": {"TestAll": 0.021, "TestAny": 0.021, "TestFlatnonzero": 0.43499999999999994, "TestGenericCumSumProd": 0.036000000000000004, "TestGenericReductions": 3.4859999999999562, "TestMean": 0.035500000000000004, "TestSum": 0.42300000000000004}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.4595000000000001, "TestIsScalar": 0.05800000000000003}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 1.0290000000000008, "TestNdarrayDunderVsUfunc": 0.40400000000000014, "TestUfuncDtypeKwd": 0.009000000000000001, "TestUnaryUfuncs": 0.5525000000000001}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.6805000000000002}}}, "linux-focal-cuda11.8-py3.9-gcc9": {"multigpu": {"distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShardNDTraining": 32.27}, "distributed/_shard/sharded_tensor/test_sharded_tensor": {"TestCreateTensorFromParams": 0.258, "TestCreateTensorNoProcessGroupMode": 0.003, "TestLocalTensor": 12.634, "TestModuleHookApi": 12.783000000000001, "TestShardMetadata": 19.444, "TestShardParameter": 12.5565, "TestShardTensor": 19.1005, "TestShardedTensorChunked": 199.13950000000003, "TestShardedTensorCustomOps": 29.3145, "TestShardedTensorEnumerable": 133.144, "TestShardedTensorFromLocalShards": 88.549, "TestShardedTensorFromLocalTensor": 19.7435, "TestShardedTensorMetadata": 0.4015, "TestShardedTensorSubGroupInit": 0.06}, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": {"TestReshard": 13.440999999999999}, "distributed/_shard/sharding_plan/test_sharding_plan": {"TestShardingPlan": 20.512999999999998}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 24.859, "TestShardingSpec": 0.0435}, "distributed/_tensor/test_device_mesh": {"DeviceMeshCollectiveTest": 19.574, "DeviceMeshTest": 19.176000000000002, "DeviceMeshTestNDim": 5.651, "InitDeviceMeshTest": 8.433, "TestDeviceMeshGetItem": 16.866999999999997}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 12.819999999999999, "TestDTensorCompileE2E": 35.036, "TestDTensorCompileWithNativeFunCol": 0.22799999999999998}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 6.6625, "DistTensorRandomOpTest": 39.699000000000005}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 11.693, "TestDistributedFailure": 35.591499999999996}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 23.0015, "TestDistributedStateDictSaveLoad": 0.6495, "TestDistributedStateDictSaveLoadWithSharedTensor": 5.747999999999999}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 0.782}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.367}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 18.451499999999996}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 8.887}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 110.6315, "TestFSDPCheckpointSubmodule": 6.766500000000001}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 44.6565}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 55.702, "TestExplicitUnshard": 12.0775}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 188.52850000000004}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 7.618, "TestHooks": 48.5205, "TestNoGrad": 13.9855, "TestParamInit": 13.933499999999999, "TestParityWithDDP": 1407.0955}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 103.25450000000001}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 54.149}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 33.975}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 59.13249999999999}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 227.06349999999998}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.3845}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 50.209}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 80.8675}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 78.184}, "distributed/fsdp/test_fsdp_input": {"TestInput": 10.9875}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 13.384500000000001}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 47.623000000000005}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 81.58650000000002, "TestFSDPMiscMultiThread": 0.7400000000000002, "TestFSDPMiscWorldSize1": 0.094}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 35.528999999999996, "TestFSDPMixedPrecisionIgnoredModules": 5.312, "TestFSDPMixedPrecisionSharded": 332.3915000000002, "TestFSDPMixedPrecisionUnsharded": 16.4345, "TestFSDPTrainEval": 8.3665}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 6.984}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 7.1305}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 456.76149999999996}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 30.5505, "TestForwardOverlapWorldSizeTwo": 45.5655}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 14.091999999999999}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.65, "TestShardedGradScalerParityWithDDP": 142.181}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 1039.8309999999997, "TestFSDPStateDict4GPUs": 7.417999999999999}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 37.082499999999996}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 5.978}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 7.0785}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 55.980500000000006, "TestUnshardParamsErrors": 23.004, "TestUnshardParamsNoShard": 10.9255}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 7.0665000000000004, "TestFSDPUseOrigParamsInit": 6.917, "TestFSDPUseOrigParamsMultipleParamGroups": 204.33950000000002, "TestFSDPUseOrigParamsNoSync": 12.527, "TestFSDPUseOrigParamsParamAccess": 6.3125, "TestFSDPUseOrigParamsUnshardReshard": 31.2125, "TestFSDPUseOrigParamsWriteback": 31.014999999999997, "TestMultiTensorApply": 0.253}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 72.15950000000001}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 6.0155, "TestShardUtilsDistributedDTensor": 5.7135}, "distributed/fsdp/test_utils": {"TestUtils": 0.6244999999999999}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 5.671999999999999, "TestFSDPWrap": 160.763, "TestWrapUtils": 0.018000000000000002}, "distributed/pipelining/test_composability": {"ComposabilityTest": 32.416000000000004}, "distributed/rpc/cuda/test_tensorpipe_agent": {"TensorPipeCudaDdpComparisonTest": 7.3105, "TensorPipeCudaDistAutogradTest": 20.938, "TensorPipeCudaRemoteModuleTest": 22.0975, "TensorPipeCudaRpcTest": 6.859999999999999, "TensorPipePipeWithDDPTest": 120.876, "TensorPipeTensorPipeAgentCudaRpcTest": 749.7955000000001, "TensorPipeTensorPipeCudaDistAutogradTest": 24.583}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 8.777}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"Test2dParallelIntegration": 32.605000000000004, "TestNew2dParallelStateDict": 58.835499999999996, "TestNew2dParallelTraining": 39.5}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 48.370000000000005}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 8.52}, "distributed/test_c10d_common": {"CommTest": 4.173500000000001, "ComputeBucketAssignmentTest": 1.4475, "LocalRankTest": 18.4545, "ProcessGroupWithDispatchedCollectivesTests": 8.7015, "PythonProcessGroupExtensionTest": 37.435, "ReduceOpTest": 1.479, "TimeoutTest": 46.9095}, "distributed/test_c10d_functional_native": {"C10DFunctionalNativeCompileTest": 100.116, "C10DFunctionalNativeTest": 31.764000000000003}, "distributed/test_c10d_gloo": {"CommTest": 50.1995, "CompilerTest": 53.08300000000001, "DistributedDataParallelTest": 197.7565, "GlooProcessGroupWithDispatchedCollectivesTests": 29.292000000000005, "LargeCommTest": 14.222, "ProcessGroupGlooTest": 267.94750000000005, "ReducerTest": 0.235, "RendezvousEnvTest": 0.3915, "TimeoutTest": 4.931}, "distributed/test_c10d_nccl": {"CommTest": 102.22999999999999, "CompilerTest": 76.465, "DistributedDataParallelTest": 381.4219999999999, "LargeCommTest": 94.99849999999999, "NCCLTraceTest": 141.686, "NCCLTraceTestDumpOnTimeout": 15.763499999999999, "NCCLTraceTestTimeoutDumpOnIdleRanks": 10.4285, "NCCLTraceTestTimeoutDumpOnStuckRanks": 8.636000000000001, "NcclErrorDumpTest": 28.366500000000002, "NcclErrorHandlingTest": 69.94999999999999, "NcclProcessGroupWithDispatchedCollectivesTests": 37.2575, "ProcessGroupNCCLGroupTest": 100.5705, "ProcessGroupNCCLNoGPUTest": 0.0015, "ProcessGroupNCCLTest": 185.37199999999999, "RendezvousEnvTest": 0.0495, "SparseCollective": 4.8260000000000005, "TimeoutTest": 4.531, "WorkHookTest": 31.6445}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 1.3410000000000002, "TestDistributedNNFunctionsGloo": 39.7705}, "distributed/test_c10d_spawn_nccl": {"TestDistributedNNFunctionsNccl": 48.952}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 0.0}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 32.11300000000001, "DeviceMeshCollectiveTestWithNativeFunCol": 12.656500000000001, "DeviceMeshTest": 72.93699999999998, "DeviceMeshTestNDim": 27.847, "DeviceMeshTestWithNativeFunCol": 31.1785, "InitDeviceMeshTest": 16.1055, "TestDeviceMeshGetItem": 32.5135, "TestMeshEnv": 25.865499999999997}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 36.738, "TestExpand": 0.35550000000000004, "TestFunctionalAutograd": 14.340499999999999, "TestFunctionalAutogradWithNCCL": 5.4145, "TestGradCollectives": 0.006, "TestMakeFx": 0.051500000000000004, "TestMetaCollectives": 0.002, "TestNCCLCollectivesWithWorldSize4": 48.676, "TestOpWaitiness": 11.992666666666665, "TestPgTag": 0.052000000000000005, "TestTraceableCollectives": 1.2090000000000003}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 51.6455, "ProcessGroupNCCLWrapperTest": 50.289}, "distributed/test_store": {"FileStoreTest": 4.79, "HashStoreTest": 2.7590000000000003, "InitPgWithNonUvStore": 0.8600000000000001, "InitPgWithUvStore": 0.568, "LibUvTCPStoreTest": 13.6075, "PrefixFileStoreTest": 3.8569999999999998, "PrefixStoreTest": 0.027, "PrefixTCPStoreTest": 3.1470000000000002, "PythonStoreTest": 0.406, "RendezvousEnvTest": 0.397, "RendezvousFileTest": 0.77, "RendezvousTCPTest": 32.4435, "RendezvousTest": 0.7715000000000001, "TCPStoreTest": 13.565999999999999, "TestMultiThreadedWait": 2.7585000000000006, "TestPythonStore": 2.7720000000000002, "TimeoutTest": 7.9065}, "test_cuda_multigpu": {"TestCudaComm": 1.0025000000000002, "TestCudaMultiGPU": 7.537999999999999}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.4955}, "test_foreach": {"TestForeachCPU": 0.49750000000000005, "TestForeachCUDA": 0.21149999999999997}, "test_optim": {"TestOptim": 2.036, "TestOptimRenewedCPU": 0.07500000000000004, "TestOptimRenewedCUDA": 13.552499999999995}}}, "linux-focal-cuda12.1-py3-gcc9-slow-gradcheck": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 1.679}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.5759999999999998}, "distributions/test_distributions": {"TestAgainstScipy": 1.0339999999999998, "TestConstraints": 0.126, "TestDistributionShapes": 0.10900000000000007, "TestDistributions": 49.26600000000001, "TestFunctors": 0.008, "TestJit": 19.248000000000005, "TestKL": 2.5989999999999993, "TestLazyLogitsInitialization": 0.01, "TestNumericalStability": 0.06000000000000001, "TestRsample": 0.619, "TestValidation": 0.30900000000000005}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 14.322999999999999}, "dynamo/test_after_aot": {"TestAfterAot": 4.753}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.889}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 11.775000000000002}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.9540000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.5200000000000005}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.031, "TestCustomBackendAPI": 1.6179999999999999, "TestExplainWithBackend": 8.197, "TestOptimizations": 1.6839999999999995}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.413}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 4.562}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.211, "BytecodeTests": 0.444}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.292, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.5740000000000001}, "dynamo/test_config": {"ConfigTests": 0.5569999999999999}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.191, "CppGuardManagerFuncTorchHigherOrderOpTests": 9.623999999999999, "CppGuardManagerFunctionTests": 22.619999999999994, "CppGuardManagerHigherOrderOpTests": 6.328999999999998, "CppGuardManagerMiscTests": 39.1880000000001, "CppGuardManagerReproTests": 33.987000000000016}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.8949999999999996}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.2859999999999996}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.435}, "dynamo/test_decorators": {"DecoratorTests": 0.6520000000000001}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.013999999999999999, "TestDeviceGuard": 0.012}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 36.77899999999998, "DynamicShapesCtxManagerTests": 7.291, "DynamicShapesExportTests": 25.83099999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 88.58500000000002, "DynamicShapesFunctionTests": 59.722999999999935, "DynamicShapesHigherOrderOpTests": 16.879000000000005, "DynamicShapesMiscTests": 78.33000000000006, "DynamicShapesNNModuleTests": 5.764000000000001, "DynamicShapesReproTests": 87.39000000000006, "DynamicShapesSubGraphTests": 7.552999999999999, "DynamicShapesTestSDPA": 0.308}, "dynamo/test_exc": {"ExcTests": 1.768}, "dynamo/test_exceptions": {"ExceptionTests": 0.53}, "dynamo/test_export": {"ExportTests": 13.564999999999998}, "dynamo/test_export_mutations": {"MutationExportTests": 0.547}, "dynamo/test_frame_init": {"FrameInitTests": 0.212}, "dynamo/test_functions": {"DefaultsTests": 0.6460000000000002, "FunctionTests": 25.993000000000006}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.047}, "dynamo/test_global": {"TestGlobals": 0.53}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.24600000000000002}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 5.891000000000001, "FuncTorchHigherOrderOpTests": 6.587999999999997, "HigherOrderOpTests": 6.510999999999999, "HigherOrderOpVmapGuardTests": 3.210000000000001}, "dynamo/test_hooks": {"HooksTests": 22.76900000000001}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 9.068999999999999, "InlineInbuiltNNModulesExportTests": 13.116999999999997, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 9.246999999999996, "InlineInbuiltNNModulesFunctionTests": 24.683999999999987, "InlineInbuiltNNModulesHigherOrderOpTests": 6.276999999999999, "InlineInbuiltNNModulesMiscTests": 47.09500000000013, "InlineInbuiltNNModulesNNModuleTests": 3.930999999999997}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.433999999999999}, "dynamo/test_interop": {"InteropTests": 0.5680000000000001}, "dynamo/test_logging": {"LoggingTests": 15.925999999999997}, "dynamo/test_minifier": {"MinifierTests": 2.1130000000000004}, "dynamo/test_misc": {"MiscTests": 46.63600000000006, "TestTracer": 0.049}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0}, "dynamo/test_modules": {"NNModuleTests": 2.6729999999999987, "OptimizedModuleTest": 12.469}, "dynamo/test_nops": {"NopTests": 0.298}, "dynamo/test_optimizers": {"End2EndTests": 0.619, "OptimizerTests": 1.442}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.48700000000000004}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.3119999999999998}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.629}, "dynamo/test_recompiles": {"RecompileTests": 0.8070000000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.517}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.7033333333333335}, "dynamo/test_repros": {"ReproTests": 41.45399999999997}, "dynamo/test_resume": {"ResumeFunctionTests": 0.443}, "dynamo/test_sdpa": {"TestSDPA": 0.48300000000000004}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.55}, "dynamo/test_sources": {"SourceTests": 0.484}, "dynamo/test_structured_trace": {"StructuredTraceTest": 13.127}, "dynamo/test_subclasses": {"SubclassTests": 2.801999999999999, "TestNestedTensor": 12.674999999999999}, "dynamo/test_subgraphs": {"SubGraphTests": 1.956999999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.095, "TraceRuleTests": 1.151}, "dynamo/test_triton_kernels": {"KernelTests": 47.839, "MutationTests": 2.5260000000000007, "NoOptimizationKernelTests": 7.585000000000001, "no_opt_test_class": 9.010999999999997}, "dynamo/test_unspec": {"UnspecTests": 10.123000000000001}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.5790000000000001}, "dynamo/test_view": {"ViewTests": 0.635}, "export/test_converter": {"TestConverter": 4.515000000000001}, "export/test_db": {"ExampleTests": 2.6399999999999992}, "export/test_experimental": {"TestExperiment": 0.887}, "export/test_export": {"TestDynamismExpression": 0.484, "TestExport": 23.13299999999998, "TestExportCustomClass": 0.058, "TestOneOffModelExportResult": 0.987}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.44099999999999995, "NonStrictExportTestExport": 21.503000000000004}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.432, "PreDispatchExportTestExport": 22.616999999999994}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.22}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.5933333333333333}, "export/test_hop": {"TestHOPCUDA": 5.197000000000001, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.103, "TestLiftUnlift": 0.01}, "export/test_pass_infra": {"TestPassInfra": 0.8330000000000002}, "export/test_passes": {"TestPasses": 10.570999999999998}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.76, "RetraceExportTestExport": 34.767999999999994}, "export/test_safeguard": {"TestSafeguard": 0.672}, "export/test_schema": {"TestSchema": 0.253}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.21200000000000002, "SerDesExportPreDispatchTestExport": 17.098000000000006, "SerDesExportTestDynamismExpression": 0.555, "SerDesExportTestExport": 23.054999999999986}, "export/test_serialize": {"TestDeserialize": 6.975000000000002, "TestOpVersioning": 0.003, "TestSaveLoad": 0.254, "TestSchemaVersioning": 0.027, "TestSerialize": 0.9640000000000002, "TestSerializeCustomClass": 0.074}, "export/test_sparse": {"TestSparseProp": 49.07499999999992}, "export/test_tools": {"TestExportTools": 0.543}, "export/test_torchbind": {"TestCompileTorchbind": 0.8680000000000002, "TestExportTorchbind": 1.5429999999999993, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.217}, "export/test_unflatten": {"TestUnflatten": 2.6950000000000003}, "export/test_upgrade": {"TestUpgrade": 0.392}, "export/test_verifier": {"TestVerifier": 0.8570000000000001}, "functorch/test_ac": {"MemoryBudgetTest": 11.712}, "functorch/test_aotdispatch": {"TestAOTAutograd": 10.692999999999996, "TestAOTAutogradWithDynamo": 11.608, "TestAOTDispatch": 0.43600000000000005, "TestAOTExport": 1.9059999999999995, "TestAOTModuleSimplified": 0.533, "TestPartitioning": 2.8129999999999993}, "functorch/test_control_flow": {"TestControlFlow": 0.8840000000000002, "TestControlFlowTraced": 92.02900000000008}, "functorch/test_dims": {"TestMin": 13.312, "TestMinFunctorchOnly": 12.530999999999999}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.08900000000000004, "TestAutogradFunctionVmapAPICUDA": 0.020000000000000004, "TestCompileTransformsCUDA": 4.323, "TestComposabilityCUDA": 0.15600000000000006, "TestExamplesCorrectnessCUDA": 2.0060000000000002, "TestFunctionalizeCUDA": 0.31400000000000006, "TestGradTransformCUDA": 0.9020000000000002, "TestHelpersCUDA": 0.258, "TestHessianCUDA": 0.055, "TestHigherOrderOperatorInteractionCUDA": 0.026000000000000002, "TestJacCUDA": 0.6380000000000002, "TestJvpCUDA": 0.059000000000000025, "TestLinearizeCUDA": 0.7300000000000001, "TestMakeFunctional": 0.06600000000000002, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.018, "TestVmapOfGradCUDA": 0.6130000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.261}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.28300000000000003, "RandomOpTestCase": 0.07, "ReduceTestCase": 0.066, "TestMemoryEfficientOpAuthoring": 7.175999999999999}, "functorch/test_minifier": {"TestMinifier": 0.3930000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 3680.6069999999836}, "functorch/test_parsing": {"TestAnonymousAxis": 0.217, "TestParsedExpression": 0.004, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.257}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.8940000000000007, "TestTransformFailureCUDA": 0.098, "TestVmapAPI": 0.2920000000000001, "TestVmapBatchedGradientCUDA": 0.1990000000000001, "TestVmapDeviceTypeCUDA": 0.021000000000000005, "TestVmapNestedTensorCUDA": 0.04000000000000001, "TestVmapOperators": 2.3509999999999938, "TestVmapOperatorsOpInfoCUDA": 361.4099999999996}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 1.9459999999998994}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.584}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 652.9490000000001, "AOTInductorTestABICompatibleCpuWithStackAllocation": 451.40999999999997, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 199.18599999999998, "AOTInductorTestABICompatibleCuda": 1241.3339999999998, "AOTInductorTestNonABICompatibleCpu": 1398.956, "AOTInductorTestNonABICompatibleCuda": 2046.395}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.648000000000001, "BenchmarkFusionCudaTest": 75.404, "BenchmarkMultiTemplateFusionCudaTest": 13.176}, "inductor/test_binary_folding": {"FreezingCpuTests": 32.998, "FreezingCudaTests": 2.157}, "inductor/test_codecache": {"TestFxGraphCache": 117.49699999999999, "TestFxGraphCacheHashing": 0.747, "TestUtils": 3.24, "test_codecache": 3.0170000000000003}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.19}, "inductor/test_compile_worker": {"TestCompileWorker": 5.433}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 222.71900000000056, "TestAutogradWithCompiledAutograd": 278.8970000000004, "TestCompiledAutograd": 136.65099999999995, "TestCustomOpWithCompiledAutograd": 1.8159999999999954}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 588.1679999999999, "CompiledOptimizerTests": 1285.645}, "inductor/test_config": {"TestInductorConfig": 5.224000000000001}, "inductor/test_control_flow": {"CondTests": 83.06299999999999, "WhileLoopTests": 34.426}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 2.847}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 261.4495, "DynamicShapesCudaWrapperCudaTests": 824.0070000000001, "TestCppWrapper": 256.25749999999994, "TestCudaWrapper": 740.7175}, "inductor/test_cpu_repro": {"CPUReproTests": 556.1499999999999}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 975.7669999999999, "TestCudaWrapper": 942.355}, "inductor/test_cuda_repro": {"CudaReproTests": 88.722}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 67.702}, "inductor/test_custom_lowering": {"TestCustomLowering": 2.8089999999999997}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 9.871}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 50.878}, "inductor/test_debug_trace": {"TestDebugTrace": 12.391}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 29.328}, "inductor/test_dependencies": {"TestDependencies": 0.18000000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.1}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.001, "EfficientConvBNEvalCudaTests": 0.001}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.035}, "inductor/test_flex_attention": {"TestFlexAttention": 499.5060000000001, "TestTemplatedSDPA": 226.88099999999997}, "inductor/test_foreach": {"ForeachTests": 276.5130000000001}, "inductor/test_fp8": {"TestFP8Types": 0.008}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 70.34400000000001, "SDPAPatternRewriterCpuTests": 65.589, "SDPAPatternRewriterCudaDynamicTests": 39.433, "SDPAPatternRewriterCudaTests": 28.218}, "inductor/test_fx_fusion": {"TestFxFusion": 0.188}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.013}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.026, "TestGroupBatchFusion": 75.645, "TestPostGradBatchLinearFusion": 1.878}, "inductor/test_indexing": {"ExprPrinterTests": 0.038000000000000006, "TestIndexingSimplification": 2.48}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 45.732, "FreezingCudaTests": 28.372000000000003}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 5.019}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 138.888}, "inductor/test_layout_optim": {"TestLayoutOptim": 10.548000000000004}, "inductor/test_loop_ordering": {"LoopOrderingTest": 3.356}, "inductor/test_max_autotune": {"TestMaxAutotune": 288.748, "TestTuningProcess": 9.682}, "inductor/test_memory_planning": {"TestMemoryPlanning": 26.956999999999997}, "inductor/test_metrics": {"TestMetrics": 3.3350000000000004}, "inductor/test_minifier": {"MinifierTests": 27.051}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 87.97200000000001}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 81.974, "TestPatternMatcher": 372.2619999999998}, "inductor/test_mmdecomp": {"TestDecompCUDA": 6.119000000000002}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 13.804999999999998}, "inductor/test_multi_kernel": {"MultiKernelTest": 66.75099999999999}, "inductor/test_pad_mm": {"PadMMTest": 119.25}, "inductor/test_padding": {"PaddingTest": 9.552000000000001, "PerfTestBetweenGoodAndBadShape": 0.001, "PerfTestWithAndWithoutPadding": 3.888}, "inductor/test_pattern_matcher": {"TestPaternMatcher": 53.621, "TestPatternMatcher": 92.932}, "inductor/test_perf": {"FusionTests": 12.896, "InplacingTests": 5.168, "MinCutPartitioningTests": 10.056, "NoopTests": 0.8400000000000001, "NumBytesMetricTests": 19.544000000000004, "SchedulerFusionTests": 8.056000000000001, "TilingTests": 1.8619999999999999}, "inductor/test_profiler": {"DynamoProfilerTests": 5.6739999999999995}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 105.534}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 2.7449999999999997, "MemoryBoundedTests": 1.4929999999999999, "TestCommAnalysis": 4.0249999999999995, "UnsupportedTests": 0.433}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 93.015}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 17.349}, "inductor/test_storage_offset": {"StorageOffsetTests": 0.999}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 53.747}, "inductor/test_torchbind": {"TestTorchbind": 5.978}, "inductor/test_torchinductor": {"CpuTests": 1327.753, "CudaTests": 332.78500000000014, "GPUTests": 900.1019999999997, "NanCheckerTest": 0.717, "RNNTest": 0.025, "SweepInputsCpuTest": 109.923, "SweepInputsCudaTest": 11.506000000000004, "SweepInputsGPUTest": 22.541, "TestFull": 9.595, "TritonCodeGenTests": 22.493000000000002}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1408.8299999999995, "DynamicShapesCodegenCudaTests": 345.3650000000001, "DynamicShapesCodegenGPUTests": 891.0490000000001}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1503.099, "DynamicShapesCudaTests": 536.169, "DynamicShapesGPUTests": 1344.7039999999995, "TestInductorDynamicCUDA": 57.873999999999995}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1537.9019999999962}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.514}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 3.934}, "inductor/test_triton_kernels": {"KernelTests": 83.53499999999998, "MutationTests": 0.5470000000000002, "NoOptimizationKernelTests": 9.58199999999999, "no_opt_test_class": 11.028999999999996}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 8.09}, "inductor/test_unbacked_symints": {"TestUnbackedSymints": 5.714, "TestUnbackedSymintsCUDA": 16.360000000000003}, "inductor/test_utils": {"TestUtils": 0.222}, "lazy/test_debug_util": {"DebugUtilTest": 0.27}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.27}, "lazy/test_generator": {"LazyGeneratorTest": 0.273}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.42200000000000004}, "lazy/test_step_closures": {"ClosuresTest": 2.2129999999999996}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.17200000000000001, "TestLazyTensor": 0.05}, "nn/test_convolution": {"TestConvolutionNN": 20.985999999999997, "TestConvolutionNNDeviceTypeCUDA": 1638.767999999999}, "nn/test_dropout": {"TestDropoutNN": 0.103, "TestDropoutNNDeviceTypeCUDA": 0.444}, "nn/test_embedding": {"TestEmbeddingNN": 0.09500000000000001, "TestEmbeddingNNDeviceTypeCUDA": 9.970000000000008}, "nn/test_init": {"TestNNInit": 3.504999999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.42800000000000005}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.5090000000000001, "TestLoadStateDictSwap": 0.043}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.016, "TestModuleHookNN": 0.054000000000000006, "TestModuleHooks": 0.06600000000000002, "TestStateDictHooks": 0.036000000000000004}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 3.7919999999999994, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.32600000000000007}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.498}, "nn/test_parametrization": {"TestNNParametrization": 0.6310000000000001, "TestNNParametrizationDeviceCUDA": 0.293}, "nn/test_pooling": {"TestAvgPool": 0.22999999999999998, "TestPoolingNN": 0.654, "TestPoolingNNDeviceTypeCUDA": 4.548999999999998}, "nn/test_pruning": {"TestPruningNN": 0.07400000000000004}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.3310000000000004}, "profiler/test_memory_profiler": {"TestDataFlow": 1.0479999999999998, "TestIdentifyGradients": 0.22500000000000003, "TestMemoryProfiler": 0.373, "TestMemoryProfilerE2E": 2.3990000000000005}, "profiler/test_profiler": {"TestExecutionTrace": 1.569, "TestExperimentalUtils": 3.254999999999999, "TestProfiler": 17.794999999999998, "TestProfilerCUDA": 4.966, "TestProfilerITT": 0.002, "TestRecordFunction": 0.04, "TestTorchTidyProfiler": 4.889999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.43100000000000005}, "profiler/test_record_function": {"TestRecordFunction": 0.278}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.6949999999999985}, "test_ao_sparsity": {"TestActivationSparsifier": 0.05, "TestBaseDataScheduler": 0.023, "TestBaseDataSparsifier": 0.052000000000000005, "TestBaseSparsifier": 0.022, "TestBaseStructuredSparsifier": 2.55, "TestComposability": 1.578, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.054, "TestFakeSparsity": 0.05500000000000001, "TestFxComposability": 1.343, "TestNearlyDiagonalSparsifier": 0.642, "TestNormDataSparsifiers": 0.5980000000000001, "TestQuantizationUtils": 0.013000000000000001, "TestQuantizedSparseKernels": 0.229, "TestQuantizedSparseLayers": 0.266, "TestSaliencyPruner": 0.019, "TestScheduler": 0.011000000000000001, "TestSparsityUtilFunctions": 0.026999999999999996, "TestWeightNormSparsifier": 0.24100000000000002}, "test_autocast": {"TestAutocastCPU": 1.5109999999999997, "TestAutocastGPU": 0.228, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.021000000000000005, "TestAutograd": 14.972999999999972, "TestAutogradComplex": 0.003, "TestAutogradDeviceTypeCUDA": 2.9019999999999992, "TestAutogradForwardMode": 0.04900000000000002, "TestAutogradForwardModeBatchedGrad": 0.024, "TestAutogradFunctional": 32.29900000000002, "TestAutogradInferenceMode": 0.023000000000000007, "TestAutogradLogging": 0.011, "TestAutogradMultipleDispatchCUDA": 0.02, "TestMultithreadAutograd": 0.17600000000000005, "TestNestedCheckpoint": 0.32600000000000007}, "test_autograd_fallback": {"TestAutogradFallback": 0.32000000000000006}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 156.17199999999815}, "test_bundled_inputs": {"TestBundledInputs": 0.8880000000000001}, "test_comparison_utils": {"TestComparisonUtils": 0.215}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.08600000000000002}, "test_content_store": {"TestContentStoreCUDA": 2.689}, "test_cpp_api_parity": {"TestCppApiParity": 8.078999999999997}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.269, "TestMAIATensor": 0.006, "TestORTTensor": 0.011000000000000001, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.043}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.24300000000000002, "TestMAIATensor": 0.006, "TestORTTensor": 0.011000000000000001, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.001}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.171000000000001}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0}, "test_cuda": {"TestBlockStateAbsorption": 5.051, "TestCuda": 66.02500000000003, "TestCudaMallocAsync": 8.048, "TestCudaOptimsCUDA": 3.892000000000001}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.019, "TestCuda": 73.84999999999995, "TestCudaMallocAsync": 11.907, "TestCudaOptimsCUDA": 3.7980000000000005}, "test_cuda_multigpu": {"TestCudaComm": 0.017000000000000008, "TestCudaMultiGPU": 0.486}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.264, "TestVisibleDeviceParses": 0.018000000000000002}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.003}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.40700000000000003, "TestEventHandler": 0.02000000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 1.7520000000000002}, "test_custom_backend": {"TestCustomBackend": 0.074}, "test_custom_ops": {"MiniOpTest": 0.4530000000000001, "MiniOpTestOther": 0.04600000000000001, "TestCustomOp": 2.070999999999995, "TestCustomOpAPI": 0.09100000000000004, "TestCustomOpTestingCUDA": 1.356, "TestCustomOperators": 0.28900000000000003, "TestGenerateOpcheckTests": 2.691}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.001, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.033, "TestCustomPinFn": 0.097, "TestDataLoader": 79.42299999999999, "TestDataLoaderDeviceTypeCUDA": 12.52, "TestDataLoaderPersistentWorkers": 81.52499999999999, "TestDatasetRandomSplit": 0.022, "TestDictDataLoader": 0.033, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.003, "TestSetAffinity": 0.037, "TestStackDataset": 0.021000000000000005, "TestStringDataLoader": 0.047, "TestTensorDataset": 0.016}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006, "TestDataChunk": 0.006, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 3.0729999999999986, "TestFunctionalMapDataPipe": 0.028999999999999998, "TestGraph": 0.012000000000000002, "TestIterDataPipeCountSampleYielded": 0.006, "TestIterDataPipeGraphFastForward": 0.035, "TestIterDataPipeSingletonConstraint": 0.018000000000000002, "TestIterableDataPipeBasic": 0.022, "TestSerialization": 4.867, "TestSharding": 0.15700000000000003, "TestStreamWrapper": 0.221, "TestTyping": 0.002}, "test_deploy": {"TestFreezer": 0.222}, "test_dispatch": {"TestDispatch": 33.548000000000016, "TestPythonDispatcher": 0.028999999999999998}, "test_dlpack": {"TestTorchDlPackCUDA": 0.2880000000000002}, "test_dynamic_shapes": {"TestDimConstraints": 1.612, "TestFloorDiv": 0.009000000000000001, "TestPySymInt": 1.133, "TestSymNumberMagicMethods": 1.4539999999999946}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 6.9270000000000005, "TestExpandedWeightHelperFunctionCUDA": 0.08600000000000002, "TestExpandedWeightModuleCUDA": 8.412}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04500000000000001, "FakeTensorConverterTest": 0.018000000000000002, "FakeTensorDispatchCache": 0.064, "FakeTensorOpInfoTestCUDA": 0.547, "FakeTensorOperatorInvariants": 0.326, "FakeTensorPropTest": 0.056999999999999995, "FakeTensorSerialization": 0.004, "FakeTensorTest": 5.530999999999999, "PropagateRealTensorsFakeTensorConstHandling": 0.07, "PropagateRealTensorsFakeTensorConverterTest": 0.017, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.155, "PropagateRealTensorsFakeTensorPropTest": 0.04, "PropagateRealTensorsFakeTensorTest": 9.969000000000014}, "test_flop_counter": {"TestFlopCounter": 1.7510000000000001}, "test_foreach": {"TestForeachCUDA": 614.6230000000028}, "test_function_schema": {"TestFunctionSchema": 0.478}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 15.065}, "test_functional_optim": {"TestFunctionalOptimParity": 0.28600000000000003}, "test_functionalization": {"TestCrossRefFunctionalization": 1.6049999999999998, "TestFunctionalization": 1.7869999999999993}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.056}, "test_futures": {"TestFuture": 0.853}, "test_fx_experimental": {"TestFXExperimental": 10.711000000000002, "TestNormalizeOperatorsCUDA": 1.3569999999999987, "TestTranslationValidation": 0.103}, "test_fx_passes": {"TestFXGraphPasses": 0.30700000000000016, "TestFXMatcherUtils": 0.06800000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.3550000000000001}, "test_import_stats": {"TestImportTime": 3.161}, "test_indexing": {"NumpyTestsCUDA": 0.04000000000000002, "TestIndexingCUDA": 1.077}, "test_itt": {"TestItt": 0.219}, "test_jit_autocast": {"TestAutocast": 1.1969999999999998, "TestJitTraceAutocast": 18.057}, "test_jit_disabled": {"TestJitDisabled": 0.30800000000000005}, "test_jit_fuser_te": {"TestFuserCommon": 0.115, "TestNNCOpInfoCUDA": 13.608999999999163, "TestTEFuserDynamic": 301.74100000000016, "TestTEFuserStatic": 265.64}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.059, "TestFusionPatternCUDA": 0.001, "TestModel": 0.001, "TestOpCUDA": 0.001}, "test_jiterator": {"TestPythonJiteratorCUDA": 18.86900000000002}, "test_legacy_vmap": {"TestVmapAPI": 1.0809999999999977, "TestVmapAPILegacy": 0.731, "TestVmapBatchedGradientCUDA": 0.8460000000000002, "TestVmapBatchedGradientLegacyCUDA": 0.3570000000000001, "TestVmapOperators": 0.8470000000000001, "TestVmapOperatorsLegacy": 0.6630000000000001}, "test_license": {"TestLicense": 0.22}, "test_linalg": {"TestLinalgCUDA": 264.09100000000035}, "test_logging": {"LoggingTest": 2.227}, "test_masked": {"TestMaskedCUDA": 26.584000000000014}, "test_maskedtensor": {"TestBasicsCUDA": 1.1350000000000002, "TestBinary": 0.2510000000000001, "TestOperatorsCUDA": 68.3990000000002, "TestReductions": 0.053000000000000005, "TestUnary": 0.18100000000000013}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.003, "TestMatmulCudaCUDA": 69.645, "TestMixedDtypesLinearCudaCUDA": 0.69}, "test_mkl_verbose": {"TestMKLVerbose": 3.174}, "test_mkldnn_fusion": {"TestMkldnnFusion": 28.149}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.105}, "test_mobile_optimizer": {"TestOptimizer": 2.6069999999999998}, "test_model_dump": {"TestModelDump": 0.8009999999999999}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.212}, "test_module_init": {"TestModuleInitCUDA": 2.445499999999985}, "test_module_tracker": {"TestModuleTracker": 0.223}, "test_modules": {"TestModuleCUDA": 2151.5149999999953}, "test_monitor": {"TestMonitor": 0.225, "TestMonitorTensorboard": 0.102}, "test_multiprocessing": {"TestMultiprocessing": 92.315}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.555, "SpawnTest": 23.683}, "test_namedtensor": {"TestNamedTensor": 0.6890000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.547}, "test_native_functions": {"TestNativeFunctions": 0.31600000000000006}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.5440000000000003}, "test_nestedtensor": {"TestNestedTensor": 0.10100000000000005, "TestNestedTensorAutogradCUDA": 1.5560000000000003, "TestNestedTensorDeviceTypeCUDA": 1.0269999999999997, "TestNestedTensorSubclassCUDA": 23.08100000000001}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.252, "TestFusionUtils": 0.004, "TestNN": 166.04900000000035, "TestNNDeviceTypeCUDA": 414.1890000000013, "TestUtils": 0.003}, "test_numba_integration": {"TestNumbaIntegration": 0.252}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.13500000000000006}, "test_openmp": {"TestOpenMP_ParallelFor": 3.496}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 6618.8079999999745}, "test_ops_gradients": {"TestBwdGradientsCUDA": 6792.8069999999325}, "test_optim": {"TestDifferentiableOptimizer": 0.519, "TestLRScheduler": 0.7840000000000004, "TestOptim": 56.448, "TestOptimRenewedCUDA": 173.53399999999957, "TestSWAUtils": 0.663}, "test_out_dtype_op": {"TestOutDtypeOp": 0.457}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.016, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.006, "TestResolveName": 0.094, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 1.6939999999999267, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.028999999999999998, "ModelTest": 0.0, "TestAnalyze": 0.216, "TestDependencyAPI": 0.039000000000000014, "TestDependencyHooks": 0.006, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.016000000000000007, "TestImporter": 0.009000000000000001, "TestLoadBCPackages": 0.046, "TestMangling": 0.012, "TestMisc": 0.027000000000000007, "TestPackageFX": 0.048999999999999995, "TestPackageScript": 1.4039999999999995, "TestRepackage": 0.005, "TestResources": 0.009000000000000001, "TestSaveLoad": 0.026000000000000002}, "test_per_overload_api": {"TestPerOverloadAPI": 0.222}, "test_prims": {"TestDecompCUDA": 0.10500000000000001, "TestPrimsBasic": 0.01, "TestPrimsCUDA": 0.20700000000000002, "TestRefsCUDA": 0.011000000000000001}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.08200000000000002, "TestGenericProxyTensorFake": 1.4660000000000002, "TestGenericProxyTensorReal": 1.6809999999999998, "TestGenericProxyTensorSymbolic": 13.417, "TestRealProxyTensor": 0.014, "TestSymbolicTracing": 2.898999999999999}, "test_pruning_op": {"PruningOpTest": 0.37}, "test_public_bindings": {"TestPublicBindings": 4.642}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.024, "TestPythonDispatch": 0.20100000000000007, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 1.2489999999999999, "TestWrapperSubclassAliasingCUDA": 1.1969999999999998}, "test_pytree": {"TestCxxPytree": 0.012000000000000004, "TestGenericPytree": 0.31300000000000006, "TestPythonPytree": 0.04800000000000003}, "test_reductions": {"TestReductionsCUDA": 115.89999999999962}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 11.188}, "test_schema_check": {"TestSchemaCheck": 0.11200000000000004, "TestSchemaCheckModeOpInfoCUDA": 830.6089999999953}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 2.7949999999999995}, "test_serialization": {"TestBothSerializationCUDA": 0.075, "TestOldSerialization": 15.143000000000002, "TestSerialization": 6.362999999999993, "TestSubclassSerialization": 0.022000000000000006}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.221}, "test_shape_ops": {"TestShapeOpsCUDA": 1.070999999999999}, "test_show_pickle": {"TestShowPickle": 0.222}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.628999999999996}, "test_sparse": {"TestSparseAnyCUDA": 560.5460000000004, "TestSparseCUDA": 108.19500000000002, "TestSparseLegacyAndDeprecation": 0.04, "TestSparseMaskedReductionsCUDA": 16.936999999999998, "TestSparseMeta": 2.7969999999999993, "TestSparseOneOff": 0.056999999999999995, "TestSparseUnaryUfuncsCUDA": 157.50800000000052}, "test_sparse_csr": {"TestSparseCSRCUDA": 231.85900000000123, "TestSparseCSRSampler": 0.433, "TestSparseCompressedCUDA": 316.6410000000012, "TestSparseCompressedTritonKernelsCUDA": 679.873}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 9.195, "TestCUSPARSELTCUDA": 3.6749999999999994, "TestSparseSemiStructuredCUDA": 2.402999999999992, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.1830000000000001, "TestSparseSemiStructuredCUTLASSCUDA": 12.718, "TestSparseSemiStructuredTrainingCUDA": 3.1709999999999985}, "test_spectral_ops": {"TestFFTCUDA": 20.510999999999992}, "test_stateless": {"TestPythonOptimizeMode": 2.908, "TestStatelessDeprecation": 1.434, "TestStatelessFunctionalAPI": 0.17600000000000005}, "test_subclass": {"TestSubclass": 0.3560000000000001}, "test_sympy_utils": {"TestNumbers": 0.034, "TestSingletonInt": 0.005, "TestSympyInterp": 6.933, "TestSympySolve": 0.14400000000000004, "TestValueRanges": 5.105999999999998}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.46200000000000035, "TestLikeTensorCreationCUDA": 0.011000000000000001, "TestRandomTensorCreationCUDA": 0.13700000000000004, "TestTensorCreationCUDA": 78.54599999999961}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.015, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.29700000000000004, "TestTensorBoardPytorchGraph": 19.554, "TestTensorBoardSummary": 0.024000000000000007, "TestTensorBoardSummaryWriter": 0.006, "TestTensorBoardUtils": 0.10400000000000001, "TestTensorBoardWriter": 0.059, "TestTensorProtoSummary": 0.008}, "test_tensorexpr": {"TestTensorExprFuser": 112.88800000000003}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.007, "TestTensorExprPyBind": 0.5490000000000002}, "test_testing": {"TestAssertClose": 0.07200000000000004, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.04100000000000001, "TestAssertCloseMultiDeviceCUDA": 0.007, "TestAssertCloseQuantized": 0.007, "TestAssertCloseSparseBSC": 0.012, "TestAssertCloseSparseBSR": 0.011, "TestAssertCloseSparseCOO": 0.014000000000000002, "TestAssertCloseSparseCSC": 0.011, "TestAssertCloseSparseCSR": 0.011, "TestFrameworkUtils": 10.472, "TestImports": 9.838000000000001, "TestMakeTensorCUDA": 1.2240000000000009, "TestOpInfoSampleFunctionsCUDA": 3.4220000000000166, "TestOpInfos": 0.002, "TestTestParametrization": 0.02100000000000001, "TestTestParametrizationDeviceTypeCUDA": 3.1339999999999977, "TestTestingCUDA": 0.32800000000000007}, "test_torch": {"TestBasicVitalSigns": 0.024, "TestDevicePrecisionCUDA": 0.06900000000000002, "TestTorch": 4.82499999999999, "TestTorchDeviceTypeCUDA": 81.81799999999996, "TestVitalSignsCudaCUDA": 0.002}, "test_transformers": {"TestAttnBiasCUDA": 3.329, "TestAttnMasksCUDA": 0.042, "TestSDPACUDA": 6.062000000000001, "TestSDPACudaOnlyCUDA": 2532.3239999995103, "TestSDPAFailureModesCUDA": 0.258, "TestTransformersCUDA": 15.870999999999999}, "test_type_hints": {"TestTypeHints": 0.215}, "test_type_info": {"TestDTypeInfo": 0.227}, "test_type_promotion": {"TestTypePromotionCUDA": 7.240999999999964}, "test_typing": {"TestTyping": 56.766999999999975}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 411.3049999998}, "test_utils": {"TestAssert": 0.052, "TestBottleneck": 8.799999999999999, "TestCheckpoint": 0.15100000000000002, "TestCollectEnv": 0.962, "TestCppExtensionUtils": 0.022, "TestDataLoaderUtils": 0.244, "TestDeviceUtilsCUDA": 11.971000000000636, "TestExtensionUtils": 0.003, "TestHipify": 0.001, "TestHipifyTrie": 0.006, "TestONNXUtils": 0.003, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.2, "TestTraceback": 0.006}, "test_view_ops": {"TestOldViewOpsCUDA": 12.256000000000004, "TestViewOpsCUDA": 1.193999999999999}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.016, "WeakKeyDictionaryTestCase": 0.016, "WeakTest": 3.436999999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.002, "TestXNNPACKOps": 2.8049999999999997, "TestXNNPACKRewritePass": 0.9800000000000001, "TestXNNPACKSerDes": 3.3159999999999994}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.001}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.232, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.09300000000000001, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 11.257, "TestEinsumPath": 0.0, "TestMisc": 0.005}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.231, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.005, "TestBroadcastedAssignments": 0.014, "TestFancyIndexingCast": 0.003, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.32700000000000007, "TestMultiIndexingAutomated": 0.006, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.014000000000000002, "TestArgmax": 0.8710000000000007, "TestArgmaxArgminCommon": 0.04400000000000002, "TestArgmin": 0.9170000000000006, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.031000000000000007, "TestArrayCreationCopyArgument": 0.0, "TestArrayInterface": 0.020000000000000004, "TestAssignment": 0.007, "TestAttributes": 0.019000000000000003, "TestBinop": 0.014, "TestBool": 20.236000000000004, "TestCequenceMethods": 0.001, "TestChoose": 0.013000000000000001, "TestClip": 0.005, "TestCompress": 0.003, "TestConversion": 0.030000000000000002, "TestCreation": 0.0, "TestDelMisc": 0.001, "TestDot": 0.05700000000000002, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.024, "TestFlag": 0.009000000000000001, "TestFormat": 0.004, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.138, "TestHashing": 0.002, "TestIO": 0.001, "TestInner": 0.171, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.3400000000000001, "TestMatmulOperator": 0.23600000000000002, "TestMethods": 1.1200000000000003, "TestMinMax": 0.004, "TestMinScalarType": 0.004, "TestNewaxis": 0.003, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.009000000000000001, "TestRepeat": 0.01, "TestResize": 0.03900000000000001, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.017, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.12600000000000006, "TestStats": 0.188, "TestSubscripting": 0.001, "TestTake": 0.026000000000000006, "TestVdot": 0.03, "TestViewDtype": 0.006, "TestWarnings": 0.001, "TestWhere": 0.28600000000000003, "TestWritebackIfCopy": 0.022000000000000002}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.016, "TestArgwhere": 0.021, "TestArrayComparisons": 0.01, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.007, "TestBoolArray": 1.5939999999999999, "TestBoolCmp": 0.136, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.14500000000000007, "TestConvolve": 0.013000000000000001, "TestCorrelate": 0.020999999999999998, "TestCreationFuncs": 0.8710000000000001, "TestCross": 0.04, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.007, "TestFromiter": 0.0, "TestIndex": 0.004, "TestIndices": 0.031000000000000003, "TestIsclose": 0.063, "TestIsscalar": 0.002, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.006, "TestNonarrayArgs": 0.08800000000000004, "TestNonzeroAndCountNonzero": 0.19300000000000003, "TestOuterMisc": 0.004, "TestRequire": 0.004, "TestResize": 0.24100000000000002, "TestRoll": 0.025, "TestRollaxis": 0.003, "TestSeterr": 0.004, "TestStdVar": 0.023000000000000003, "TestStdVarComplex": 0.01, "TestStringFunction": 0.001, "TestTensordot": 0.011000000000000001, "TestTypes": 0.011000000000000001}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.219, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06100000000000005, "TestFromInt": 0.005, "TestFromString": 0.216}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.001, "TestClassGetitemMisc": 0.0, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.08000000000000002, "TestBaseMath": 7.14, "TestBitShifts": 0.071, "TestComplexDivision": 0.047, "TestConversion": 0.04100000000000001, "TestHash": 0.0, "TestModulus": 0.775, "TestMultiply": 0.0, "TestNegative": 0.016, "TestPower": 0.101, "TestRepr": 0.001, "TestScalarOpsMisc": 0.032000000000000015, "TestScalarSubclassingMisc": 0.006, "TestSubtract": 0.015, "TestTypes": 11.875}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.226, "TestAtleast2d": 0.013000000000000001, "TestAtleast3d": 0.012, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.11600000000000008, "TestHstack": 0.014000000000000002, "TestStackMisc": 0.002, "TestVstack": 0.015000000000000003}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.009, "TestFFTShift": 5.172999999999999, "TestIRFFTN": 0.004, "TestRFFTFreq": 0.008}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 1.9569999999999999, "TestFFTShift": 0.213, "TestFFTThreadSafe": 0.472}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.23}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.001, "TestUnique": 0.34}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.006, "TestAmax": 0.005, "TestAmin": 0.005, "TestAngle": 0.007, "TestAny": 0.006, "TestAverage": 0.019999999999999997, "TestBincount": 0.032, "TestCheckFinite": 0.002, "TestCopy": 0.006, "TestCorrCoef": 0.026, "TestCov": 0.04700000000000001, "TestCumprod": 0.026, "TestCumsum": 0.033, "TestDelete": 0.015, "TestDiff": 0.062, "TestDigitize": 0.011000000000000003, "TestExtins": 0.005, "TestFilterwindows": 0.45200000000000035, "TestFlip": 0.025, "TestGradient": 0.114, "TestInsert": 0.007, "TestInterp": 0.03400000000000002, "TestKaiser": 0.008, "TestMedian": 0.08200000000000002, "TestMeshgrid": 0.04300000000000001, "TestMsort": 0.0, "TestPercentile": 0.04900000000000003, "TestPiecewise": 0.008, "TestProd": 0.025, "TestPtp": 0.008, "TestQuantile": 0.013000000000000001, "TestRot90": 0.261, "TestSelect": 0.006, "TestSinc": 0.007, "TestSortComplex": 0.007, "TestTrapz": 0.004, "TestTrimZeros": 0.008, "TestUnique": 0.003, "Test_I0": 0.011}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.31200000000000006, "TestHistogramOptimBinNums": 0.02100000000000001, "TestHistogramdd": 0.104}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.004, "TestDiagIndicesFrom": 0.006, "TestFillDiagonal": 0.020999999999999998, "TestGrid": 0.007, "TestIndexExpression": 0.008, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.231}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.009000000000000001, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.135, "TestColumnStack": 0.008, "TestDsplit": 0.008, "TestDstack": 0.014000000000000002, "TestExpandDims": 0.005, "TestHsplit": 0.010000000000000002, "TestKron": 0.011, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.008, "TestSplit": 0.005, "TestSqueeze": 0.027000000000000003, "TestTakeAlongAxis": 0.246, "TestTile": 0.067, "TestVsplit": 0.007}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.025, "TestEye": 0.24900000000000003, "TestFliplr": 0.004, "TestFlipud": 0.004, "TestHistogram2d": 0.033, "TestTri": 0.07100000000000001, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.002, "TestTriuIndicesFrom": 0.001, "TestVander": 0.014}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.221, "TestImag": 0.01, "TestIscomplex": 0.004, "TestIscomplexobj": 0.003, "TestIsfinite": 0.011000000000000001, "TestIsinf": 0.008, "TestIsnan": 0.011000000000000001, "TestIsneginf": 0.002, "TestIsposinf": 0.002, "TestIsreal": 0.007, "TestIsrealobj": 0.001, "TestIsscalar": 0.002, "TestMintypecode": 0.003, "TestNanToNum": 0.01, "TestReal": 0.011, "TestRealIfClose": 0.003}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.119, "TestCond": 0.17100000000000004, "TestDet": 0.119, "TestEig": 0.029000000000000005, "TestEigh": 0.020000000000000004, "TestEighCases": 0.0, "TestEigvals": 0.043000000000000003, "TestEigvalsh": 0.017, "TestEigvalshCases": 0.0, "TestInv": 0.037000000000000005, "TestLstsq": 0.16699999999999998, "TestMatrixRank": 0.29300000000000004, "TestMisc": 0.019, "TestMisc2": 0.002, "TestMultiDot": 0.04100000000000001, "TestNormDouble": 0.647, "TestNormInt64": 0.643, "TestNormSingle": 0.66, "TestNorm_NonSystematic": 0.003, "TestPinv": 0.083, "TestPinvHermitian": 0.025, "TestQR": 0.34, "TestSVD": 0.032, "TestSVDHermitian": 0.07300000000000001, "TestSolve": 0.253, "TestTensorinv": 0.013000000000000001, "TestTensorsolve": 0.004}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.006, "TestCtorNested": 0.003, "TestDefaultDtype": 0.005, "TestDivmod": 0.012000000000000002, "TestExport": 0.0, "TestMisc": 0.296, "TestNormalizations": 0.004, "TestOneArr": 0.2410000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1340000000000001, "TestOneArrAndShape": 0.002, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.017, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.31600000000000006}, "torch_np/test_dtype": {"TestConvertDType": 0.261}, "torch_np/test_function_base": {"TestAppend": 0.221}, "torch_np/test_ndarray_methods": {"TestAmax": 0.006, "TestAmin": 0.006, "TestArgmax": 0.7870000000000006, "TestArgmaxArgminCommon": 0.041000000000000016, "TestArgmin": 0.8790000000000006, "TestContains": 0.001, "TestIndexing": 0.22, "TestIter": 0.004, "TestNoExtraMethods": 0.006, "TestNonzero": 0.114, "TestRavel": 0.006, "TestReshape": 0.004, "TestTranspose": 0.008}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.011, "TestNEP50Table": 0.001}, "torch_np/test_random": {"TestChoice": 0.009000000000000001, "TestNumpyGlobal": 0.003, "TestScalarReturn": 0.25, "TestShuffle": 0.010000000000000002}, "torch_np/test_reductions": {"TestAll": 0.009000000000000001, "TestAny": 0.01, "TestFlatnonzero": 0.215, "TestGenericCumSumProd": 0.017, "TestGenericReductions": 1.6569999999999607, "TestMean": 0.017, "TestSum": 0.16999999999999998}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.24500000000000002, "TestIsScalar": 0.02100000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3870000000000003, "TestNdarrayDunderVsUfunc": 0.15900000000000009, "TestUfuncDtypeKwd": 0.004, "TestUnaryUfuncs": 0.24200000000000002}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.30700000000000005}}}, "linux-focal-cuda12.1-py3.10-gcc9": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 2.382}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.0820000000000003}, "distributions/test_distributions": {"TestAgainstScipy": 1.7363333333333335, "TestConstraints": 0.23766666666666666, "TestDistributionShapes": 0.18300000000000013, "TestDistributions": 49.288333333333334, "TestFunctors": 0.014, "TestJit": 26.171333333333333, "TestKL": 3.420666666666667, "TestLazyLogitsInitialization": 0.02, "TestNumericalStability": 0.11166666666666669, "TestRsample": 0.924, "TestValidation": 0.5926666666666667}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.5613333333333334}, "dynamo/test_after_aot": {"TestAfterAot": 6.5569999999999995}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.82}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.021666666666667}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.26133333333333336, "AOTAutogradCacheTests": 19.147333333333336}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 3.5473333333333326}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.052333333333333336, "TestCustomBackendAPI": 2.372666666666667, "TestExplainWithBackend": 12.207333333333333, "TestOptimizations": 2.5823333333333327}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 15.176666666666668}, "dynamo/test_base_output": {"TestBaseOutput": 0.006000000000000001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.466}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 6.071333333333333, "BytecodeTests": 0.49700000000000005}, "dynamo/test_compile": {"InPlaceCompilationTests": 8.186666666666667, "PublicTorchCompilerTests": 0.0030000000000000005}, "dynamo/test_comptime": {"ComptimeTests": 0.6830000000000002}, "dynamo/test_config": {"ConfigTests": 0.6723333333333334}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.30100000000000005, "CppGuardManagerFuncTorchHigherOrderOpTests": 16.410000000000004, "CppGuardManagerFunctionTests": 33.50066666666672, "CppGuardManagerHigherOrderOpTests": 9.580333333333328, "CppGuardManagerMiscTests": 59.65633333333335, "CppGuardManagerReproTests": 52.88833333333337}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.509666666666666}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 4.2813333333333325}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.30433333333333334}, "dynamo/test_decorators": {"DecoratorTests": 7.258666666666666}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0030000000000000005, "TestDeviceGuard": 0.021}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 259.2756666666667, "DynamicShapesCtxManagerTests": 8.271333333333333, "DynamicShapesExportTests": 37.086333333333336, "DynamicShapesFuncTorchHigherOrderOpTests": 105.49600000000002, "DynamicShapesFunctionTests": 89.33433333333322, "DynamicShapesHigherOrderOpTests": 22.162999999999993, "DynamicShapesMiscTests": 114.65833333333337, "DynamicShapesNNModuleTests": 8.441, "DynamicShapesReproTests": 126.32433333333331, "DynamicShapesSubGraphTests": 14.687666666666667, "DynamicShapesTestSDPA": 0.48000000000000004}, "dynamo/test_exc": {"ExcTests": 2.5163333333333333}, "dynamo/test_exceptions": {"ExceptionTests": 0.6100000000000001}, "dynamo/test_export": {"ExportTests": 20.804666666666662}, "dynamo/test_export_mutations": {"MutationExportTests": 0.6750000000000002}, "dynamo/test_frame_init": {"FrameInitTests": 0.2793333333333334}, "dynamo/test_functions": {"DefaultsTests": 1.0593333333333332, "FunctionTests": 27.91566666666668}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.5756666666666668}, "dynamo/test_global": {"TestGlobals": 0.5986666666666668}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.33033333333333337}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.10200000000000002, "FuncTorchHigherOrderOpTests": 14.997666666666667, "HigherOrderOpTests": 10.186000000000002, "HigherOrderOpVmapGuardTests": 5.437333333333334}, "dynamo/test_hooks": {"HooksTests": 33.40100000000001}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 13.823, "InlineInbuiltNNModulesExportTests": 20.910999999999998, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 15.050000000000002, "InlineInbuiltNNModulesFunctionTests": 30.073000000000018, "InlineInbuiltNNModulesHigherOrderOpTests": 9.949333333333337, "InlineInbuiltNNModulesMiscTests": 76.7060000000002, "InlineInbuiltNNModulesNNModuleTests": 5.756666666666665}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 8.934666666666665}, "dynamo/test_interop": {"InteropTests": 0.6443333333333334}, "dynamo/test_logging": {"LoggingTests": 20.64366666666667}, "dynamo/test_minifier": {"MinifierTests": 3.1199999999999997}, "dynamo/test_misc": {"MiscTests": 71.38700000000013, "TestTracer": 0.07133333333333335}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.015000000000000006}, "dynamo/test_modules": {"NNModuleTests": 3.6559999999999984, "OptimizedModuleTest": 23.009666666666664}, "dynamo/test_nops": {"NopTests": 0.3746666666666667}, "dynamo/test_optimizers": {"End2EndTests": 0.7413333333333334, "OptimizerTests": 2.2886666666666664}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.5566666666666666}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.6116666666666666}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.7606666666666667}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.0786666666666669}, "dynamo/test_recompiles": {"RecompileTests": 1.0546666666666666}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.5996666666666668}, "dynamo/test_replay_record": {"ReplayRecordTests": 1.132}, "dynamo/test_repros": {"ReproTests": 65.62100000000005}, "dynamo/test_resume": {"ResumeFunctionTests": 0.502}, "dynamo/test_sdpa": {"TestSDPA": 0.5540000000000002}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.6816666666666666}, "dynamo/test_sources": {"SourceTests": 0.5666666666666668}, "dynamo/test_structured_trace": {"StructuredTraceTest": 15.680666666666667}, "dynamo/test_subclasses": {"SubclassTests": 6.151666666666666, "TestNestedTensor": 13.696666666666667}, "dynamo/test_subgraphs": {"SubGraphTests": 2.9866666666666664}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.122, "TraceRuleTests": 1.4266666666666665}, "dynamo/test_triton_kernels": {"KernelTests": 0.1263333333333334, "MutationTests": 0.012000000000000004, "NoOptimizationKernelTests": 0.12500000000000008, "no_opt_test_class": 0.12600000000000008}, "dynamo/test_unspec": {"UnspecTests": 15.862999999999998}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.7220000000000001}, "dynamo/test_view": {"ViewTests": 0.7583333333333333}, "export/test_converter": {"TestConverter": 9.783333333333333}, "export/test_db": {"ExampleTests": 4.041333333333333}, "export/test_experimental": {"TestExperiment": 1.1876666666666666}, "export/test_export": {"TestDynamismExpression": 0.6223333333333333, "TestExport": 33.004999999999995, "TestExportCustomClass": 0.09033333333333333, "TestOneOffModelExportResult": 1.4866666666666666}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.555, "NonStrictExportTestExport": 32.35066666666667}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.632, "PreDispatchExportTestExport": 34.712666666666664}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.30033333333333334}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.851}, "export/test_hop": {"TestHOPCUDA": 3.703333333333333, "TestHOPGeneric": 0.0033333333333333335}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0030000000000000005, "TestLift": 0.12666666666666668, "TestLiftUnlift": 0.015}, "export/test_pass_infra": {"TestPassInfra": 1.1256666666666668}, "export/test_passes": {"TestPasses": 17.683999999999997}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.2313333333333334, "RetraceExportTestExport": 55.531}, "export/test_safeguard": {"TestSafeguard": 1.2790000000000001}, "export/test_schema": {"TestSchema": 0.3256666666666666}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.31666666666666665, "SerDesExportPreDispatchTestExport": 26.870666666666676, "SerDesExportTestDynamismExpression": 0.7096666666666666, "SerDesExportTestExport": 36.303000000000004}, "export/test_serialize": {"TestDeserialize": 10.617000000000003, "TestOpVersioning": 0.005666666666666667, "TestSaveLoad": 0.42766666666666664, "TestSchemaVersioning": 0.041666666666666664, "TestSerialize": 1.388, "TestSerializeCustomClass": 0.115}, "export/test_sparse": {"TestSparseProp": 82.2583333333333}, "export/test_tools": {"TestExportTools": 0.645}, "export/test_torchbind": {"TestCompileTorchbind": 1.6696666666666669, "TestExportTorchbind": 2.579999999999999, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.28833333333333333}, "export/test_unflatten": {"TestUnflatten": 4.162}, "export/test_upgrade": {"TestUpgrade": 0.5283333333333333}, "export/test_verifier": {"TestVerifier": 1.1896666666666667}, "functorch/test_aotdispatch": {"TestAOTAutograd": 17.625333333333334, "TestAOTAutogradWithDynamo": 20.013333333333335, "TestAOTDispatch": 0.697, "TestAOTExport": 3.037666666666667, "TestAOTModuleSimplified": 0.836, "TestPartitioning": 4.469333333333332}, "functorch/test_control_flow": {"TestControlFlow": 1.0903333333333334, "TestControlFlowTraced": 148.4326666666667}, "functorch/test_dims": {"TestMin": 16.11266666666667, "TestMinFunctorchOnly": 15.208333333333334}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.1153333333333334, "TestAutogradFunctionVmapAPICUDA": 0.023000000000000003, "TestCompileTransformsCUDA": 4.675999999999999, "TestComposabilityCUDA": 0.19566666666666674, "TestExamplesCorrectnessCUDA": 4.812666666666668, "TestFunctionalizeCUDA": 0.14600000000000002, "TestGradTransformCUDA": 1.5329999999999993, "TestHelpersCUDA": 0.015, "TestHessianCUDA": 0.08733333333333333, "TestHigherOrderOperatorInteractionCUDA": 0.035, "TestJacCUDA": 0.9803333333333336, "TestJvpCUDA": 0.07666666666666667, "TestLinearizeCUDA": 0.318, "TestMakeFunctional": 0.08966666666666669, "TestSliceArgnums": 0.019000000000000003, "TestVmapJvpInplaceViewCUDA": 0.024000000000000004, "TestVmapOfGradCUDA": 0.5826666666666668}, "functorch/test_logging": {"TestAOTLogging": 0.3466666666666667}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.25100000000000006, "RandomOpTestCase": 0.11333333333333333, "ReduceTestCase": 0.10333333333333333, "TestMemoryEfficientOpAuthoring": 9.512666666666666}, "functorch/test_minifier": {"TestMinifier": 0.544}, "functorch/test_ops": {"TestOperatorsCUDA": 5886.814333333343}, "functorch/test_parsing": {"TestAnonymousAxis": 0.31266666666666665, "TestParsedExpression": 0.006000000000000001, "TestParsingUtils": 0.006666666666666667, "TestValidateRearrangeExpressions": 0.007}, "functorch/test_rearrange": {"TestRearrange": 0.38500000000000006}, "functorch/test_vmap": {"TestRandomnessCUDA": 1.2186666666666663, "TestTransformFailureCUDA": 0.33, "TestVmapAPI": 0.4420000000000001, "TestVmapBatchedGradientCUDA": 0.2990000000000001, "TestVmapDeviceTypeCUDA": 0.030666666666666665, "TestVmapNestedTensorCUDA": 0.05333333333333335, "TestVmapOperators": 4.051999999999993, "TestVmapOperatorsOpInfoCUDA": 426.25899999999837}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.8023333333331983}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.025333333333334}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 12.267666666666665}, "inductor/test_binary_folding": {"FreezingCpuTests": 51.99766666666667}, "inductor/test_codecache": {"TestFxGraphCache": 50.28099999999997, "TestFxGraphCacheHashing": 1.2896666666666665, "TestUtils": 4.947333333333334, "test_codecache": 0.0016666666666666668}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.30633333333333335}, "inductor/test_compile_worker": {"TestCompileWorker": 15.548333333333334}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 325.62200000000036, "TestAutogradWithCompiledAutograd": 430.94733333333414, "TestCompiledAutograd": 244.4616666666667, "TestCustomOpWithCompiledAutograd": 2.4946666666666624}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 0.09933333333333338, "CompiledOptimizerTests": 329.13566666666657}, "inductor/test_config": {"TestInductorConfig": 8.474999999999998}, "inductor/test_control_flow": {"CondTests": 0.03400000000000002, "WhileLoopTests": 0.01800000000000001}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1084.274333333333, "TestCppWrapper": 901.3516666666666}, "inductor/test_cpu_repro": {"CPUReproTests": 876.0816666666666}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0030000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 15.346666666666666}, "inductor/test_debug_trace": {"TestDebugTrace": 4.590000000000001}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.005666666666666667}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 51.41400000000001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 86.69233333333331}, "inductor/test_extension_backend": {"ExtensionBackendTests": 24.370666666666665}, "inductor/test_flex_attention": {"TestFlexAttention": 0.10200000000000008, "TestTemplatedSDPA": 0.07600000000000005}, "inductor/test_foreach": {"ForeachTests": 24.368000000000194}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 107.14133333333335, "SDPAPatternRewriterCpuTests": 103.69733333333333}, "inductor/test_fx_fusion": {"TestFxFusion": 0.279}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.01833333333333333}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.36066666666666664, "TestGroupBatchFusion": 0.0016666666666666668, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.058666666666666666, "TestIndexingSimplification": 0.6723333333333333}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 67.52433333333333}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.002}, "inductor/test_metrics": {"TestMetrics": 0.335}, "inductor/test_minifier": {"MinifierTests": 32.75633333333334}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 64.902}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 129.20633333333333, "TestPatternMatcher": 603.8066666666668}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.022333333333333344}, "inductor/test_profiler": {"DynamoProfilerTests": 0.005}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 24.548666666666666}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.048000000000000036}, "inductor/test_torchbind": {"TestTorchbind": 8.533333333333333}, "inductor/test_torchinductor": {"CpuTests": 2014.7426666666663, "SweepInputsCpuTest": 165.22833333333332, "TestFull": 13.963333333333333}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2132.755333333332}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2233.056333333332, "TestInductorDynamicCUDA": 0.08533333333333337}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 18.156666666666677}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 2.248666666666667}, "inductor/test_triton_kernels": {"KernelTests": 0.15433333333333343, "MutationTests": 0.017000000000000008, "NoOptimizationKernelTests": 0.1440000000000001, "no_opt_test_class": 0.1450000000000001}, "inductor/test_utils": {"TestUtils": 0.2793333333333334}, "lazy/test_debug_util": {"DebugUtilTest": 0.37266666666666665}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.3713333333333333}, "lazy/test_generator": {"LazyGeneratorTest": 0.379}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.6266666666666666}, "lazy/test_step_closures": {"ClosuresTest": 2.294333333333333}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.2773333333333334, "TestLazyTensor": 0.10533333333333333}, "nn/test_convolution": {"TestConvolutionNN": 25.804333333333332, "TestConvolutionNNDeviceTypeCUDA": 21.701666666666714}, "nn/test_dropout": {"TestDropoutNN": 0.15666666666666665, "TestDropoutNNDeviceTypeCUDA": 1.8716666666666668}, "nn/test_embedding": {"TestEmbeddingNN": 0.1626666666666667, "TestEmbeddingNNDeviceTypeCUDA": 18.050333333333317}, "nn/test_init": {"TestNNInit": 4.679333333333332}, "nn/test_lazy_modules": {"TestLazyModules": 0.41566666666666685}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.8109999999999999, "TestLoadStateDictSwap": 0.07933333333333333}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.028333333333333332, "TestModuleHookNN": 0.08533333333333333, "TestModuleHooks": 0.1136666666666667, "TestStateDictHooks": 0.03833333333333334}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.759999999999999, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.36599999999999994}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5543333333333335}, "nn/test_parametrization": {"TestNNParametrization": 1.1559999999999988, "TestNNParametrizationDeviceCUDA": 0.16933333333333334}, "nn/test_pooling": {"TestAvgPool": 0.43766666666666665, "TestPoolingNN": 0.878, "TestPoolingNNDeviceTypeCUDA": 10.686666666666662}, "nn/test_pruning": {"TestPruningNN": 0.12400000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.21000000000000005}, "profiler/test_memory_profiler": {"TestDataFlow": 1.5163333333333338, "TestIdentifyGradients": 0.36133333333333334, "TestMemoryProfiler": 0.37033333333333335, "TestMemoryProfilerE2E": 3.5229999999999997}, "profiler/test_profiler": {"TestExecutionTrace": 7.571666666666666, "TestExperimentalUtils": 3.8583333333333325, "TestProfiler": 19.682, "TestProfilerCUDA": 7.4689999999999985, "TestProfilerITT": 0.0023333333333333335, "TestRecordFunction": 0.057, "TestTorchTidyProfiler": 5.830333333333333}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.4753333333333334}, "profiler/test_record_function": {"TestRecordFunction": 0.36866666666666664}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.9456666666666655}, "test_ao_sparsity": {"TestActivationSparsifier": 0.07166666666666667, "TestBaseDataScheduler": 0.03766666666666666, "TestBaseDataSparsifier": 0.10066666666666668, "TestBaseSparsifier": 0.029666666666666664, "TestBaseStructuredSparsifier": 4.014333333333334, "TestComposability": 3.0633333333333326, "TestCubicScheduler": 0.006000000000000001, "TestFPGMPruner": 0.09733333333333334, "TestFakeSparsity": 0.08466666666666667, "TestFxComposability": 2.5716666666666668, "TestNearlyDiagonalSparsifier": 1.2323333333333333, "TestNormDataSparsifiers": 1.2226666666666668, "TestQuantizationUtils": 0.02366666666666667, "TestQuantizedSparseKernels": 0.242, "TestQuantizedSparseLayers": 0.37733333333333335, "TestSaliencyPruner": 0.03133333333333333, "TestScheduler": 0.015, "TestSparsityUtilFunctions": 0.04599999999999999, "TestWeightNormSparsifier": 0.4683333333333333}, "test_autocast": {"TestAutocastCPU": 1.9266666666666667, "TestAutocastGPU": 0.13266666666666668, "TestTorchAutocast": 0.006000000000000001}, "test_autograd": {"TestAllowMutationOnSaved": 0.035, "TestAutograd": 24.136999999999933, "TestAutogradComplex": 0.006000000000000001, "TestAutogradDeviceTypeCUDA": 1.5389999999999997, "TestAutogradForwardMode": 0.08433333333333337, "TestAutogradForwardModeBatchedGrad": 0.021333333333333333, "TestAutogradFunctional": 16.621666666666666, "TestAutogradInferenceMode": 0.039000000000000014, "TestAutogradLogging": 0.017333333333333336, "TestAutogradMultipleDispatchCUDA": 0.025333333333333336, "TestMultithreadAutograd": 0.32600000000000007, "TestNestedCheckpoint": 0.6593333333333334, "TestSelectiveActivationCheckpoint": 0.10066666666666668}, "test_autograd_fallback": {"TestAutogradFallback": 0.4726666666666668}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 162.36833333333448}, "test_bundled_inputs": {"TestBundledInputs": 1.338666666666666}, "test_comparison_utils": {"TestComparisonUtils": 0.2976666666666667}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCUDA": 0.14800000000000002}, "test_content_store": {"TestContentStoreCUDA": 0.14300000000000002}, "test_cpp_api_parity": {"TestCppApiParity": 12.283666666666614}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.238, "TestMAIATensor": 0.008666666666666668, "TestORTTensor": 0.014, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0036666666666666666, "TestTorchLibrary": 0.06833333333333334}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.229, "TestMAIATensor": 0.008333333333333333, "TestORTTensor": 0.014, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0036666666666666666, "TestTorchLibrary": 0.06766666666666667}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 140.85466666666665}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.005}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 9.731666666666671}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.001}, "test_cuda": {"TestBlockStateAbsorption": 6.765666666666667, "TestCuda": 86.90466666666669, "TestCudaMallocAsync": 26.23566666666667, "TestCudaOptimsCUDA": 3.8666666666666667}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 6.754333333333334, "TestCuda": 88.8046666666667, "TestCudaMallocAsync": 29.576000000000004, "TestCudaOptimsCUDA": 3.7089999999999996}, "test_cuda_multigpu": {"TestCudaComm": 0.032666666666666684, "TestCudaMultiGPU": 0.6633333333333333}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.3033333333333333, "TestVisibleDeviceParses": 0.024000000000000004}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0030000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.3743333333333334, "TestEventHandler": 0.025666666666666674, "TestMessages": 0.004}, "test_cuda_trace": {"TestCudaTrace": 1.252}, "test_custom_backend": {"TestCustomBackend": 0.12466666666666666}, "test_custom_ops": {"MiniOpTest": 0.7763333333333335, "MiniOpTestOther": 0.08300000000000002, "TestCustomOp": 3.0493333333333275, "TestCustomOpAPI": 0.18200000000000005, "TestCustomOpTestingCUDA": 2.238, "TestCustomOperators": 0.44133333333333336, "TestGenerateOpcheckTests": 4.141666666666667}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 41.876333333333335, "TestConcatDataset": 0.012000000000000002, "TestConvAfterFork": 0.033, "TestCustomPinFn": 0.12166666666666666, "TestDataLoader": 95.99466666666667, "TestDataLoaderDeviceTypeCUDA": 16.311, "TestDataLoaderPersistentWorkers": 127.44099999999999, "TestDatasetRandomSplit": 0.03266666666666667, "TestDictDataLoader": 0.03833333333333334, "TestIndividualWorkerQueue": 0.0016666666666666668, "TestNamedTupleDataLoader": 0.005, "TestSetAffinity": 0.04, "TestStackDataset": 0.03933333333333334, "TestStringDataLoader": 0.04900000000000001, "TestTensorDataset": 0.028}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.007666666666666666, "TestDataChunk": 0.009, "TestDataFramesPipes": 0.006666666666666667, "TestFunctionalIterDataPipe": 5.243999999999999, "TestFunctionalMapDataPipe": 0.041666666666666664, "TestGraph": 0.020666666666666667, "TestIterDataPipeCountSampleYielded": 0.011000000000000001, "TestIterDataPipeGraphFastForward": 0.051666666666666666, "TestIterDataPipeSingletonConstraint": 0.024333333333333335, "TestIterableDataPipeBasic": 0.031666666666666676, "TestSerialization": 7.456666666666667, "TestSharding": 0.16033333333333336, "TestStreamWrapper": 0.314, "TestTyping": 0.011000000000000001}, "test_decomp": {"DecompOneOffTestsCUDA": 0.035, "HasDecompTest": 0.21, "TestDecompCUDA": 13974.54766666668}, "test_deploy": {"TestFreezer": 0.29633333333333334}, "test_dispatch": {"TestDispatch": 41.47100000000001, "TestPythonDispatcher": 0.035333333333333335}, "test_dlpack": {"TestTorchDlPackCUDA": 0.3900000000000003}, "test_dynamic_shapes": {"TestDimConstraints": 2.4426666666666668, "TestFloorDiv": 0.015333333333333332, "TestGuardsExpressions": 0.03366666666666667, "TestPySymInt": 1.571999999999999, "TestSymNumberMagicMethods": 2.5029999999999912}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 4.795666666666665, "TestExpandedWeightHelperFunctionCUDA": 0.1486666666666667, "TestExpandedWeightModuleCUDA": 14.608333333333334}, "test_fake_tensor": {"FakeTensorConstHandling": 0.07366666666666667, "FakeTensorConverterTest": 0.028, "FakeTensorDispatchCache": 0.10400000000000002, "FakeTensorOpInfoTestCUDA": 0.13333333333333333, "FakeTensorOperatorInvariants": 0.5926666666666667, "FakeTensorPropTest": 0.09033333333333333, "FakeTensorSerialization": 0.006000000000000001, "FakeTensorTest": 10.092666666666672, "PropagateRealTensorsFakeTensorConstHandling": 0.1146666666666667, "PropagateRealTensorsFakeTensorConverterTest": 0.02666666666666667, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.21166666666666667, "PropagateRealTensorsFakeTensorPropTest": 0.06733333333333334, "PropagateRealTensorsFakeTensorTest": 19.383666666666677}, "test_flop_counter": {"TestFlopCounter": 0.506}, "test_foreach": {"TestForeachCUDA": 255.59233333334103}, "test_function_schema": {"TestFunctionSchema": 0.7233333333333333}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 21.57133333333333}, "test_functional_optim": {"TestFunctionalOptimParity": 0.43}, "test_functionalization": {"TestCrossRefFunctionalization": 2.4763333333333315, "TestFunctionalization": 3.002666666666665}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 3.3049999999999997}, "test_futures": {"TestFuture": 0.9336666666666668}, "test_fx": {"AnnotationsTest": 0.01766666666666667, "TestCSEPass": 0.3383333333333334, "TestCommonPass": 0.23666666666666678, "TestConstFold": 0.19066666666666668, "TestConstParamShapeInControlFlow": 0.05100000000000001, "TestDCE": 0.035333333333333335, "TestFX": 3.2549999999999932, "TestFXAPIBackwardCompatibility": 0.03133333333333333, "TestFunctionalTracing": 0.4233333333333336, "TestMatcher": 0.41700000000000004, "TestOperatorSignaturesCUDA": 1.3659999999999994, "TestPassManager": 0.029333333333333333, "TestSourceMatcher": 1.8500000000000003, "TestSubgraphRewriter": 0.3470000000000002, "TestVisionTracing": 307.122, "TypeCheckerTest": 2.1739999999999995}, "test_fx_experimental": {"TestFXExperimental": 17.287000000000006, "TestNormalizeOperatorsCUDA": 2.0019999999999647, "TestTranslationValidation": 0.14666666666666667}, "test_fx_passes": {"TestFXGraphPasses": 0.6846666666666669, "TestFXMatcherUtils": 0.10000000000000003}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5643333333333334}, "test_import_stats": {"TestImportTime": 4.597333333333333}, "test_indexing": {"NumpyTestsCUDA": 0.05466666666666669, "TestIndexingCUDA": 2.1606666666666654}, "test_itt": {"TestItt": 0.31033333333333335}, "test_jit": {"TestAliasAnalysis": 0.35000000000000003, "TestAsync": 0.3626666666666667, "TestAtenPow": 0.009333333333333332, "TestAutodiffJit": 0.06533333333333334, "TestAutodiffSubgraphSlicing": 0.30366666666666675, "TestAwait": 0.2206666666666667, "TestBackends": 0.7290000000000001, "TestBackendsWithCompiler": 0.147, "TestBatchMM": 0.08700000000000001, "TestBuiltins": 0.06, "TestCUDA": 0.8386666666666667, "TestClassType": 2.606666666666667, "TestComplex": 0.9263333333333335, "TestCustomOperators": 0.042000000000000016, "TestDCE": 0.021333333333333333, "TestDataParallel": 0.005, "TestDataclasses": 4.920333333333334, "TestDeviceAnalysis": 4.514666666666668, "TestDict": 0.4283333333333335, "TestDtypeAnalysis": 0.17433333333333337, "TestEnum": 0.19633333333333336, "TestFreezing": 2.2883333333333327, "TestFrontend": 0.4673333333333333, "TestFrozenOptimizations": 11.333333333333334, "TestFunctionalBlocks": 0.007666666666666666, "TestFunctionalToInplaceActivation": 2.332333333333333, "TestGenerator": 0.084, "TestGetDefaultAttr": 0.016666666666666666, "TestGraphRewritePasses": 0.041, "TestHash": 0.07633333333333332, "TestHooks": 0.6846666666666671, "TestIgnorableArgs": 0.010666666666666666, "TestIgnoreContextManager": 0.04800000000000001, "TestInplaceToFunctionalActivation": 2.492, "TestIsinstance": 0.20600000000000007, "TestJit": 6.068666666666662, "TestJitGeneratedModule": 12.167000000000025, "TestJitProfiler": 0.001, "TestJitUtils": 0.017333333333333336, "TestList": 1.3070000000000004, "TestLogging": 0.05000000000000001, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.17033333333333336, "TestMixTracingScripting": 1.1290000000000002, "TestModels": 5.944666666666666, "TestModuleAPIs": 0.12833333333333333, "TestModuleContainers": 1.247, "TestModuleInterface": 0.7100000000000001, "TestModules": 0.014333333333333332, "TestNamedTuple": 0.06866666666666667, "TestNnapiBackend": 7.487333333333335, "TestOpDecompositions": 0.016333333333333335, "TestOptimizeForMobilePreserveDebugInfo": 0.16633333333333336, "TestParametrization": 0.09933333333333333, "TestPeephole": 0.4453333333333335, "TestProducerVersion": 0.0016666666666666668, "TestProfiler": 0.5526666666666666, "TestPythonBindings": 0.02900000000000001, "TestPythonBuiltinOP": 0.38100000000000006, "TestPythonIr": 0.022000000000000002, "TestRecursiveScript": 0.7403333333333336, "TestRemoveMutation": 0.12700000000000003, "TestSaveLoad": 42.36866666666667, "TestSaveLoadFlatbuffer": 0.3586666666666667, "TestSaveLoadForOpVersion": 2.311, "TestScript": 45.55800000000002, "TestScriptDict": 0.026333333333333334, "TestScriptList": 0.8146666666666668, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.16000000000000003, "TestScriptProfile": 0.4323333333333333, "TestSlice": 0.15000000000000008, "TestSparse": 0.048999999999999995, "TestStringFormatting": 0.11300000000000004, "TestSymbolicShapeAnalysis": 1.2309999999999997, "TestTensorBuiltins": 0.10333333333333335, "TestTensorCreationOps": 0.044333333333333336, "TestTensorMethods": 0.012333333333333333, "TestTorchbind": 0.15666666666666673, "TestTracer": 5.098333333333328, "TestTypeSharing": 0.5103333333333334, "TestTypesAndAnnotation": 0.121, "TestTyping": 0.37066666666666687, "TestUnion": 0.4426666666666668, "TestUnsupportedOps": 0.028333333333333335, "TestUpgraders": 0.06400000000000002, "TestWarn": 0.04900000000000001, "TestWith": 0.36000000000000004}, "test_jit_autocast": {"TestAutocast": 1.445999999999999, "TestJitTraceAutocast": 33.961000000000006}, "test_jit_disabled": {"TestJitDisabled": 0.46166666666666667}, "test_jit_fuser_te": {"TestFuserCommon": 0.158, "TestNNCOpInfoCUDA": 19.624666666667192, "TestTEFuserDynamic": 511.2176666666669, "TestTEFuserStatic": 431.1166666666668}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.07633333333333332, "TestFusionPatternCUDA": 0.004666666666666667, "TestModel": 0.005, "TestOpCUDA": 0.005}, "test_jiterator": {"TestPythonJiteratorCUDA": 25.751666666666605}, "test_legacy_vmap": {"TestVmapAPI": 1.4266666666666659, "TestVmapAPILegacy": 1.1893333333333327, "TestVmapBatchedGradientCUDA": 1.1023333333333325, "TestVmapBatchedGradientLegacyCUDA": 0.6036666666666669, "TestVmapOperators": 1.3246666666666667, "TestVmapOperatorsLegacy": 1.2136666666666667}, "test_license": {"TestLicense": 0.2913333333333333}, "test_linalg": {"TestLinalgCUDA": 1031.1063333333313}, "test_logging": {"LoggingTest": 3.33}, "test_masked": {"TestMaskedCUDA": 40.12600000000001}, "test_maskedtensor": {"TestBasicsCUDA": 0.24633333333333338, "TestBinary": 0.3983333333333336, "TestOperatorsCUDA": 7.976999999999954, "TestReductions": 0.08366666666666668, "TestUnary": 0.29033333333333355}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.022333333333333344, "TestMatmulCudaCUDA": 47.629333333333335, "TestMixedDtypesLinearCudaCUDA": 0.0013333333333333333}, "test_meta": {"TestMetaCUDA": 2916.827999999877, "TestMetaConverter": 0.161}, "test_mkl_verbose": {"TestMKLVerbose": 4.9606666666666674}, "test_mkldnn_fusion": {"TestMkldnnFusion": 42.54}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.558333333333334}, "test_mobile_optimizer": {"TestOptimizer": 3.3656666666666664}, "test_model_dump": {"TestModelDump": 1.3096666666666668}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.18666666666666668}, "test_module_init": {"TestModuleInitCUDA": 2.0239999999999982}, "test_module_tracker": {"TestModuleTracker": 0.3053333333333334}, "test_modules": {"TestModuleCUDA": 956.6853333333241}, "test_monitor": {"TestMonitor": 0.29833333333333334, "TestMonitorTensorboard": 0.15266666666666664}, "test_multiprocessing": {"TestMultiprocessing": 116.94333333333333}, "test_multiprocessing_spawn": {"ErrorTest": 0.0030000000000000005, "ForkTest": 0.6513333333333333, "SpawnTest": 36.25366666666667}, "test_namedtensor": {"TestNamedTensor": 1.0606666666666669}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.225}, "test_native_functions": {"TestNativeFunctions": 0.4280000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.8810000000000006}, "test_nestedtensor": {"TestNestedTensor": 0.17800000000000007, "TestNestedTensorAutogradCUDA": 1.3973333333333329, "TestNestedTensorDeviceTypeCUDA": 1.6453333333333304, "TestNestedTensorSubclassCUDA": 1.7273333333333314}, "test_nn": {"TestAddRelu": 0.004, "TestConstantPadNd": 0.004, "TestFunctionalPickle": 0.0016666666666666668, "TestFusionEval": 0.40266666666666673, "TestFusionUtils": 0.006000000000000001, "TestNN": 68.88866666666681, "TestNNDeviceTypeCUDA": 138.51699999999752, "TestUtils": 0.004}, "test_numba_integration": {"TestNumbaIntegration": 0.19366666666666668}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.33200000000000013}, "test_openmp": {"TestOpenMP_ParallelFor": 4.748666666666666}, "test_ops": {"TestCommonCUDA": 3966.7206666666393, "TestCompositeComplianceCUDA": 1301.06133333333, "TestFakeTensorCUDA": 1144.1299999999994, "TestMathBitsCUDA": 104.03366666666666, "TestSelfKwarg": 0.02266666666666667, "TestTagsCUDA": 3.182000000000002}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1448.5390000000007}, "test_ops_gradients": {"TestBwdGradientsCUDA": 2361.109666666712}, "test_ops_jit": {"TestJitCUDA": 1364.346333333331}, "test_optim": {"TestDifferentiableOptimizer": 0.2773333333333334, "TestLRScheduler": 1.1449999999999985, "TestOptim": 95.257, "TestOptimRenewedCUDA": 532.4729999999985, "TestSWAUtils": 1.518}, "test_out_dtype_op": {"TestOutDtypeOp": 0.401}, "test_overrides": {"TestBroadcastAllOverride": 0.0030000000000000005, "TestDisabledTorchFunction": 0.002, "TestDisabledUserWarnings": 0.002, "TestEinsumOverride": 0.004333333333333334, "TestGradCheckOverride": 0.028999999999999998, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.01, "TestIterator": 0.0023333333333333335, "TestNamedTuple": 0.0026666666666666666, "TestPickle": 0.0026666666666666666, "TestRNN": 0.0030000000000000005, "TestResolveName": 0.13933333333333334, "TestTorchFunctionMode": 0.04800000000000002, "TestTorchFunctionOverride": 3.1863333333332062, "TestTorchFunctionWarning": 0.014666666666666666, "TestWrapTorchFunction": 0.002}, "test_package": {"DirectoryReaderTest": 0.051, "ModelTest": 0.0030000000000000005, "TestAnalyze": 0.22399999999999998, "TestDependencyAPI": 0.05733333333333335, "TestDependencyHooks": 0.01, "TestDiGraph": 0.02233333333333334, "TestGlobGroup": 0.028666666666666677, "TestImporter": 0.012333333333333335, "TestLoadBCPackages": 0.06833333333333334, "TestMangling": 0.021333333333333333, "TestMisc": 0.03566666666666667, "TestPackageFX": 0.07466666666666667, "TestPackageScript": 2.194666666666666, "TestRepackage": 0.007, "TestResources": 0.013000000000000003, "TestSaveLoad": 0.04}, "test_per_overload_api": {"TestPerOverloadAPI": 0.313}, "test_prims": {"TestDecompCUDA": 0.09666666666666668, "TestPrimsBasic": 0.034, "TestPrimsCUDA": 0.3903333333333334, "TestRefsCUDA": 0.013}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.139, "TestGenericProxyTensorFake": 2.4756666666666662, "TestGenericProxyTensorReal": 2.624333333333334, "TestGenericProxyTensorSymbolic": 23.558999999999997, "TestRealProxyTensor": 0.024000000000000004, "TestSymbolicTracing": 4.762999999999999}, "test_pruning_op": {"PruningOpTest": 0.5379999999999999}, "test_public_bindings": {"TestPublicBindings": 6.504666666666666}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.024000000000000004, "TestPythonDispatch": 0.4130000000000001, "TestPythonDispatcher": 0.007333333333333333, "TestPythonRegistration": 1.7046666666666663, "TestWrapperSubclassAliasingCUDA": 0.15800000000000003}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 0.4390000000000001, "TestPythonPytree": 0.07266666666666671}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.018666666666666668, "TestAOMigrationNNQuantized": 0.04733333333333334, "TestAOMigrationQuantization": 0.024000000000000004, "TestAOMigrationQuantizationFx": 0.026, "TestBackendConfig": 0.04533333333333334, "TestBiasCorrectionEager": 0.8086666666666668, "TestBits": 0.005, "TestBitsCUDA": 0.036, "TestComparatorOps": 1.6913333333333334, "TestDeprecatedJitQuantized": 2.522, "TestDistributed": 0.028333333333333335, "TestDuplicateDQPass": 4.769333333333333, "TestDynamicQuantizedModule": 25.462666666666667, "TestDynamicQuantizedOps": 11.711666666666666, "TestEqualizeEager": 0.12766666666666668, "TestEqualizeFx": 4.172999999999999, "TestFXGraphMatcher": 1.4116666666666664, "TestFXGraphMatcherModels": 10.922333333333334, "TestFXNumericSuiteCoreAPIs": 36.42066666666667, "TestFXNumericSuiteCoreAPIsModels": 47.64000000000001, "TestFXNumericSuiteNShadows": 45.091333333333324, "TestFakeQuantize": 0.3136666666666667, "TestFakeQuantizeOps": 29.752333333333336, "TestFloat8DtypeCUDA": 0.37966666666666676, "TestFuseEager": 3.0563333333333333, "TestFuseFx": 2.2756666666666665, "TestFusedObsFakeQuant": 0.30433333333333334, "TestFusedObsFakeQuantModule": 0.3263333333333333, "TestFusionPasses": 0.02366666666666667, "TestFxDetectInputWeightEqualization": 0.21666666666666665, "TestFxDetectOutliers": 0.29533333333333334, "TestFxModelReportClass": 0.5813333333333334, "TestFxModelReportDetectDynamicStatic": 0.07633333333333332, "TestFxModelReportDetector": 0.22299999999999998, "TestFxModelReportObserver": 0.26866666666666666, "TestFxModelReportVisualizer": 0.25566666666666665, "TestGenerateNumericDebugHandle": 1.0183333333333333, "TestGraphUtils": 1.6453333333333333, "TestHistogramObserver": 52.810333333333325, "TestMetaDataPorting": 9.927666666666667, "TestModelNumericsEager": 0.746, "TestNumericSuiteEager": 9.122333333333334, "TestObserver": 5.304333333333333, "TestPT2ERepresentation": 37.083333333333336, "TestPadding": 10.609333333333334, "TestQNNPackOps": 2.8639999999999994, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 2.055, "TestQuantizeDynamicJitPasses": 4.947333333333334, "TestQuantizeEagerOps": 2.0580000000000003, "TestQuantizeEagerPTQDynamic": 7.876333333333332, "TestQuantizeEagerPTQStatic": 28.273, "TestQuantizeEagerQAT": 8.127333333333333, "TestQuantizeEagerQATNumerics": 2.304, "TestQuantizeFx": 34.378, "TestQuantizeFxModels": 12.550333333333334, "TestQuantizeFxOps": 133.17666666666665, "TestQuantizeJit": 25.096333333333334, "TestQuantizeJitOps": 279.01399999999995, "TestQuantizeJitPasses": 6.043666666666667, "TestQuantizePT2E": 105.59133333333334, "TestQuantizePT2EQAT": 100.14000000000003, "TestQuantizePT2EQATModels": 59.36033333333334, "TestQuantizePT2EQAT_ConvBn1d": 900.1243333333333, "TestQuantizePT2EQAT_ConvBn2d": 901.8433333333332, "TestQuantizePT2EX86Inductor": 280.154, "TestQuantizedConv": 37.855000000000004, "TestQuantizedEmbeddingOps": 0.7879999999999999, "TestQuantizedFunctionalOps": 1.2186666666666666, "TestQuantizedLinear": 16.229, "TestQuantizedOps": 124.45766666666664, "TestQuantizedTensor": 3.3313333333333333, "TestRecordHistogramObserver": 0.034, "TestReferenceQuantizedModule": 0.04833333333333334, "TestSerialization": 1.521, "TestStaticQuantizedModule": 78.39266666666667, "TestSubgraphRewriter": 1.1860000000000002, "TestUtils": 0.019666666666666666, "TestXNNPACKQuantizer": 64.16833333333334, "TestXNNPACKQuantizerModels": 4.014666666666667}, "test_reductions": {"TestReductionsCUDA": 139.88566666666011}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 19.708000000000002}, "test_schema_check": {"TestSchemaCheck": 0.1393333333333334, "TestSchemaCheckModeOpInfoCUDA": 341.97199999999106}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 3.364999999999998}, "test_serialization": {"TestBothSerializationCUDA": 0.12833333333333333, "TestOldSerialization": 27.65066666666667, "TestSerialization": 11.752666666666672, "TestSubclassSerialization": 0.035333333333333335}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.302}, "test_shape_ops": {"TestShapeOpsCUDA": 1.6083333333333323}, "test_show_pickle": {"TestShowPickle": 0.34400000000000003}, "test_sort_and_select": {"TestSortAndSelectCUDA": 6.543666666666663}, "test_sparse": {"TestSparseAnyCUDA": 814.1909999999997, "TestSparseCUDA": 50.65133333333336, "TestSparseLegacyAndDeprecation": 0.051666666666666666, "TestSparseMaskedReductionsCUDA": 2.8336666666666672, "TestSparseMeta": 5.1049999999999995, "TestSparseOneOff": 0.08900000000000001, "TestSparseUnaryUfuncsCUDA": 7.950333333333288}, "test_sparse_csr": {"TestSparseCSRCUDA": 219.31433333333345, "TestSparseCSRSampler": 0.8433333333333333, "TestSparseCompressedCUDA": 157.6310000000001, "TestSparseCompressedTritonKernelsCUDA": 0.010000000000000002}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005, "TestCUSPARSELTCUDA": 0.028000000000000014, "TestSparseSemiStructuredCUDA": 0.09700000000000007, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.028000000000000014, "TestSparseSemiStructuredCUTLASSCUDA": 0.016000000000000007, "TestSparseSemiStructuredTrainingCUDA": 0.02000000000000001}, "test_spectral_ops": {"TestFFTCUDA": 25.616999999999994}, "test_stateless": {"TestPythonOptimizeMode": 4.207666666666667, "TestStatelessDeprecation": 2.0843333333333334, "TestStatelessFunctionalAPI": 0.2713333333333334}, "test_subclass": {"TestSubclass": 0.5136666666666668}, "test_sympy_utils": {"TestNumbers": 0.04533333333333334, "TestSingletonInt": 0.006000000000000001, "TestSympyInterp": 11.237, "TestSympySolve": 0.2056666666666667, "TestValueRanges": 7.457999999999998}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.7186666666666671, "TestLikeTensorCreationCUDA": 0.012333333333333335, "TestRandomTensorCreationCUDA": 0.39833333333333343, "TestTensorCreationCUDA": 109.96866666666631}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.02366666666666667, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.004666666666666667, "TestTensorBoardPyTorchNumpy": 0.21166666666666667, "TestTensorBoardPytorchGraph": 31.675666666666668, "TestTensorBoardSummary": 0.03933333333333334, "TestTensorBoardSummaryWriter": 0.008666666666666668, "TestTensorBoardUtils": 0.17366666666666664, "TestTensorBoardWriter": 0.07933333333333333, "TestTensorProtoSummary": 0.016999999999999998}, "test_tensorexpr": {"TestTensorExprFuser": 139.249}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.012000000000000002, "TestTensorExprPyBind": 0.972666666666667}, "test_testing": {"TestAssertClose": 0.12200000000000005, "TestAssertCloseContainer": 0.007333333333333333, "TestAssertCloseErrorMessage": 0.07100000000000001, "TestAssertCloseMultiDeviceCUDA": 0.012666666666666668, "TestAssertCloseQuantized": 0.013999999999999999, "TestAssertCloseSparseBSC": 0.021333333333333333, "TestAssertCloseSparseBSR": 0.021, "TestAssertCloseSparseCOO": 0.025000000000000005, "TestAssertCloseSparseCSC": 0.021, "TestAssertCloseSparseCSR": 0.02066666666666667, "TestFrameworkUtils": 16.31233333333333, "TestImports": 15.200666666666669, "TestMakeTensorCUDA": 1.6476666666666677, "TestOpInfoSampleFunctionsCUDA": 5.157333333333226, "TestOpInfos": 0.005333333333333333, "TestTestParametrization": 0.03566666666666669, "TestTestParametrizationDeviceTypeCUDA": 4.317666666666665, "TestTestingCUDA": 0.7813333333333334}, "test_torch": {"TestBasicVitalSigns": 0.026, "TestDevicePrecisionCUDA": 0.09833333333333337, "TestTorch": 7.3893333333333215, "TestTorchDeviceTypeCUDA": 141.51666666666668, "TestVitalSignsCudaCUDA": 0.002}, "test_transformers": {"TestAttnBiasCUDA": 2.671, "TestAttnMasksCUDA": 0.4653333333333333, "TestSDPACUDA": 2.3863333333332757, "TestSDPACudaOnlyCUDA": 156.11499999999708, "TestSDPAFailureModesCUDA": 0.07433333333333338, "TestTransformersCUDA": 5.795666666666666}, "test_type_hints": {"TestTypeHints": 0.3076666666666667}, "test_type_info": {"TestDTypeInfo": 0.307}, "test_type_promotion": {"TestTypePromotionCUDA": 10.206999999999995}, "test_typing": {"TestTyping": 91.05966666666664}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 493.33433333331317}, "test_utils": {"TestAssert": 0.07733333333333332, "TestBottleneck": 13.713666666666667, "TestCheckpoint": 0.26366666666666666, "TestCollectEnv": 1.216, "TestCppExtensionUtils": 0.03266666666666667, "TestDataLoaderUtils": 0.20099999999999998, "TestDeviceUtilsCUDA": 17.637000000000494, "TestExtensionUtils": 0.004333333333333334, "TestHipify": 0.002, "TestHipifyTrie": 0.008, "TestONNXUtils": 0.004333333333333334, "TestRenderUtils": 0.014333333333333332, "TestStandaloneCPPJIT": 2.857666666666667, "TestTraceback": 0.01}, "test_view_ops": {"TestOldViewOpsCUDA": 21.01433333333333, "TestViewOpsCUDA": 1.41}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.01833333333333333, "WeakKeyDictionaryTestCase": 0.026, "WeakTest": 5.027333333333332}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 21.99933333333333, "TestXNNPACKOps": 2.374, "TestXNNPACKRewritePass": 0.9976666666666665, "TestXNNPACKSerDes": 2.934333333333333}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.010000000000000002}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.3286666666666667, "TestClassGetItem": 0.0023333333333333335, "TestDtypeAttributeDeletion": 0.0003333333333333333, "TestFromDTypeAttribute": 0.0026666666666666666, "TestMisc": 0.004333333333333334, "TestPickling": 0.1526666666666667, "TestPromotion": 0.0033333333333333335}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 19.938, "TestEinsumPath": 0.002, "TestMisc": 0.006666666666666667}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.002, "TestHalf": 0.001, "TestIinfo": 0.31866666666666665, "TestMisc": 0.004666666666666667, "TestPythonFloat": 0.001, "TestRepr": 0.0036666666666666666, "TestSingle": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.006000000000000001, "TestBroadcastedAssignments": 0.017666666666666667, "TestFancyIndexingCast": 0.004, "TestFloatNonIntegerArgument": 0.01, "TestIndexing": 0.4366666666666668, "TestMultiIndexingAutomated": 0.009666666666666669, "TestMultipleEllipsisError": 0.002, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.026666666666666672, "TestArgmax": 1.434333333333333, "TestArgmaxArgminCommon": 0.2046666666666668, "TestArgmin": 1.6206666666666665, "TestArrayAttributeDeletion": 0.007666666666666666, "TestArrayConstruction": 0.056000000000000015, "TestArrayCreationCopyArgument": 0.004, "TestArrayInterface": 0.022333333333333334, "TestAssignment": 0.015666666666666672, "TestAttributes": 0.027333333333333338, "TestBinop": 0.02466666666666667, "TestBool": 34.248, "TestCequenceMethods": 0.002, "TestChoose": 0.028666666666666674, "TestClip": 0.010333333333333333, "TestCompress": 0.008, "TestConversion": 0.051, "TestCreation": 0.006000000000000001, "TestDelMisc": 0.002, "TestDot": 0.08766666666666671, "TestDtypedescr": 0.002, "TestFancyIndexing": 0.037333333333333336, "TestFlag": 0.014333333333333337, "TestFormat": 0.006333333333333334, "TestFromBuffer": 0.01666666666666667, "TestHash": 0.21333333333333335, "TestHashing": 0.004, "TestIO": 0.004, "TestInner": 0.29466666666666663, "TestLexsort": 0.02366666666666667, "TestMatmul": 0.5866666666666668, "TestMatmulOperator": 0.403, "TestMethods": 1.8953333333333333, "TestMinMax": 0.008, "TestMinScalarType": 0.007333333333333333, "TestNewaxis": 0.006666666666666667, "TestPEP3118Dtype": 0.0026666666666666666, "TestPutmask": 0.015333333333333336, "TestRepeat": 0.018666666666666665, "TestResize": 0.06366666666666666, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.028000000000000008, "TestSizeOf": 0.009333333333333334, "TestSortFloatMisc": 0.20466666666666675, "TestStats": 0.325, "TestSubscripting": 0.002, "TestTake": 0.04466666666666667, "TestVdot": 0.04966666666666667, "TestViewDtype": 0.006000000000000001, "TestWarnings": 0.002, "TestWhere": 0.4036666666666667, "TestWritebackIfCopy": 0.031000000000000003}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.025000000000000005, "TestArgwhere": 0.036000000000000004, "TestArrayComparisons": 0.015, "TestBaseRepr": 0.006666666666666667, "TestBinaryRepr": 0.010333333333333333, "TestBoolArray": 2.2976666666666663, "TestBoolCmp": 0.24133333333333332, "TestBoolScalar": 0.011666666666666667, "TestBroadcast": 0.008333333333333333, "TestClip": 0.2343333333333335, "TestConvolve": 0.02366666666666667, "TestCorrelate": 0.039666666666666676, "TestCreationFuncs": 1.5073333333333332, "TestCross": 0.06833333333333334, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.011333333333333334, "TestFromiter": 0.0016666666666666668, "TestIndex": 0.007, "TestIndices": 0.05100000000000001, "TestIsclose": 0.11166666666666668, "TestIsscalar": 0.002, "TestLikeFuncs": 0.0013333333333333333, "TestMoveaxis": 0.010333333333333333, "TestNonarrayArgs": 0.1373333333333334, "TestNonzeroAndCountNonzero": 0.32833333333333337, "TestOuterMisc": 0.006666666666666667, "TestRequire": 0.007333333333333333, "TestResize": 0.2986666666666667, "TestRoll": 0.04166666666666668, "TestRollaxis": 0.005, "TestSeterr": 0.007333333333333333, "TestStdVar": 0.03633333333333333, "TestStdVarComplex": 0.016333333333333335, "TestStringFunction": 0.002, "TestTensordot": 0.017, "TestTypes": 0.020000000000000004}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.002, "TestCommonType": 0.3403333333333333, "TestDocStrings": 0.001, "TestIsSubDType": 0.011000000000000001, "TestScalarTypeNames": 0.03566666666666669}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.10266666666666674, "TestFromInt": 0.009333333333333334, "TestFromString": 0.32766666666666666}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.004666666666666667, "TestBitCount": 0.0026666666666666666, "TestClassGetItem": 0.0036666666666666666, "TestClassGetitemMisc": 0.0030000000000000005, "TestIsInteger": 0.0033333333333333335}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.1396666666666667, "TestBaseMath": 12.819666666666668, "TestBitShifts": 0.12733333333333333, "TestComplexDivision": 0.08033333333333333, "TestConversion": 0.07633333333333335, "TestHash": 0.0026666666666666666, "TestModulus": 1.3386666666666667, "TestMultiply": 0.0003333333333333333, "TestNegative": 0.02566666666666667, "TestPower": 0.17433333333333334, "TestRepr": 0.002, "TestScalarOpsMisc": 0.06733333333333337, "TestScalarSubclassingMisc": 0.07833333333333338, "TestSubtract": 0.025333333333333336, "TestTypes": 20.123}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.30200000000000005, "TestAtleast2d": 0.018000000000000002, "TestAtleast3d": 0.016, "TestBlock": 0.033000000000000015, "TestConcatenate": 0.17400000000000007, "TestHstack": 0.02066666666666667, "TestStackMisc": 0.021000000000000008, "TestVstack": 0.024333333333333335}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.014666666666666666, "TestFFTShift": 8.656333333333333, "TestIRFFTN": 0.004333333333333334, "TestRFFTFreq": 0.014}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.4469999999999996, "TestFFTShift": 0.29333333333333333, "TestFFTThreadSafe": 0.6413333333333334}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.355}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.008, "TestUnique": 0.533}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.008666666666666668, "TestAmax": 0.008333333333333333, "TestAmin": 0.008333333333333333, "TestAngle": 0.012000000000000002, "TestAny": 0.009000000000000001, "TestAverage": 0.03900000000000001, "TestBincount": 0.05366666666666667, "TestCheckFinite": 0.0036666666666666666, "TestCopy": 0.01, "TestCorrCoef": 0.04466666666666667, "TestCov": 0.08233333333333336, "TestCumprod": 0.043333333333333335, "TestCumsum": 0.057999999999999996, "TestDelete": 0.021, "TestDiff": 0.10133333333333334, "TestDigitize": 0.02066666666666667, "TestExtins": 0.007, "TestFilterwindows": 0.7403333333333338, "TestFlip": 0.04066666666666666, "TestGradient": 0.18900000000000003, "TestInsert": 0.012333333333333335, "TestInterp": 0.053333333333333365, "TestKaiser": 0.014666666666666666, "TestMedian": 0.1476666666666667, "TestMeshgrid": 0.07866666666666668, "TestMsort": 0.001, "TestPercentile": 0.18000000000000013, "TestPiecewise": 0.015, "TestProd": 0.042, "TestPtp": 0.013, "TestQuantile": 0.04000000000000002, "TestRot90": 0.26666666666666666, "TestSelect": 0.012333333333333333, "TestSinc": 0.011000000000000001, "TestSortComplex": 0.014, "TestTrapz": 0.008, "TestTrimZeros": 0.015, "TestUnique": 0.005, "Test_I0": 0.018666666666666668}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4830000000000001, "TestHistogramOptimBinNums": 0.03500000000000001, "TestHistogramdd": 0.18033333333333337}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0016666666666666668, "TestConcatenator": 0.010666666666666666, "TestDiagIndices": 0.006666666666666667, "TestDiagIndicesFrom": 0.009666666666666669, "TestFillDiagonal": 0.03133333333333333, "TestGrid": 0.014333333333333335, "TestIndexExpression": 0.013333333333333334, "TestIx_": 0.009333333333333334, "TestNdIndex": 0.0016666666666666668, "TestNdenumerate": 0.002, "TestRavelUnravelIndex": 0.3116666666666667}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.017666666666666667, "TestApplyOverAxes": 0.002, "TestArraySplit": 0.2293333333333334, "TestColumnStack": 0.012333333333333335, "TestDsplit": 0.014, "TestDstack": 0.020000000000000004, "TestExpandDims": 0.008666666666666668, "TestHsplit": 0.016, "TestKron": 0.02166666666666667, "TestMayShareMemory": 0.002, "TestPutAlongAxis": 0.012333333333333335, "TestSplit": 0.008, "TestSqueeze": 0.037000000000000005, "TestTakeAlongAxis": 0.3826666666666667, "TestTile": 0.11366666666666665, "TestVsplit": 0.012000000000000002}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.03900000000000001, "TestEye": 0.3646666666666667, "TestFliplr": 0.007, "TestFlipud": 0.007, "TestHistogram2d": 0.046000000000000006, "TestTri": 0.122, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.0030000000000000005, "TestTriuIndicesFrom": 0.002, "TestVander": 0.023000000000000003}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0016666666666666668, "TestCommonType": 0.30666666666666664, "TestImag": 0.015333333333333332, "TestIscomplex": 0.006000000000000001, "TestIscomplexobj": 0.006000000000000001, "TestIsfinite": 0.014, "TestIsinf": 0.012000000000000002, "TestIsnan": 0.014, "TestIsneginf": 0.002, "TestIsposinf": 0.0026666666666666666, "TestIsreal": 0.01, "TestIsrealobj": 0.002, "TestIsscalar": 0.002, "TestMintypecode": 0.005333333333333333, "TestNanToNum": 0.021000000000000005, "TestReal": 0.017333333333333336, "TestRealIfClose": 0.005666666666666667}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.17533333333333337, "TestCond": 0.3076666666666667, "TestDet": 0.20400000000000004, "TestEig": 0.04400000000000001, "TestEigh": 0.03366666666666668, "TestEighCases": 0.0, "TestEigvals": 0.07233333333333335, "TestEigvalsh": 0.028000000000000008, "TestEigvalshCases": 0.0, "TestInv": 0.06633333333333334, "TestLstsq": 0.278, "TestMatrixRank": 0.5216666666666666, "TestMisc": 0.021333333333333333, "TestMisc2": 0.004333333333333334, "TestMultiDot": 0.063, "TestNormDouble": 1.1183333333333334, "TestNormInt64": 1.1293333333333333, "TestNormSingle": 1.1433333333333335, "TestNorm_NonSystematic": 0.004666666666666667, "TestPinv": 0.1516666666666667, "TestPinvHermitian": 0.044000000000000004, "TestQR": 0.6296666666666667, "TestSVD": 0.056333333333333346, "TestSVDHermitian": 0.13066666666666668, "TestSolve": 0.35333333333333333, "TestTensorinv": 0.022333333333333334, "TestTensorsolve": 0.007}, "torch_np/test_basic": {"TestArrayToSequence": 0.011333333333333334, "TestCopyTo": 0.006666666666666667, "TestCtorNested": 0.004, "TestDefaultDtype": 0.008, "TestDivmod": 0.018666666666666668, "TestExport": 0.0006666666666666666, "TestMisc": 0.24, "TestNormalizations": 0.006000000000000001, "TestOneArr": 0.450666666666667, "TestOneArrAndAxesTuple": 0.017, "TestOneArrAndAxis": 0.2526666666666668, "TestOneArrAndShape": 0.016000000000000007, "TestOneArrToScalar": 0.016000000000000004, "TestPythonArgsToArray": 0.019333333333333338, "TestSequenceOfArrays": 0.028666666666666684, "TestSequenceOfArraysToSingle": 0.014, "TestShapeLikeToArray": 0.007666666666666666, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.4353333333333334}, "torch_np/test_dtype": {"TestConvertDType": 0.38033333333333336}, "torch_np/test_function_base": {"TestAppend": 0.32566666666666666}, "torch_np/test_ndarray_methods": {"TestAmax": 0.01, "TestAmin": 0.010333333333333333, "TestArgmax": 1.3219999999999998, "TestArgmaxArgminCommon": 0.20333333333333348, "TestArgmin": 1.455333333333333, "TestContains": 0.002, "TestIndexing": 0.2906666666666667, "TestIter": 0.006000000000000001, "TestNoExtraMethods": 0.011000000000000001, "TestNonzero": 0.2046666666666667, "TestRavel": 0.008, "TestReshape": 0.005333333333333333, "TestTranspose": 0.011000000000000001}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.07400000000000004, "TestNEP50Table": 0.005}, "torch_np/test_random": {"TestChoice": 0.01333333333333333, "TestNumpyGlobal": 0.004666666666666667, "TestScalarReturn": 0.36066666666666675, "TestShuffle": 0.012333333333333335}, "torch_np/test_reductions": {"TestAll": 0.014666666666666666, "TestAny": 0.015333333333333332, "TestFlatnonzero": 0.2323333333333333, "TestGenericCumSumProd": 0.024333333333333335, "TestGenericReductions": 2.66466666666663, "TestMean": 0.02666666666666666, "TestSum": 0.30033333333333334}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.34366666666666673, "TestIsScalar": 0.034666666666666686}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.6966666666666672, "TestNdarrayDunderVsUfunc": 0.2616666666666667, "TestUfuncDtypeKwd": 0.006666666666666667, "TestUnaryUfuncs": 0.3546666666666667}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.4926666666666668}}, "jit_legacy": {"test_jit_fuser_legacy": {"TestFuser": 0.0105}, "test_jit_legacy": {"TestAliasAnalysis": 0.533, "TestAsync": 0.5445000000000001, "TestAtenPow": 0.013, "TestAutodiffJit": 0.07949999999999999, "TestAutodiffSubgraphSlicing": 0.40400000000000014, "TestAwait": 0.34950000000000003, "TestBackends": 1.152, "TestBackendsWithCompiler": 0.2345, "TestBatchMM": 0.14049999999999999, "TestBuiltins": 0.093, "TestCUDA": 1.408, "TestClassType": 4.1495, "TestComplex": 1.2965000000000004, "TestCustomOperators": 0.06300000000000003, "TestDCE": 0.0335, "TestDataParallel": 0.0075, "TestDataclasses": 5.8145, "TestDeviceAnalysis": 0.2585, "TestDict": 0.6425000000000003, "TestDtypeAnalysis": 0.25150000000000006, "TestEnum": 0.3215, "TestFreezing": 4.0755, "TestFrontend": 0.738, "TestFrozenOptimizations": 13.916499999999997, "TestFunctionalBlocks": 0.01, "TestFunctionalToInplaceActivation": 0.181, "TestGenerator": 0.08399999999999999, "TestGetDefaultAttr": 0.027499999999999997, "TestGraphRewritePasses": 0.061, "TestHash": 0.1135, "TestHooks": 1.0540000000000005, "TestIgnorableArgs": 0.016, "TestIgnoreContextManager": 0.066, "TestInplaceToFunctionalActivation": 0.0855, "TestIsinstance": 0.3055000000000001, "TestJit": 9.288499999999994, "TestJitGeneratedModule": 18.071500000000015, "TestJitProfiler": 0.0015, "TestJitUtils": 0.027500000000000004, "TestList": 2.1785000000000005, "TestLogging": 0.07899999999999999, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.26300000000000007, "TestMixTracingScripting": 2.073, "TestModels": 7.041999999999998, "TestModuleAPIs": 0.208, "TestModuleContainers": 1.9250000000000003, "TestModuleInterface": 0.784, "TestModules": 0.023, "TestNamedTuple": 0.10700000000000001, "TestNnapiBackend": 10.043499999999998, "TestOpDecompositions": 0.0295, "TestOptimizeForMobilePreserveDebugInfo": 0.25450000000000006, "TestParametrization": 0.14100000000000001, "TestPeephole": 0.7015000000000002, "TestProducerVersion": 0.003, "TestProfiler": 0.8725000000000002, "TestPythonBindings": 0.0465, "TestPythonBuiltinOP": 0.554, "TestPythonIr": 0.036000000000000004, "TestRecursiveScript": 1.1130000000000004, "TestRemoveMutation": 0.1965, "TestSaveLoad": 0.7415000000000002, "TestSaveLoadFlatbuffer": 0.8955, "TestSaveLoadForOpVersion": 3.6500000000000004, "TestScript": 76.16150000000007, "TestScriptDict": 0.038500000000000006, "TestScriptList": 1.223, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.275, "TestScriptProfile": 0.6445, "TestSlice": 0.2225000000000001, "TestSparse": 0.073, "TestStringFormatting": 0.18300000000000005, "TestSymbolicShapeAnalysis": 1.7839999999999994, "TestTensorBuiltins": 0.1525, "TestTensorCreationOps": 0.066, "TestTensorMethods": 0.017, "TestTorchbind": 0.2435000000000001, "TestTracer": 16.947499999999998, "TestTypeSharing": 0.7575000000000001, "TestTypesAndAnnotation": 0.1845, "TestTyping": 0.5630000000000003, "TestUnion": 0.6435000000000003, "TestUnsupportedOps": 0.043000000000000003, "TestUpgraders": 0.10500000000000004, "TestWarn": 0.079, "TestWith": 0.808}}, "nogpu_AVX512": {"backends/xeon/test_launch": {"TestTorchrun": 2.6435}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.782}, "distributions/test_distributions": {"TestAgainstScipy": 1.7150000000000003, "TestConstraints": 0.21650000000000003, "TestDistributionShapes": 0.1850000000000001, "TestDistributions": 52.70000000000002, "TestFunctors": 0.0165, "TestJit": 28.64, "TestKL": 4.405999999999999, "TestLazyLogitsInitialization": 0.018000000000000002, "TestNumericalStability": 0.10900000000000001, "TestRsample": 1.012, "TestValidation": 0.518}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.801}, "dynamo/test_after_aot": {"TestAfterAot": 10.5125}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 1.132}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 19.669}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.0744999999999996, "AOTAutogradCacheTests": 15.290000000000003}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.137}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.052500000000000005, "TestCustomBackendAPI": 2.5024999999999995, "TestExplainWithBackend": 15.6845, "TestOptimizations": 2.8899999999999992}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 18.503}, "dynamo/test_base_output": {"TestBaseOutput": 0.0035}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.319}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 9.0175, "BytecodeTests": 0.6799999999999999}, "dynamo/test_compile": {"InPlaceCompilationTests": 10.788499999999999, "PublicTorchCompilerTests": 0.003}, "dynamo/test_comptime": {"ComptimeTests": 0.9625000000000001}, "dynamo/test_config": {"ConfigTests": 0.8940000000000001}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.211, "CppGuardManagerFuncTorchHigherOrderOpTests": 10.904999999999996, "CppGuardManagerFunctionTests": 22.30533333333334, "CppGuardManagerHigherOrderOpTests": 6.689333333333333, "CppGuardManagerMiscTests": 42.17866666666673, "CppGuardManagerReproTests": 32.93266666666667}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.9315000000000007}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.382}, "dynamo/test_decorators": {"DecoratorTests": 10.3265}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.022}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 49.0525, "DynamicShapesCtxManagerTests": 7.180499999999998, "DynamicShapesExportTests": 41.607500000000016, "DynamicShapesFuncTorchHigherOrderOpTests": 139.586, "DynamicShapesFunctionTests": 99.08849999999998, "DynamicShapesHigherOrderOpTests": 22.894000000000002, "DynamicShapesMiscTests": 119.37349999999998, "DynamicShapesNNModuleTests": 8.990999999999998, "DynamicShapesReproTests": 137.34150000000005, "DynamicShapesSubGraphTests": 12.189000000000004, "DynamicShapesTestSDPA": 0.5075000000000001}, "dynamo/test_exc": {"ExcTests": 2.8655}, "dynamo/test_exceptions": {"ExceptionTests": 0.8390000000000001}, "dynamo/test_export": {"ExportTests": 21.7895}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8675000000000002}, "dynamo/test_frame_init": {"FrameInitTests": 0.337}, "dynamo/test_functions": {"DefaultsTests": 1.0815000000000001, "FunctionTests": 33.442000000000064}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.6885}, "dynamo/test_global": {"TestGlobals": 0.8240000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.391}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.1295, "FuncTorchHigherOrderOpTests": 11.083499999999997, "HigherOrderOpTests": 11.048999999999998, "HigherOrderOpVmapGuardTests": 5.446999999999999}, "dynamo/test_hooks": {"HooksTests": 37.256500000000024}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 6.4655000000000005, "InlineInbuiltNNModulesExportTests": 27.58200000000001, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 10.912499999999998, "InlineInbuiltNNModulesFunctionTests": 6.516499999999988, "InlineInbuiltNNModulesHigherOrderOpTests": 10.268499999999996, "InlineInbuiltNNModulesMiscTests": 76.58350000000009, "InlineInbuiltNNModulesNNModuleTests": 5.9985}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 12.1985}, "dynamo/test_interop": {"InteropTests": 0.8895}, "dynamo/test_logging": {"LoggingTests": 25.216500000000003}, "dynamo/test_minifier": {"MinifierTests": 2.0459999999999994}, "dynamo/test_misc": {"MiscTests": 84.21450000000011, "TestTracer": 0.078}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.005}, "dynamo/test_modules": {"NNModuleTests": 4.018999999999997, "OptimizedModuleTest": 24.241999999999997}, "dynamo/test_nops": {"NopTests": 0.46799999999999997}, "dynamo/test_optimizers": {"End2EndTests": 0.9855, "OptimizerTests": 1.6343333333333332}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.7635000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.8639999999999997}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.9970000000000001}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.2795000000000003}, "dynamo/test_recompiles": {"RecompileTests": 1.2825000000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.8400000000000001}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.8130000000000002}, "dynamo/test_repros": {"ReproTests": 50.63799999999999}, "dynamo/test_resume": {"ResumeFunctionTests": 0.739}, "dynamo/test_sdpa": {"TestSDPA": 0.784}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.89}, "dynamo/test_sources": {"SourceTests": 0.7675000000000001}, "dynamo/test_structured_trace": {"StructuredTraceTest": 17.290499999999998}, "dynamo/test_subclasses": {"SubclassTests": 4.350999999999998, "TestNestedTensor": 16.865}, "dynamo/test_subgraphs": {"SubGraphTests": 3.2529999999999983}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.14500000000000002, "TraceRuleTests": 1.755}, "dynamo/test_triton_kernels": {"KernelTests": 0.025000000000000012, "MutationTests": 0.0030000000000000005, "NoOptimizationKernelTests": 0.014000000000000005, "no_opt_test_class": 0.016333333333333342}, "dynamo/test_unspec": {"UnspecTests": 19.787499999999994}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.9339999999999999}, "dynamo/test_view": {"ViewTests": 0.9885}, "export/test_converter": {"TestConverter": 7.380000000000001}, "export/test_db": {"ExampleTests": 4.454499999999999}, "export/test_experimental": {"TestExperiment": 1.4244999999999999}, "export/test_export": {"TestDynamismExpression": 0.7030000000000001, "TestExport": 41.046, "TestExportCustomClass": 0.0955, "TestOneOffModelExportResult": 1.5180000000000002}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.5685, "NonStrictExportTestExport": 35.85300000000001}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.453, "PreDispatchExportTestExport": 26.291666666666668}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.34900000000000003}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.6623333333333333}, "export/test_hop": {"TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.137, "TestLiftUnlift": 0.011000000000000001}, "export/test_pass_infra": {"TestPassInfra": 1.3285000000000002}, "export/test_passes": {"TestPasses": 17.890000000000004}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.173, "RetraceExportTestExport": 66.896}, "export/test_safeguard": {"TestSafeguard": 0.9423333333333334}, "export/test_schema": {"TestSchema": 0.4115}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.22333333333333336, "SerDesExportPreDispatchTestExport": 19.38166666666667, "SerDesExportTestDynamismExpression": 0.7805, "SerDesExportTestExport": 43.8375}, "export/test_serialize": {"TestDeserialize": 11.202000000000005, "TestOpVersioning": 0.004666666666666667, "TestSaveLoad": 0.43300000000000005, "TestSchemaVersioning": 0.0475, "TestSerialize": 1.5370000000000001, "TestSerializeCustomClass": 0.124}, "export/test_sparse": {"TestSparseProp": 84.51149999999986}, "export/test_tools": {"TestExportTools": 0.841}, "export/test_torchbind": {"TestCompileTorchbind": 1.5225000000000004, "TestExportTorchbind": 2.524999999999999, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.34099999999999997}, "export/test_unflatten": {"TestUnflatten": 4.5005}, "export/test_upgrade": {"TestUpgrade": 0.42100000000000004}, "export/test_verifier": {"TestVerifier": 1.3520000000000003}, "functorch/test_aotdispatch": {"TestAOTAutograd": 17.385999999999996, "TestAOTAutogradWithDynamo": 18.90649999999999, "TestAOTDispatch": 0.7144999999999999, "TestAOTExport": 3.1000000000000005, "TestAOTModuleSimplified": 0.9029999999999999, "TestPartitioning": 1.4405000000000001}, "functorch/test_control_flow": {"TestControlFlow": 1.0705000000000002, "TestControlFlowTraced": 156.47149999999993}, "functorch/test_dims": {"TestMin": 22.262000000000004, "TestMinFunctorchOnly": 21.226499999999994}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.14000000000000004, "TestSliceArgnums": 0.019500000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.3945}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.7535000000000001, "RandomOpTestCase": 0.11249999999999999, "ReduceTestCase": 0.10999999999999999, "TestMemoryEfficientOpAuthoring": 0.002}, "functorch/test_minifier": {"TestMinifier": 0.621}, "functorch/test_parsing": {"TestAnonymousAxis": 0.343, "TestParsedExpression": 0.0075, "TestParsingUtils": 0.006, "TestValidateRearrangeExpressions": 0.006}, "functorch/test_rearrange": {"TestRearrange": 0.42450000000000004}, "functorch/test_vmap": {"TestVmapAPI": 0.3550000000000002, "TestVmapOperators": 4.27549999999999}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.6054999999998336}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.517}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 13.252500000000001}, "inductor/test_binary_folding": {"FreezingCpuTests": 52.87949999999999}, "inductor/test_codecache": {"TestFxGraphCache": 56.7375, "TestFxGraphCacheHashing": 1.0025, "TestUtils": 5.0015, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.34}, "inductor/test_compile_worker": {"TestCompileWorker": 11.4375}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 228.00400000000067, "TestAutogradWithCompiledAutograd": 422.0540000000003, "TestCompiledAutograd": 259.1845, "TestCustomOpWithCompiledAutograd": 0.7565000000000004}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 342.64050000000066}, "inductor/test_config": {"TestInductorConfig": 9.113}, "inductor/test_control_flow": {"CondTests": 0.113, "WhileLoopTests": 0.006}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 585.3253333333333, "TestCppWrapper": 609.9226666666666}, "inductor/test_cpu_repro": {"CPUReproTests": 941.2394999999999}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 15.8995}, "inductor/test_debug_trace": {"TestDebugTrace": 4.942}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.002}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 52.758500000000005}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 27.283}, "inductor/test_flex_attention": {"TestFlexAttention": 0.021000000000000008, "TestTemplatedSDPA": 0.017000000000000008}, "inductor/test_foreach": {"ForeachTests": 25.056000000000026}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 110.62, "SDPAPatternRewriterCpuTests": 105.94049999999999}, "inductor/test_fx_fusion": {"TestFxFusion": 0.2885}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.0205}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.3055, "TestGroupBatchFusion": 0.0025, "TestPostGradBatchLinearFusion": 0.0005}, "inductor/test_indexing": {"ExprPrinterTests": 0.06300000000000001, "TestIndexingSimplification": 0.8654999999999999}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 76.92600000000002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_metrics": {"TestMetrics": 0.214}, "inductor/test_minifier": {"MinifierTests": 35.184000000000005}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 68.187}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 223.7765, "TestPatternMatcher": 782.7675000000002}, "inductor/test_profiler": {"DynamoProfilerTests": 0.0033333333333333335}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 24.488500000000002}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.021333333333333343}, "inductor/test_torchbind": {"TestTorchbind": 14.026}, "inductor/test_torchinductor": {"CpuTests": 1977.2819999999992, "SweepInputsCpuTest": 168.52949999999998, "TestFull": 15.123000000000001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2088.2109999999993}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2207.2584999999985}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.863}, "inductor/test_triton_kernels": {"KernelTests": 0.033000000000000015, "MutationTests": 0.0055, "NoOptimizationKernelTests": 0.015000000000000006, "no_opt_test_class": 0.019333333333333345}, "inductor/test_utils": {"TestUtils": 0.3405}, "lazy/test_debug_util": {"DebugUtilTest": 0.40800000000000003}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.42800000000000005}, "lazy/test_generator": {"LazyGeneratorTest": 0.4305}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.776}, "lazy/test_step_closures": {"ClosuresTest": 3.3375}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.274, "TestLazyTensor": 0.0835}, "nn/test_convolution": {"TestConvolutionNN": 21.135500000000004}, "nn/test_dropout": {"TestDropoutNN": 0.15100000000000002}, "nn/test_embedding": {"TestEmbeddingNN": 0.06850000000000003}, "nn/test_init": {"TestNNInit": 5.604999999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.5470000000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.804, "TestLoadStateDictSwap": 0.0685}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.0305, "TestModuleHookNN": 0.09100000000000003, "TestModuleHooks": 0.11850000000000001, "TestStateDictHooks": 0.04250000000000002}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.893999999999999}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5955000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.1240000000000003}, "nn/test_pooling": {"TestAvgPool": 0.34299999999999997, "TestPoolingNN": 0.49150000000000005}, "nn/test_pruning": {"TestPruningNN": 0.14000000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.15749999999999997}, "profiler/test_memory_profiler": {"TestDataFlow": 2.3139999999999996, "TestIdentifyGradients": 0.34650000000000003, "TestMemoryProfiler": 0.3435, "TestMemoryProfilerE2E": 4.038}, "profiler/test_profiler": {"TestExecutionTrace": 8.558000000000002, "TestExperimentalUtils": 5.905999999999999, "TestProfiler": 21.758499999999998, "TestProfilerCUDA": 0.0005, "TestProfilerITT": 0.006, "TestRecordFunction": 0.042666666666666665, "TestTorchTidyProfiler": 5.653333333333332}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.4600000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.4035}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.920499999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.0915, "TestBaseDataScheduler": 0.037500000000000006, "TestBaseDataSparsifier": 0.08549999999999999, "TestBaseSparsifier": 0.032, "TestBaseStructuredSparsifier": 1.7199999999999998, "TestComposability": 2.1045, "TestCubicScheduler": 0.006, "TestFPGMPruner": 0.027000000000000003, "TestFakeSparsity": 0.0925, "TestFxComposability": 1.928, "TestNearlyDiagonalSparsifier": 0.931, "TestNormDataSparsifiers": 1.054, "TestQuantizationUtils": 0.024, "TestQuantizedSparseKernels": 0.35, "TestQuantizedSparseLayers": 0.4365, "TestSaliencyPruner": 0.032, "TestScheduler": 0.0195, "TestSparsityUtilFunctions": 0.0475, "TestWeightNormSparsifier": 0.338}, "test_autocast": {"TestAutocastCPU": 1.5594999999999999, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.008}, "test_autograd": {"TestAllowMutationOnSaved": 0.037000000000000005, "TestAutograd": 24.550500000000042, "TestAutogradComplex": 0.0075, "TestAutogradForwardMode": 0.10000000000000005, "TestAutogradForwardModeBatchedGrad": 0.022500000000000003, "TestAutogradFunctional": 13.032, "TestAutogradInferenceMode": 0.04400000000000002, "TestAutogradLogging": 0.018000000000000002, "TestMultithreadAutograd": 0.25850000000000006, "TestNestedCheckpoint": 0.5330000000000001, "TestSelectiveActivationCheckpoint": 0.021}, "test_autograd_fallback": {"TestAutogradFallback": 0.5140000000000001}, "test_bundled_inputs": {"TestBundledInputs": 1.593}, "test_comparison_utils": {"TestComparisonUtils": 0.37350000000000005}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_cpp_api_parity": {"TestCppApiParity": 4.875999999999983}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03300000000000001, "TestMAIATensor": 0.0105, "TestORTTensor": 0.0125, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03300000000000001, "TestMAIATensor": 0.013500000000000002, "TestORTTensor": 0.0115, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 60.436}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.056}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 12.055}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.085}, "test_custom_backend": {"TestCustomBackend": 0.10999999999999999}, "test_custom_ops": {"MiniOpTest": 0.8045000000000002, "MiniOpTestOther": 0.07950000000000002, "TestCustomOp": 3.6599999999999895, "TestCustomOpAPI": 0.15700000000000006, "TestCustomOperators": 0.42100000000000004, "TestGenerateOpcheckTests": 4.3095}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.06, "TestCustomPinFn": 0.0015, "TestDataLoader": 109.31400000000002, "TestDataLoaderPersistentWorkers": 145.13450000000006, "TestDatasetRandomSplit": 0.036500000000000005, "TestDictDataLoader": 0.0545, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.006, "TestSetAffinity": 0.08549999999999999, "TestStackDataset": 0.038500000000000006, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.026500000000000003}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.0015, "TestFunctionalIterDataPipe": 7.157499999999999, "TestFunctionalMapDataPipe": 0.045, "TestGraph": 0.0205, "TestIterDataPipeCountSampleYielded": 0.012, "TestIterDataPipeGraphFastForward": 0.061500000000000006, "TestIterDataPipeSingletonConstraint": 0.028500000000000004, "TestIterableDataPipeBasic": 0.0345, "TestSerialization": 8.088999999999999, "TestSharding": 0.25050000000000006, "TestStreamWrapper": 0.34600000000000003, "TestTyping": 0.0045000000000000005}, "test_decomp": {"HasDecompTest": 0.22649999999999998}, "test_deploy": {"TestFreezer": 0.343}, "test_dispatch": {"TestDispatch": 41.809, "TestPythonDispatcher": 0.07550000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 2.631, "TestFloorDiv": 0.013500000000000002, "TestGuardsExpressions": 0.019, "TestPySymInt": 1.6070000000000002, "TestSymNumberMagicMethods": 2.038499999999993}, "test_fake_tensor": {"FakeTensorConstHandling": 0.10850000000000001, "FakeTensorConverterTest": 0.031000000000000003, "FakeTensorDispatchCache": 0.09300000000000001, "FakeTensorOperatorInvariants": 0.5940000000000001, "FakeTensorPropTest": 0.095, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 1.2390000000000003, "PropagateRealTensorsFakeTensorConstHandling": 0.12550000000000003, "PropagateRealTensorsFakeTensorConverterTest": 0.032, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.248, "PropagateRealTensorsFakeTensorPropTest": 0.067, "PropagateRealTensorsFakeTensorTest": 0.3320000000000001}, "test_flop_counter": {"TestFlopCounter": 0.5955}, "test_function_schema": {"TestFunctionSchema": 0.7364999999999999}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 42.219500000000004}, "test_functional_optim": {"TestFunctionalOptimParity": 0.5005000000000002}, "test_functionalization": {"TestCrossRefFunctionalization": 3.170999999999999, "TestFunctionalization": 3.6499999999999986}, "test_futures": {"TestFuture": 1.3035}, "test_fx": {"AnnotationsTest": 0.017500000000000005, "TestCSEPass": 0.3480000000000001, "TestCommonPass": 0.07899999999999999, "TestConstFold": 0.21250000000000005, "TestConstParamShapeInControlFlow": 0.056499999999999995, "TestDCE": 0.0415, "TestFX": 4.188499999999998, "TestFXAPIBackwardCompatibility": 0.0365, "TestFunctionalTracing": 0.4580000000000003, "TestMatcher": 0.5070000000000001, "TestPassManager": 0.030000000000000006, "TestSourceMatcher": 1.5474999999999999, "TestSubgraphRewriter": 0.3850000000000001, "TestVisionTracing": 346.6825000000001, "TypeCheckerTest": 2.407499999999998}, "test_fx_experimental": {"TestFXExperimental": 20.980500000000003, "TestTranslationValidation": 0.1535}, "test_fx_passes": {"TestFXGraphPasses": 0.8315000000000002, "TestFXMatcherUtils": 0.13100000000000003}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5895000000000001}, "test_import_stats": {"TestImportTime": 5.069}, "test_itt": {"TestItt": 0.3425}, "test_jit": {"TestAliasAnalysis": 0.4665, "TestAsync": 0.8825000000000002, "TestAtenPow": 0.0335, "TestAutodiffJit": 0.40850000000000003, "TestAutodiffSubgraphSlicing": 0.9390000000000003, "TestAwait": 0.46, "TestBackends": 0.788, "TestBackendsWithCompiler": 0.17049999999999998, "TestBatchMM": 0.10350000000000001, "TestBuiltins": 0.077, "TestClassType": 3.421999999999999, "TestComplex": 1.1375000000000002, "TestCustomOperators": 0.05950000000000001, "TestDCE": 0.025, "TestDataParallel": 0.0015, "TestDataclasses": 10.017999999999999, "TestDeviceAnalysis": 4.664499999999999, "TestDict": 0.49200000000000016, "TestDtypeAnalysis": 0.5030000000000001, "TestEnum": 0.4415000000000001, "TestFreezing": 3.3860000000000006, "TestFrontend": 0.5725, "TestFrozenOptimizations": 13.988999999999997, "TestFunctionalBlocks": 0.008, "TestFunctionalToInplaceActivation": 3.6055, "TestGenerator": 0.08050000000000002, "TestGetDefaultAttr": 0.021500000000000002, "TestGraphRewritePasses": 0.065, "TestHash": 0.11, "TestHooks": 1.0095000000000003, "TestIgnorableArgs": 0.015, "TestIgnoreContextManager": 0.053000000000000005, "TestInplaceToFunctionalActivation": 3.138, "TestIsinstance": 0.30650000000000016, "TestJit": 7.520499999999993, "TestJitGeneratedModule": 12.674999999999967, "TestJitProfiler": 0.0015, "TestJitUtils": 0.026000000000000002, "TestList": 1.4820000000000007, "TestLogging": 0.05399999999999999, "TestMKLDNNReinplacing": 0.006500000000000001, "TestMisc": 0.24650000000000005, "TestMixTracingScripting": 1.4665, "TestModels": 2.3884999999999987, "TestModuleAPIs": 0.183, "TestModuleContainers": 1.5979999999999999, "TestModuleInterface": 0.6450000000000002, "TestModules": 0.016, "TestNamedTuple": 0.07900000000000001, "TestNnapiBackend": 11.299999999999997, "TestOpDecompositions": 0.019, "TestOptimizeForMobilePreserveDebugInfo": 0.202, "TestPDT": 0.38350000000000006, "TestParametrization": 0.12350000000000001, "TestPeephole": 0.6310000000000003, "TestProducerVersion": 0.0015, "TestProfiler": 0.6625, "TestPythonBindings": 0.0385, "TestPythonBuiltinOP": 0.5135000000000001, "TestPythonIr": 0.03, "TestRecursiveScript": 0.7680000000000002, "TestRemoveMutation": 0.1385, "TestSaveLoad": 0.8800000000000001, "TestSaveLoadFlatbuffer": 0.822, "TestSaveLoadForOpVersion": 1.806, "TestScript": 45.56500000000004, "TestScriptDict": 0.0335, "TestScriptList": 1.5324999999999998, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2630000000000001, "TestScriptProfile": 0.488, "TestSlice": 0.19100000000000003, "TestSparse": 0.061, "TestStringFormatting": 0.15450000000000008, "TestSymbolicShapeAnalysis": 1.926999999999999, "TestTensorBuiltins": 0.1115, "TestTensorCreationOps": 0.0715, "TestTensorMethods": 0.014000000000000002, "TestTorchbind": 0.14450000000000005, "TestTracer": 3.1824999999999957, "TestTypeSharing": 0.5300000000000001, "TestTypesAndAnnotation": 0.1835, "TestTyping": 0.6090000000000002, "TestUnion": 0.5175000000000003, "TestUnsupportedOps": 0.0315, "TestUpgraders": 0.10250000000000001, "TestWarn": 0.061, "TestWith": 0.5720000000000001}, "test_jit_autocast": {"TestAutocast": 0.1245, "TestJitTraceAutocast": 23.568999999999996}, "test_jit_disabled": {"TestJitDisabled": 0.4810000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.17250000000000001, "TestTEFuserDynamic": 128.42350000000005, "TestTEFuserStatic": 52.836000000000034}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0005, "TestEnableDisableLlgaFuser": 0.101, "TestModel": 3.220999999999999}, "test_legacy_vmap": {"TestVmapAPI": 1.165666666666665, "TestVmapAPILegacy": 1.241, "TestVmapOperators": 0.9740000000000002, "TestVmapOperatorsLegacy": 1.2170000000000003}, "test_license": {"TestLicense": 0.369}, "test_logging": {"LoggingTest": 3.5650000000000004}, "test_maskedtensor": {"TestBinary": 0.4275000000000003, "TestReductions": 0.09700000000000003, "TestUnary": 0.3700000000000003}, "test_meta": {"TestMetaConverter": 0.07000000000000003}, "test_mkl_verbose": {"TestMKLVerbose": 6.102}, "test_mkldnn_fusion": {"TestMkldnnFusion": 82.81550000000001}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.204}, "test_mobile_optimizer": {"TestOptimizer": 3.8644999999999996}, "test_model_dump": {"TestModelDump": 1.25}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.28500000000000003}, "test_module_tracker": {"TestModuleTracker": 0.34500000000000003}, "test_monitor": {"TestMonitor": 0.34950000000000003, "TestMonitorTensorboard": 0.252}, "test_multiprocessing": {"TestMultiprocessing": 68.6405}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.776, "SpawnTest": 37.84400000000001}, "test_namedtensor": {"TestNamedTensor": 0.42700000000000016}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.5149999999999997}, "test_native_functions": {"TestNativeFunctions": 0.4850000000000001}, "test_nestedtensor": {"TestNestedTensor": 0.1725000000000001}, "test_nn": {"TestAddRelu": 0.0045000000000000005, "TestConstantPadNd": 0.0045000000000000005, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.4375, "TestFusionUtils": 0.006, "TestNN": 55.36599999999996, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.0045000000000000005}, "test_openmp": {"TestOpenMP_ParallelFor": 6.71}, "test_ops": {"TestSelfKwarg": 0.0045000000000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.25350000000000006, "TestLRScheduler": 1.2845000000000006, "TestOptim": 50.24250000000001, "TestSWAUtils": 0.22699999999999998}, "test_out_dtype_op": {"TestOutDtypeOp": 0.41200000000000003}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.0315, "TestGradCheckOverride": 0.026000000000000002, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.0085, "TestIterator": 0.0015, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.003, "TestResolveName": 0.1295, "TestTorchFunctionMode": 0.044500000000000026, "TestTorchFunctionOverride": 2.524999999999891, "TestTorchFunctionWarning": 0.0195, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.051000000000000004, "ModelTest": 0.0, "TestAnalyze": 0.336, "TestDependencyAPI": 0.06350000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.018000000000000006, "TestGlobGroup": 0.026000000000000013, "TestImporter": 0.013500000000000002, "TestLoadBCPackages": 0.0895, "TestMangling": 0.020000000000000004, "TestMisc": 0.06300000000000001, "TestPackageFX": 0.08049999999999999, "TestPackageScript": 2.399499999999999, "TestRepackage": 0.014499999999999999, "TestResources": 0.014000000000000002, "TestSaveLoad": 0.044500000000000005}, "test_per_overload_api": {"TestPerOverloadAPI": 0.35550000000000004}, "test_prims": {"TestPrimsBasic": 0.018500000000000003}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.136, "TestGenericProxyTensorFake": 2.92, "TestGenericProxyTensorReal": 2.9484999999999992, "TestGenericProxyTensorSymbolic": 22.506999999999998, "TestRealProxyTensor": 0.0195, "TestSymbolicTracing": 4.378499999999999}, "test_pruning_op": {"PruningOpTest": 0.5995}, "test_public_bindings": {"TestPublicBindings": 7.749499999999999}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.3280000000000001, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.275}, "test_pytree": {"TestCxxPytree": 0.023500000000000007, "TestGenericPytree": 0.4865000000000001, "TestPythonPytree": 0.08050000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.019500000000000007, "TestAOMigrationNNQuantized": 0.07100000000000002, "TestAOMigrationQuantization": 0.025500000000000005, "TestAOMigrationQuantizationFx": 0.030500000000000006, "TestBackendConfig": 0.06150000000000003, "TestBiasCorrectionEager": 1.2025000000000001, "TestBits": 0.004, "TestComparatorOps": 1.8, "TestDeprecatedJitQuantized": 5.529999999999999, "TestDistributed": 0.032, "TestDuplicateDQPass": 3.5605, "TestDynamicQuantizedModule": 50.505, "TestDynamicQuantizedOps": 28.142500000000002, "TestEqualizeEager": 0.15, "TestEqualizeFx": 7.043999999999999, "TestFXGraphMatcher": 2.6885, "TestFXGraphMatcherModels": 11.9245, "TestFXNumericSuiteCoreAPIs": 34.7205, "TestFXNumericSuiteCoreAPIsModels": 49.075500000000005, "TestFXNumericSuiteNShadows": 44.869, "TestFakeQuantize": 0.348, "TestFakeQuantizeOps": 2.277, "TestFuseEager": 3.2609999999999997, "TestFuseFx": 2.702499999999999, "TestFusedObsFakeQuant": 0.099, "TestFusedObsFakeQuantModule": 0.26650000000000007, "TestFusionPasses": 0.026000000000000002, "TestFxDetectInputWeightEqualization": 0.21950000000000003, "TestFxDetectOutliers": 0.309, "TestFxModelReportClass": 0.6145, "TestFxModelReportDetectDynamicStatic": 0.07450000000000001, "TestFxModelReportDetector": 0.23150000000000004, "TestFxModelReportObserver": 0.244, "TestFxModelReportVisualizer": 0.2465, "TestGenerateNumericDebugHandle": 0.9470000000000001, "TestGraphUtils": 2.6069999999999998, "TestHistogramObserver": 43.437, "TestMetaDataPorting": 7.940000000000001, "TestModelNumericsEager": 1.3495000000000001, "TestNumericSuiteEager": 10.407, "TestObserver": 4.204999999999999, "TestPT2ERepresentation": 34.431999999999995, "TestPadding": 26.969499999999996, "TestQNNPackOps": 5.5735, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.2695, "TestQuantizeDynamicJitPasses": 5.8374999999999995, "TestQuantizeEagerOps": 1.9184999999999994, "TestQuantizeEagerPTQDynamic": 9.057, "TestQuantizeEagerPTQStatic": 33.8155, "TestQuantizeEagerQAT": 12.485499999999998, "TestQuantizeEagerQATNumerics": 2.399, "TestQuantizeFx": 51.41050000000001, "TestQuantizeFxModels": 7.294000000000001, "TestQuantizeFxOps": 134.7305, "TestQuantizeJit": 24.8, "TestQuantizeJitOps": 288.6790000000001, "TestQuantizeJitPasses": 6.347999999999999, "TestQuantizePT2E": 60.2815, "TestQuantizePT2EQAT": 36.59866666666666, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 384.7625, "TestQuantizePT2EQAT_ConvBn2d": 387.41949999999997, "TestQuantizePT2EX86Inductor": 100.16900000000001, "TestQuantizedConv": 61.044, "TestQuantizedEmbeddingOps": 2.2435, "TestQuantizedFunctionalOps": 4.916, "TestQuantizedLinear": 24.960499999999996, "TestQuantizedOps": 124.65650000000004, "TestQuantizedTensor": 2.2829999999999995, "TestRecordHistogramObserver": 0.0415, "TestReferenceQuantizedModule": 0.060000000000000005, "TestSerialization": 1.9415, "TestStaticQuantizedModule": 85.53900000000002, "TestSubgraphRewriter": 1.0835000000000004, "TestUtils": 0.029, "TestXNNPACKQuantizer": 50.0085, "TestXNNPACKQuantizerModels": 3.8485}, "test_schema_check": {"TestSchemaCheck": 0.14250000000000007}, "test_serialization": {"TestOldSerialization": 39.1695, "TestSerialization": 13.08100000000001, "TestSubclassSerialization": 0.03200000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.348}, "test_show_pickle": {"TestShowPickle": 0.402}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.035, "TestSparseMeta": 4.846499999999998, "TestSparseOneOff": 0.002}, "test_sparse_csr": {"TestSparseCSRSampler": 0.65}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_stateless": {"TestPythonOptimizeMode": 5.1274999999999995, "TestStatelessDeprecation": 2.362, "TestStatelessFunctionalAPI": 0.2830000000000001}, "test_subclass": {"TestSubclass": 0.6175000000000002}, "test_sympy_utils": {"TestNumbers": 0.035, "TestSingletonInt": 0.0075, "TestSympyInterp": 11.585999999999999, "TestSympySolve": 0.41000000000000003, "TestValueRanges": 7.817499999999999}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0285, "TestTensorBoardFigure": 0.0025, "TestTensorBoardNumpy": 0.0055, "TestTensorBoardPyTorchNumpy": 0.22600000000000003, "TestTensorBoardPytorchGraph": 37.73350000000001, "TestTensorBoardSummary": 0.05500000000000001, "TestTensorBoardSummaryWriter": 0.013000000000000001, "TestTensorBoardUtils": 0.38050000000000006, "TestTensorBoardWriter": 0.144, "TestTensorProtoSummary": 0.0125}, "test_tensorexpr": {"TestTensorExprFuser": 68.87000000000002}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.014499999999999999, "TestTensorExprPyBind": 1.1710000000000003}, "test_testing": {"TestAssertClose": 0.15600000000000008, "TestAssertCloseContainer": 0.008, "TestAssertCloseErrorMessage": 0.06950000000000002, "TestAssertCloseQuantized": 0.027000000000000003, "TestAssertCloseSparseBSC": 0.02, "TestAssertCloseSparseBSR": 0.02, "TestAssertCloseSparseCOO": 0.026000000000000002, "TestAssertCloseSparseCSC": 0.02, "TestAssertCloseSparseCSR": 0.0215, "TestFrameworkUtils": 16.799, "TestImports": 16.561999999999998, "TestOpInfos": 0.0045000000000000005, "TestTestParametrization": 0.039000000000000014}, "test_torch": {"TestBasicVitalSigns": 0.017, "TestTorch": 6.553999999999987}, "test_type_hints": {"TestTypeHints": 0.3775}, "test_type_info": {"TestDTypeInfo": 0.35350000000000004}, "test_typing": {"TestTyping": 103.13950000000006}, "test_utils": {"TestAssert": 0.08, "TestBottleneck": 12.2485, "TestCheckpoint": 0.10750000000000001, "TestCollectEnv": 1.2705, "TestCppExtensionUtils": 0.045, "TestDataLoaderUtils": 0.2825, "TestExtensionUtils": 0.006, "TestHipify": 0.0015, "TestHipifyTrie": 0.009000000000000001, "TestONNXUtils": 0.005, "TestRenderUtils": 0.0185, "TestStandaloneCPPJIT": 3.252, "TestTraceback": 0.012}, "test_vulkan": {"TestVulkanRewritePass": 0.003}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.025500000000000002, "WeakKeyDictionaryTestCase": 0.024, "WeakTest": 5.629499999999998}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 5.05, "TestXNNPACKRewritePass": 1.6665, "TestXNNPACKSerDes": 5.3919999999999995}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.003}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.368, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0025, "TestMisc": 0.0035, "TestPickling": 0.138, "TestPromotion": 0.0015}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 19.164000000000005, "TestEinsumPath": 0.0005, "TestMisc": 0.006500000000000001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0015, "TestHalf": 0.0005, "TestIinfo": 0.36650000000000005, "TestMisc": 0.0025, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.0075, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.009000000000000001, "TestIndexing": 0.5100000000000001, "TestMultiIndexingAutomated": 0.009000000000000001, "TestMultipleEllipsisError": 0.003, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.022500000000000006, "TestArgmax": 1.287500000000001, "TestArgmaxArgminCommon": 0.08050000000000004, "TestArgmin": 1.3875000000000008, "TestArrayAttributeDeletion": 0.008, "TestArrayConstruction": 0.048000000000000015, "TestArrayCreationCopyArgument": 0.0005, "TestArrayInterface": 0.020000000000000004, "TestAssignment": 0.012, "TestAttributes": 0.028500000000000004, "TestBinop": 0.021, "TestBool": 28.864500000000007, "TestCequenceMethods": 0.003, "TestChoose": 0.022500000000000006, "TestClip": 0.0075, "TestCompress": 0.0045000000000000005, "TestConversion": 0.041, "TestCreation": 0.0015, "TestDelMisc": 0.0015, "TestDot": 0.08550000000000003, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.019500000000000003, "TestFormat": 0.006, "TestFromBuffer": 0.014500000000000002, "TestHash": 0.21249999999999997, "TestHashing": 0.0035, "TestIO": 0.0015, "TestInner": 0.254, "TestLexsort": 0.023, "TestMatmul": 0.49850000000000017, "TestMatmulOperator": 0.35800000000000004, "TestMethods": 1.6970000000000007, "TestMinMax": 0.0075, "TestMinScalarType": 0.0075, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.014000000000000002, "TestRepeat": 0.0155, "TestResize": 0.05550000000000001, "TestRichcompareScalar": 0.0005, "TestScalarIndexing": 0.026000000000000002, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.21100000000000008, "TestStats": 0.279, "TestSubscripting": 0.002, "TestTake": 0.04150000000000001, "TestVdot": 0.045, "TestViewDtype": 0.007, "TestWarnings": 0.003, "TestWhere": 0.42600000000000005, "TestWritebackIfCopy": 0.0335}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.025500000000000002, "TestArgwhere": 0.033, "TestArrayComparisons": 0.015, "TestBaseRepr": 0.006, "TestBinaryRepr": 0.009000000000000001, "TestBoolArray": 2.635, "TestBoolCmp": 0.20350000000000001, "TestBoolScalar": 0.011, "TestBroadcast": 0.0075, "TestClip": 0.22500000000000012, "TestConvolve": 0.019500000000000003, "TestCorrelate": 0.063, "TestCreationFuncs": 1.2605000000000002, "TestCross": 0.06, "TestDtypePositional": 0.0015, "TestFloatExceptions": 0.0105, "TestFromiter": 0.0, "TestIndex": 0.009000000000000001, "TestIndices": 0.04650000000000001, "TestIsclose": 0.10200000000000001, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.0105, "TestNonarrayArgs": 0.13950000000000007, "TestNonzeroAndCountNonzero": 0.29000000000000004, "TestOuterMisc": 0.006, "TestRequire": 0.006, "TestResize": 0.36650000000000005, "TestRoll": 0.039, "TestRollaxis": 0.006, "TestSeterr": 0.009000000000000001, "TestStdVar": 0.034, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0015, "TestTensordot": 0.018000000000000002, "TestTypes": 0.018000000000000002}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.343, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.1530000000000001, "TestFromInt": 0.012, "TestFromString": 0.4705}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0015, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.0015, "TestIsInteger": 0.001}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.1375, "TestBaseMath": 11.0285, "TestBitShifts": 0.1245, "TestComplexDivision": 0.07250000000000001, "TestConversion": 0.06050000000000001, "TestHash": 0.0015, "TestModulus": 1.2095, "TestMultiply": 0.0, "TestNegative": 0.0225, "TestPower": 0.168, "TestRepr": 0.0015, "TestScalarOpsMisc": 0.05950000000000003, "TestScalarSubclassingMisc": 0.015000000000000003, "TestSubtract": 0.0225, "TestTypes": 17.9705}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.36050000000000004, "TestAtleast2d": 0.019500000000000003, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.03650000000000001, "TestConcatenate": 0.20000000000000012, "TestHstack": 0.021000000000000005, "TestStackMisc": 0.005, "TestVstack": 0.025500000000000002}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.0125, "TestFFTShift": 7.2965, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.012}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.557499999999999, "TestFFTShift": 0.34850000000000003, "TestFFTThreadSafe": 0.9415}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.36850000000000005}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.002, "TestUnique": 0.5385}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0075, "TestAmin": 0.0075, "TestAngle": 0.012, "TestAny": 0.009000000000000001, "TestAverage": 0.032, "TestBincount": 0.05549999999999999, "TestCheckFinite": 0.003, "TestCopy": 0.0105, "TestCorrCoef": 0.05, "TestCov": 0.07700000000000001, "TestCumprod": 0.039, "TestCumsum": 0.05, "TestDelete": 0.0225, "TestDiff": 0.0955, "TestDigitize": 0.021500000000000005, "TestExtins": 0.008, "TestFilterwindows": 0.7550000000000006, "TestFlip": 0.04200000000000001, "TestGradient": 0.182, "TestInsert": 0.0125, "TestInterp": 0.054500000000000035, "TestKaiser": 0.012, "TestMedian": 0.12750000000000003, "TestMeshgrid": 0.06750000000000002, "TestMsort": 0.0, "TestPercentile": 0.07950000000000004, "TestPiecewise": 0.012, "TestProd": 0.037000000000000005, "TestPtp": 0.012, "TestQuantile": 0.023500000000000007, "TestRot90": 0.40850000000000003, "TestSelect": 0.0105, "TestSinc": 0.0105, "TestSortComplex": 0.0125, "TestTrapz": 0.0075, "TestTrimZeros": 0.014000000000000002, "TestUnique": 0.006, "Test_I0": 0.021}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4980000000000001, "TestHistogramOptimBinNums": 0.041500000000000016, "TestHistogramdd": 0.1825}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0015, "TestConcatenator": 0.009000000000000001, "TestDiagIndices": 0.006, "TestDiagIndicesFrom": 0.009000000000000001, "TestFillDiagonal": 0.0315, "TestGrid": 0.0105, "TestIndexExpression": 0.013500000000000002, "TestIx_": 0.009000000000000001, "TestNdIndex": 0.0015, "TestNdenumerate": 0.0015, "TestRavelUnravelIndex": 0.36550000000000005}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.018500000000000006, "TestApplyOverAxes": 0.0025, "TestArraySplit": 0.19700000000000006, "TestColumnStack": 0.012, "TestDsplit": 0.012, "TestDstack": 0.021000000000000005, "TestExpandDims": 0.0105, "TestHsplit": 0.015000000000000003, "TestKron": 0.014999999999999998, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.012, "TestSplit": 0.0085, "TestSqueeze": 0.03250000000000001, "TestTakeAlongAxis": 0.392, "TestTile": 0.1, "TestVsplit": 0.0105}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.398, "TestFliplr": 0.006, "TestFlipud": 0.006, "TestHistogram2d": 0.04050000000000001, "TestTri": 0.10250000000000001, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.0035, "TestTriuIndicesFrom": 0.002, "TestVander": 0.0215}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0025, "TestCommonType": 0.3685, "TestImag": 0.015, "TestIscomplex": 0.007, "TestIscomplexobj": 0.0045000000000000005, "TestIsfinite": 0.0205, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.021, "TestIsneginf": 0.004, "TestIsposinf": 0.013999999999999999, "TestIsreal": 0.0105, "TestIsrealobj": 0.0015, "TestIsscalar": 0.003, "TestMintypecode": 0.0075, "TestNanToNum": 0.028500000000000004, "TestReal": 0.0165, "TestRealIfClose": 0.0055}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.21250000000000005, "TestCond": 0.261, "TestDet": 0.1865, "TestEig": 0.047000000000000014, "TestEigh": 0.03400000000000001, "TestEighCases": 0.0, "TestEigvals": 0.10900000000000001, "TestEigvalsh": 0.030000000000000006, "TestEigvalshCases": 0.0, "TestInv": 0.05950000000000001, "TestLstsq": 0.256, "TestMatrixRank": 0.4605, "TestMisc": 0.025500000000000002, "TestMisc2": 0.003, "TestMultiDot": 0.06350000000000001, "TestNormDouble": 0.9675, "TestNormInt64": 0.946, "TestNormSingle": 0.9535, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.14250000000000002, "TestPinvHermitian": 0.05449999999999999, "TestQR": 0.491, "TestSVD": 0.06100000000000001, "TestSVDHermitian": 0.11800000000000002, "TestSolve": 0.40800000000000003, "TestTensorinv": 0.021, "TestTensorsolve": 0.0045000000000000005}, "torch_np/test_basic": {"TestArrayToSequence": 0.009000000000000001, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.0045000000000000005, "TestDefaultDtype": 0.0085, "TestDivmod": 0.019500000000000003, "TestExport": 0.0, "TestMisc": 0.0015, "TestNormalizations": 0.0075, "TestOneArr": 0.3715000000000003, "TestOneArrAndAxesTuple": 0.013500000000000002, "TestOneArrAndAxis": 0.19950000000000012, "TestOneArrAndShape": 0.02200000000000001, "TestOneArrToScalar": 0.013500000000000002, "TestPythonArgsToArray": 0.0165, "TestSequenceOfArrays": 0.02400000000000001, "TestSequenceOfArraysToSingle": 0.0125, "TestShapeLikeToArray": 0.006, "TestSmokeNotImpl": 0.0015}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5045000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.43800000000000006}, "torch_np/test_function_base": {"TestAppend": 0.352}, "torch_np/test_ndarray_methods": {"TestAmax": 0.009000000000000001, "TestAmin": 0.009000000000000001, "TestArgmax": 1.4145000000000012, "TestArgmaxArgminCommon": 0.07200000000000004, "TestArgmin": 1.382000000000001, "TestContains": 0.003, "TestIndexing": 0.338, "TestIter": 0.006, "TestNoExtraMethods": 0.009000000000000001, "TestNonzero": 0.1705, "TestRavel": 0.009000000000000001, "TestReshape": 0.006, "TestTranspose": 0.011}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.025500000000000002, "TestNEP50Table": 0.0025}, "torch_np/test_random": {"TestChoice": 0.015, "TestNumpyGlobal": 0.0045000000000000005, "TestScalarReturn": 0.3885, "TestShuffle": 0.016500000000000004}, "torch_np/test_reductions": {"TestAll": 0.015, "TestAny": 0.0155, "TestFlatnonzero": 0.335, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.5689999999999378, "TestMean": 0.026000000000000002, "TestSum": 0.262}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.405, "TestIsScalar": 0.03600000000000002}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.7475000000000005, "TestNdarrayDunderVsUfunc": 0.2415000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.3835}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5455000000000001}}, "nogpu_NO_AVX2": {"backends/xeon/test_launch": {"TestTorchrun": 2.7584999999999997}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.8705}, "distributions/test_distributions": {"TestAgainstScipy": 1.6315, "TestConstraints": 0.21100000000000002, "TestDistributionShapes": 0.18650000000000008, "TestDistributions": 53.422500000000014, "TestFunctors": 0.0165, "TestJit": 29.855999999999995, "TestKL": 4.5665, "TestLazyLogitsInitialization": 0.017, "TestNumericalStability": 0.10300000000000001, "TestRsample": 1.0130000000000001, "TestValidation": 0.508}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.8280000000000001}, "dynamo/test_after_aot": {"TestAfterAot": 10.2545}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 1.1363333333333332}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 20.2345}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.0755, "AOTAutogradCacheTests": 14.792000000000002}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.224999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.0555, "TestCustomBackendAPI": 2.5549999999999997, "TestExplainWithBackend": 15.7525, "TestOptimizations": 2.9559999999999995}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 19.131999999999998}, "dynamo/test_base_output": {"TestBaseOutput": 0.0045000000000000005}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.724666666666667}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 9.366, "BytecodeTests": 0.7065}, "dynamo/test_compile": {"InPlaceCompilationTests": 11.240499999999999, "PublicTorchCompilerTests": 0.004}, "dynamo/test_comptime": {"ComptimeTests": 0.9365000000000001}, "dynamo/test_config": {"ConfigTests": 0.9305}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.22266666666666668, "CppGuardManagerFuncTorchHigherOrderOpTests": 10.969333333333337, "CppGuardManagerFunctionTests": 22.39033333333334, "CppGuardManagerHigherOrderOpTests": 6.969999999999998, "CppGuardManagerMiscTests": 42.59366666666671, "CppGuardManagerReproTests": 35.14333333333332}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.9945}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.3835}, "dynamo/test_decorators": {"DecoratorTests": 10.8875}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.0225}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 54.767999999999994, "DynamicShapesCtxManagerTests": 7.452999999999998, "DynamicShapesExportTests": 43.37249999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 139.95749999999998, "DynamicShapesFunctionTests": 101.99250000000005, "DynamicShapesHigherOrderOpTests": 24.252499999999998, "DynamicShapesMiscTests": 124.24199999999999, "DynamicShapesNNModuleTests": 10.0835, "DynamicShapesReproTests": 145.40450000000007, "DynamicShapesSubGraphTests": 13.025000000000002, "DynamicShapesTestSDPA": 0.5305}, "dynamo/test_exc": {"ExcTests": 3.0}, "dynamo/test_exceptions": {"ExceptionTests": 0.8795000000000002}, "dynamo/test_export": {"ExportTests": 23.098999999999993}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8885000000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.358}, "dynamo/test_functions": {"DefaultsTests": 1.1940000000000002, "FunctionTests": 34.87200000000007}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.777}, "dynamo/test_global": {"TestGlobals": 0.8610000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.41300000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.10900000000000001, "FuncTorchHigherOrderOpTests": 11.697999999999999, "HigherOrderOpTests": 11.670999999999996, "HigherOrderOpVmapGuardTests": 5.707000000000001}, "dynamo/test_hooks": {"HooksTests": 38.929500000000004}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 7.0575, "InlineInbuiltNNModulesExportTests": 29.108, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 11.546499999999996, "InlineInbuiltNNModulesFunctionTests": 6.860999999999992, "InlineInbuiltNNModulesHigherOrderOpTests": 10.894999999999998, "InlineInbuiltNNModulesMiscTests": 77.85900000000011, "InlineInbuiltNNModulesNNModuleTests": 6.251999999999998}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 12.7725}, "dynamo/test_interop": {"InteropTests": 0.9125}, "dynamo/test_logging": {"LoggingTests": 27.075500000000005}, "dynamo/test_minifier": {"MinifierTests": 2.1134999999999993}, "dynamo/test_misc": {"MiscTests": 82.27500000000013, "TestTracer": 0.0815}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.006}, "dynamo/test_modules": {"NNModuleTests": 4.207999999999997, "OptimizedModuleTest": 24.6295}, "dynamo/test_nops": {"NopTests": 0.48950000000000005}, "dynamo/test_optimizers": {"End2EndTests": 1.0225, "OptimizerTests": 1.6156666666666666}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.794}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.9209999999999998}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.0395}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.286}, "dynamo/test_recompiles": {"RecompileTests": 1.367}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.8420000000000001}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.7673333333333335}, "dynamo/test_repros": {"ReproTests": 56.55749999999999}, "dynamo/test_resume": {"ResumeFunctionTests": 0.7665}, "dynamo/test_sdpa": {"TestSDPA": 0.8065}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.8755000000000002}, "dynamo/test_sources": {"SourceTests": 0.8160000000000001}, "dynamo/test_structured_trace": {"StructuredTraceTest": 17.921499999999995}, "dynamo/test_subclasses": {"SubclassTests": 4.570499999999998, "TestNestedTensor": 17.5005}, "dynamo/test_subgraphs": {"SubGraphTests": 3.448999999999998}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.1595, "TraceRuleTests": 1.8019999999999998}, "dynamo/test_triton_kernels": {"KernelTests": 0.016333333333333342, "MutationTests": 0.0026666666666666666, "NoOptimizationKernelTests": 0.013000000000000005, "no_opt_test_class": 0.016666666666666673}, "dynamo/test_unspec": {"UnspecTests": 21.370999999999995}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.9955}, "dynamo/test_view": {"ViewTests": 1.017}, "export/test_converter": {"TestConverter": 7.784500000000001}, "export/test_db": {"ExampleTests": 4.785500000000001}, "export/test_experimental": {"TestExperiment": 1.484}, "export/test_export": {"TestDynamismExpression": 0.6930000000000001, "TestExport": 43.13549999999999, "TestExportCustomClass": 0.10200000000000001, "TestOneOffModelExportResult": 1.694}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.584, "NonStrictExportTestExport": 37.962}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.45966666666666667, "PreDispatchExportTestExport": 26.505333333333336}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.3645}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.6793333333333335}, "export/test_hop": {"TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.139, "TestLiftUnlift": 0.011000000000000001}, "export/test_pass_infra": {"TestPassInfra": 1.3470000000000002}, "export/test_passes": {"TestPasses": 18.898500000000002}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.2115, "RetraceExportTestExport": 66.38299999999997}, "export/test_safeguard": {"TestSafeguard": 1.0043333333333333}, "export/test_schema": {"TestSchema": 0.41600000000000004}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.22766666666666668, "SerDesExportPreDispatchTestExport": 19.577999999999992, "SerDesExportTestDynamismExpression": 0.8340000000000001, "SerDesExportTestExport": 48.47350000000001}, "export/test_serialize": {"TestDeserialize": 11.467000000000002, "TestOpVersioning": 0.004666666666666667, "TestSaveLoad": 0.4895, "TestSchemaVersioning": 0.05, "TestSerialize": 1.5985000000000005, "TestSerializeCustomClass": 0.1365}, "export/test_sparse": {"TestSparseProp": 90.0944999999999}, "export/test_tools": {"TestExportTools": 0.893}, "export/test_torchbind": {"TestCompileTorchbind": 1.5815000000000006, "TestExportTorchbind": 2.666999999999999, "TestRegisterFakeClass": 0.007}, "export/test_tree_utils": {"TestTreeUtils": 0.361}, "export/test_unflatten": {"TestUnflatten": 4.6795}, "export/test_upgrade": {"TestUpgrade": 0.44}, "export/test_verifier": {"TestVerifier": 1.4255000000000002}, "functorch/test_aotdispatch": {"TestAOTAutograd": 18.435499999999998, "TestAOTAutogradWithDynamo": 19.89949999999999, "TestAOTDispatch": 0.7295, "TestAOTExport": 3.2904999999999998, "TestAOTModuleSimplified": 0.9285000000000001, "TestPartitioning": 1.5495}, "functorch/test_control_flow": {"TestControlFlow": 1.1095000000000004, "TestControlFlowTraced": 162.66299999999993}, "functorch/test_dims": {"TestMin": 23.308500000000002, "TestMinFunctorchOnly": 22.3375}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.14000000000000004, "TestSliceArgnums": 0.019500000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.41600000000000004}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.776, "RandomOpTestCase": 0.11299999999999999, "ReduceTestCase": 0.11399999999999999, "TestMemoryEfficientOpAuthoring": 0.002}, "functorch/test_minifier": {"TestMinifier": 0.6559999999999999}, "functorch/test_parsing": {"TestAnonymousAxis": 0.3595, "TestParsedExpression": 0.0075, "TestParsingUtils": 0.006, "TestValidateRearrangeExpressions": 0.006}, "functorch/test_rearrange": {"TestRearrange": 0.42900000000000005}, "functorch/test_vmap": {"TestVmapAPI": 0.44350000000000017, "TestVmapOperators": 4.2524999999999915}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.4314999999998346}, "higher_order_ops/test_with_effects": {"TestWithEffects": 10.0585}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 14.152}, "inductor/test_binary_folding": {"FreezingCpuTests": 55.283500000000004}, "inductor/test_codecache": {"TestFxGraphCache": 58.87649999999998, "TestFxGraphCacheHashing": 1.0105, "TestUtils": 5.2865, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.3595}, "inductor/test_compile_worker": {"TestCompileWorker": 12.003}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 240.85900000000063, "TestAutogradWithCompiledAutograd": 437.7289999999999, "TestCompiledAutograd": 268.79050000000007, "TestCustomOpWithCompiledAutograd": 0.8050000000000003}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 354.28650000000073}, "inductor/test_config": {"TestInductorConfig": 9.464999999999998}, "inductor/test_control_flow": {"CondTests": 0.12150000000000001, "WhileLoopTests": 0.006}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 787.4163333333336, "TestCppWrapper": 843.7236666666666}, "inductor/test_cpu_repro": {"CPUReproTests": 991.3620000000002}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 16.72}, "inductor/test_debug_trace": {"TestDebugTrace": 5.141}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.003}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 54.140499999999996}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 28.676000000000002}, "inductor/test_flex_attention": {"TestFlexAttention": 0.020500000000000008, "TestTemplatedSDPA": 0.011333333333333336}, "inductor/test_foreach": {"ForeachTests": 26.20300000000003}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 114.7285, "SDPAPatternRewriterCpuTests": 110.727}, "inductor/test_fx_fusion": {"TestFxFusion": 0.29900000000000004}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.0225}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.3055, "TestGroupBatchFusion": 0.001, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.06500000000000002, "TestIndexingSimplification": 0.8905000000000001}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 81.28650000000002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0006666666666666666}, "inductor/test_metrics": {"TestMetrics": 0.217}, "inductor/test_minifier": {"MinifierTests": 37.069}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 71.77000000000001}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 234.595, "TestPatternMatcher": 814.084}, "inductor/test_profiler": {"DynamoProfilerTests": 0.0023333333333333335}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 25.5375}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.008}, "inductor/test_torchbind": {"TestTorchbind": 14.697000000000001}, "inductor/test_torchinductor": {"CpuTests": 2060.444999999999, "SweepInputsCpuTest": 174.9915, "TestFull": 15.758500000000002}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2174.2854999999986}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2296.0030000000006}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.8975}, "inductor/test_triton_kernels": {"KernelTests": 0.033500000000000016, "MutationTests": 0.0055, "NoOptimizationKernelTests": 0.015000000000000006, "no_opt_test_class": 0.019666666666666676}, "inductor/test_utils": {"TestUtils": 0.3595}, "lazy/test_debug_util": {"DebugUtilTest": 0.4245}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.428}, "lazy/test_generator": {"LazyGeneratorTest": 0.4325}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.8340000000000001}, "lazy/test_step_closures": {"ClosuresTest": 3.3804999999999996}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.28800000000000003, "TestLazyTensor": 0.08349999999999999}, "nn/test_convolution": {"TestConvolutionNN": 21.015}, "nn/test_dropout": {"TestDropoutNN": 0.21400000000000002}, "nn/test_embedding": {"TestEmbeddingNN": 0.07200000000000004}, "nn/test_init": {"TestNNInit": 5.859499999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.6075000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.8365, "TestLoadStateDictSwap": 0.07100000000000001}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.031, "TestModuleHookNN": 0.09250000000000003, "TestModuleHooks": 0.11600000000000002, "TestStateDictHooks": 0.046000000000000006}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.622999999999998}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5705000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.2890000000000004}, "nn/test_pooling": {"TestAvgPool": 0.3305, "TestPoolingNN": 0.504}, "nn/test_pruning": {"TestPruningNN": 0.14000000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.175}, "profiler/test_memory_profiler": {"TestDataFlow": 1.846, "TestIdentifyGradients": 0.3185, "TestMemoryProfiler": 0.38949999999999996, "TestMemoryProfilerE2E": 4.319}, "profiler/test_profiler": {"TestExecutionTrace": 8.525666666666666, "TestExperimentalUtils": 5.450499999999999, "TestProfiler": 26.296499999999995, "TestProfilerCUDA": 0.0015, "TestProfilerITT": 0.006, "TestRecordFunction": 0.042333333333333334, "TestTorchTidyProfiler": 5.7459999999999996}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.4690000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.44400000000000006}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.384499999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.10500000000000001, "TestBaseDataScheduler": 0.0475, "TestBaseDataSparsifier": 0.094, "TestBaseSparsifier": 0.035, "TestBaseStructuredSparsifier": 1.8224999999999993, "TestComposability": 2.1685, "TestCubicScheduler": 0.0075, "TestFPGMPruner": 0.027000000000000003, "TestFakeSparsity": 0.099, "TestFxComposability": 2.018, "TestNearlyDiagonalSparsifier": 0.917, "TestNormDataSparsifiers": 1.0435, "TestQuantizationUtils": 0.023, "TestQuantizedSparseKernels": 0.438, "TestQuantizedSparseLayers": 0.5525, "TestSaliencyPruner": 0.035, "TestScheduler": 0.0215, "TestSparsityUtilFunctions": 0.051000000000000004, "TestWeightNormSparsifier": 0.381}, "test_autocast": {"TestAutocastCPU": 3.2689999999999997, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.009000000000000001}, "test_autograd": {"TestAllowMutationOnSaved": 0.038000000000000006, "TestAutograd": 25.470000000000056, "TestAutogradComplex": 0.0075, "TestAutogradForwardMode": 0.10550000000000004, "TestAutogradForwardModeBatchedGrad": 0.024, "TestAutogradFunctional": 13.424499999999998, "TestAutogradInferenceMode": 0.04500000000000002, "TestAutogradLogging": 0.0205, "TestMultithreadAutograd": 0.29300000000000004, "TestNestedCheckpoint": 0.5230000000000001, "TestSelectiveActivationCheckpoint": 0.021}, "test_autograd_fallback": {"TestAutogradFallback": 0.5085000000000002}, "test_bundled_inputs": {"TestBundledInputs": 2.5069999999999992}, "test_comparison_utils": {"TestComparisonUtils": 0.371}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_cpp_api_parity": {"TestCppApiParity": 5.065499999999987}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03350000000000001, "TestMAIATensor": 0.0115, "TestORTTensor": 0.0145, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03300000000000001, "TestMAIATensor": 0.014000000000000002, "TestORTTensor": 0.0125, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 61.857}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.1480000000000001}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 12.199500000000004}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.093}, "test_custom_backend": {"TestCustomBackend": 0.11449999999999999}, "test_custom_ops": {"MiniOpTest": 0.8725000000000003, "MiniOpTestOther": 0.08400000000000002, "TestCustomOp": 3.62849999999999, "TestCustomOpAPI": 0.17050000000000007, "TestCustomOperators": 0.4325, "TestGenerateOpcheckTests": 4.5445}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.0645, "TestCustomPinFn": 0.003, "TestDataLoader": 112.2835, "TestDataLoaderPersistentWorkers": 130.41, "TestDatasetRandomSplit": 0.037500000000000006, "TestDictDataLoader": 0.0625, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.006, "TestSetAffinity": 0.091, "TestStackDataset": 0.040499999999999994, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.028500000000000004}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.003, "TestFunctionalIterDataPipe": 7.411499999999998, "TestFunctionalMapDataPipe": 0.045, "TestGraph": 0.021, "TestIterDataPipeCountSampleYielded": 0.015500000000000002, "TestIterDataPipeGraphFastForward": 0.058, "TestIterDataPipeSingletonConstraint": 0.028500000000000004, "TestIterableDataPipeBasic": 0.037500000000000006, "TestSerialization": 8.469999999999999, "TestSharding": 0.28, "TestStreamWrapper": 0.3665, "TestTyping": 0.0055}, "test_decomp": {"HasDecompTest": 0.23249999999999998}, "test_deploy": {"TestFreezer": 0.3925}, "test_dispatch": {"TestDispatch": 43.123999999999995, "TestPythonDispatcher": 0.08750000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 2.8325, "TestFloorDiv": 0.0155, "TestGuardsExpressions": 0.020999999999999998, "TestPySymInt": 1.6869999999999994, "TestSymNumberMagicMethods": 2.145499999999993}, "test_fake_tensor": {"FakeTensorConstHandling": 0.10400000000000001, "FakeTensorConverterTest": 0.034, "FakeTensorDispatchCache": 0.09300000000000001, "FakeTensorOperatorInvariants": 0.6105, "FakeTensorPropTest": 0.0985, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 1.2295000000000003, "PropagateRealTensorsFakeTensorConstHandling": 0.1855, "PropagateRealTensorsFakeTensorConverterTest": 0.03200000000000001, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.2525, "PropagateRealTensorsFakeTensorPropTest": 0.06949999999999999, "PropagateRealTensorsFakeTensorTest": 0.3325000000000001}, "test_flop_counter": {"TestFlopCounter": 0.766}, "test_function_schema": {"TestFunctionSchema": 0.9205000000000001}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 45.17400000000001}, "test_functional_optim": {"TestFunctionalOptimParity": 0.5115000000000001}, "test_functionalization": {"TestCrossRefFunctionalization": 3.6359999999999983, "TestFunctionalization": 3.8844999999999983}, "test_futures": {"TestFuture": 1.3130000000000002}, "test_fx": {"AnnotationsTest": 0.018500000000000006, "TestCSEPass": 0.3595000000000001, "TestCommonPass": 0.08299999999999999, "TestConstFold": 0.21200000000000008, "TestConstParamShapeInControlFlow": 0.056999999999999995, "TestDCE": 0.0395, "TestFX": 4.870999999999997, "TestFXAPIBackwardCompatibility": 0.04, "TestFunctionalTracing": 0.45850000000000035, "TestMatcher": 0.5295000000000001, "TestPassManager": 0.032, "TestSourceMatcher": 1.5965000000000003, "TestSubgraphRewriter": 0.38550000000000006, "TestVisionTracing": 407.25700000000006, "TypeCheckerTest": 3.331500000000001}, "test_fx_experimental": {"TestFXExperimental": 25.417, "TestTranslationValidation": 0.16349999999999998}, "test_fx_passes": {"TestFXGraphPasses": 0.8965000000000003, "TestFXMatcherUtils": 0.16050000000000003}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.6025000000000003}, "test_import_stats": {"TestImportTime": 5.2795}, "test_itt": {"TestItt": 0.371}, "test_jit": {"TestAliasAnalysis": 0.485, "TestAsync": 0.4270000000000001, "TestAtenPow": 0.0105, "TestAutodiffJit": 0.085, "TestAutodiffSubgraphSlicing": 0.3570000000000001, "TestAwait": 0.2610000000000001, "TestBackends": 0.842, "TestBackendsWithCompiler": 0.1825, "TestBatchMM": 0.0975, "TestBuiltins": 0.07250000000000001, "TestClassType": 3.5284999999999993, "TestComplex": 1.1955000000000002, "TestCustomOperators": 0.05650000000000001, "TestDCE": 0.025, "TestDataParallel": 0.003, "TestDataclasses": 5.587, "TestDeviceAnalysis": 4.929999999999999, "TestDict": 0.48250000000000015, "TestDtypeAnalysis": 0.18249999999999997, "TestEnum": 0.31600000000000006, "TestFreezing": 3.1195000000000004, "TestFrontend": 0.5615, "TestFrozenOptimizations": 15.286499999999997, "TestFunctionalBlocks": 0.009000000000000001, "TestFunctionalToInplaceActivation": 3.326, "TestGenerator": 0.08549999999999999, "TestGetDefaultAttr": 0.019500000000000003, "TestGraphRewritePasses": 0.0475, "TestHash": 0.11049999999999999, "TestHooks": 0.9780000000000003, "TestIgnorableArgs": 0.016, "TestIgnoreContextManager": 0.053000000000000005, "TestInplaceToFunctionalActivation": 3.046, "TestIsinstance": 0.2905000000000001, "TestJit": 7.205499999999987, "TestJitGeneratedModule": 14.020499999999977, "TestJitProfiler": 0.0015, "TestJitUtils": 0.027000000000000003, "TestList": 1.5340000000000005, "TestLogging": 0.05849999999999999, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.24900000000000008, "TestMixTracingScripting": 1.5795000000000001, "TestModels": 2.167499999999999, "TestModuleAPIs": 0.1925, "TestModuleContainers": 1.7160000000000002, "TestModuleInterface": 0.6935000000000002, "TestModules": 0.0175, "TestNamedTuple": 0.08900000000000001, "TestNnapiBackend": 14.231000000000002, "TestOpDecompositions": 0.0205, "TestOptimizeForMobilePreserveDebugInfo": 0.203, "TestPDT": 0.4245000000000001, "TestParametrization": 0.10900000000000001, "TestPeephole": 0.6065000000000003, "TestProducerVersion": 0.0015, "TestProfiler": 0.8015000000000001, "TestPythonBindings": 0.0465, "TestPythonBuiltinOP": 0.5255000000000001, "TestPythonIr": 0.0345, "TestRecursiveScript": 0.8190000000000002, "TestRemoveMutation": 0.164, "TestSaveLoad": 0.7915000000000001, "TestSaveLoadFlatbuffer": 0.6700000000000002, "TestSaveLoadForOpVersion": 3.2119999999999997, "TestScript": 47.06500000000002, "TestScriptDict": 0.034, "TestScriptList": 0.9075, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2695000000000001, "TestScriptProfile": 0.47050000000000003, "TestSlice": 0.20900000000000005, "TestSparse": 0.062, "TestStringFormatting": 0.15650000000000006, "TestSymbolicShapeAnalysis": 1.9279999999999986, "TestTensorBuiltins": 0.0905, "TestTensorCreationOps": 0.058499999999999996, "TestTensorMethods": 0.0155, "TestTorchbind": 0.17150000000000004, "TestTracer": 3.3384999999999945, "TestTypeSharing": 0.5575000000000001, "TestTypesAndAnnotation": 0.17200000000000004, "TestTyping": 0.5235000000000002, "TestUnion": 0.5135000000000003, "TestUnsupportedOps": 0.034, "TestUpgraders": 0.099, "TestWarn": 0.07350000000000001, "TestWith": 0.7445}, "test_jit_autocast": {"TestAutocast": 0.1355, "TestJitTraceAutocast": 23.182000000000002}, "test_jit_disabled": {"TestJitDisabled": 0.4855000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.1815, "TestTEFuserDynamic": 138.79500000000002, "TestTEFuserStatic": 55.907500000000034}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.1045, "TestModel": 3.6329999999999987}, "test_legacy_vmap": {"TestVmapAPI": 1.1879999999999984, "TestVmapAPILegacy": 1.226, "TestVmapOperators": 0.9223333333333336, "TestVmapOperatorsLegacy": 1.2235000000000003}, "test_license": {"TestLicense": 0.40549999999999997}, "test_logging": {"LoggingTest": 3.695}, "test_maskedtensor": {"TestBinary": 0.4320000000000003, "TestReductions": 0.10400000000000004, "TestUnary": 0.3715000000000003}, "test_meta": {"TestMetaConverter": 0.07100000000000004}, "test_mkl_verbose": {"TestMKLVerbose": 6.025}, "test_mkldnn_fusion": {"TestMkldnnFusion": 93.1035}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.366}, "test_mobile_optimizer": {"TestOptimizer": 4.0945}, "test_model_dump": {"TestModelDump": 1.484}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.29800000000000004}, "test_module_tracker": {"TestModuleTracker": 0.3615}, "test_monitor": {"TestMonitor": 0.376, "TestMonitorTensorboard": 0.203}, "test_multiprocessing": {"TestMultiprocessing": 68.4925}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.8470000000000001, "SpawnTest": 38.787000000000006}, "test_namedtensor": {"TestNamedTensor": 0.5375000000000002}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.404}, "test_native_functions": {"TestNativeFunctions": 0.5195000000000001}, "test_nestedtensor": {"TestNestedTensor": 0.19150000000000011}, "test_nn": {"TestAddRelu": 0.007, "TestConstantPadNd": 0.006, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.43899999999999995, "TestFusionUtils": 0.006, "TestNN": 65.52500000000009, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.005}, "test_openmp": {"TestOpenMP_ParallelFor": 6.3225}, "test_ops": {"TestSelfKwarg": 0.0045000000000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.25900000000000006, "TestLRScheduler": 1.3630000000000007, "TestOptim": 50.744, "TestSWAUtils": 0.21949999999999997}, "test_out_dtype_op": {"TestOutDtypeOp": 0.42450000000000004}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.032, "TestGradCheckOverride": 0.026999999999999996, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.0105, "TestIterator": 0.0025, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.003, "TestResolveName": 0.1335, "TestTorchFunctionMode": 0.04550000000000003, "TestTorchFunctionOverride": 2.5324999999998905, "TestTorchFunctionWarning": 0.0195, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.052500000000000005, "ModelTest": 0.0, "TestAnalyze": 0.34950000000000003, "TestDependencyAPI": 0.06600000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.021000000000000005, "TestGlobGroup": 0.027000000000000014, "TestImporter": 0.015000000000000003, "TestLoadBCPackages": 0.0945, "TestMangling": 0.022500000000000006, "TestMisc": 0.05800000000000001, "TestPackageFX": 0.0865, "TestPackageScript": 2.8969999999999994, "TestRepackage": 0.013000000000000001, "TestResources": 0.0145, "TestSaveLoad": 0.0455}, "test_per_overload_api": {"TestPerOverloadAPI": 0.3635}, "test_prims": {"TestPrimsBasic": 0.019500000000000003}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.2225, "TestGenericProxyTensorFake": 3.088, "TestGenericProxyTensorReal": 3.278999999999999, "TestGenericProxyTensorSymbolic": 22.4755, "TestRealProxyTensor": 0.0385, "TestSymbolicTracing": 4.949999999999999}, "test_pruning_op": {"PruningOpTest": 0.6015}, "test_public_bindings": {"TestPublicBindings": 7.982499999999999}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.33750000000000013, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.2745}, "test_pytree": {"TestCxxPytree": 0.02700000000000001, "TestGenericPytree": 0.5075000000000001, "TestPythonPytree": 0.08550000000000005}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.019500000000000003, "TestAOMigrationNNQuantized": 0.08100000000000002, "TestAOMigrationQuantization": 0.029500000000000005, "TestAOMigrationQuantizationFx": 0.03150000000000001, "TestBackendConfig": 0.06600000000000003, "TestBiasCorrectionEager": 3.511, "TestBits": 0.004, "TestComparatorOps": 2.0215, "TestDeprecatedJitQuantized": 5.722, "TestDistributed": 0.033, "TestDuplicateDQPass": 4.383, "TestDynamicQuantizedModule": 77.93, "TestDynamicQuantizedOps": 49.507, "TestEqualizeEager": 0.10700000000000001, "TestEqualizeFx": 7.785000000000001, "TestFXGraphMatcher": 2.8569999999999998, "TestFXGraphMatcherModels": 12.508, "TestFXNumericSuiteCoreAPIs": 35.539, "TestFXNumericSuiteCoreAPIsModels": 50.75449999999999, "TestFXNumericSuiteNShadows": 50.52950000000001, "TestFakeQuantize": 0.3675, "TestFakeQuantizeOps": 2.653999999999999, "TestFuseEager": 4.016500000000001, "TestFuseFx": 2.7159999999999997, "TestFusedObsFakeQuant": 0.10500000000000001, "TestFusedObsFakeQuantModule": 0.30300000000000005, "TestFusionPasses": 0.025, "TestFxDetectInputWeightEqualization": 0.2275, "TestFxDetectOutliers": 0.346, "TestFxModelReportClass": 0.5975, "TestFxModelReportDetectDynamicStatic": 0.07450000000000001, "TestFxModelReportDetector": 0.2375, "TestFxModelReportObserver": 0.241, "TestFxModelReportVisualizer": 0.2635, "TestGenerateNumericDebugHandle": 1.068, "TestGraphUtils": 2.9025, "TestHistogramObserver": 45.650499999999994, "TestMetaDataPorting": 8.332999999999998, "TestModelNumericsEager": 1.3800000000000001, "TestNumericSuiteEager": 12.0485, "TestObserver": 5.1095, "TestPT2ERepresentation": 35.6165, "TestPadding": 33.6485, "TestQNNPackOps": 10.925999999999998, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.7510000000000003, "TestQuantizeDynamicJitPasses": 6.6499999999999995, "TestQuantizeEagerOps": 1.9974999999999994, "TestQuantizeEagerPTQDynamic": 10.8245, "TestQuantizeEagerPTQStatic": 41.706500000000005, "TestQuantizeEagerQAT": 18.3155, "TestQuantizeEagerQATNumerics": 2.5509999999999993, "TestQuantizeFx": 57.27950000000001, "TestQuantizeFxModels": 10.102, "TestQuantizeFxOps": 168.01500000000004, "TestQuantizeJit": 26.413, "TestQuantizeJitOps": 303.59950000000003, "TestQuantizeJitPasses": 6.786, "TestQuantizePT2E": 63.921499999999995, "TestQuantizePT2EQAT": 35.461000000000006, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 400.80100000000004, "TestQuantizePT2EQAT_ConvBn2d": 406.18949999999995, "TestQuantizePT2EX86Inductor": 104.31849999999997, "TestQuantizedConv": 96.3625, "TestQuantizedEmbeddingOps": 3.0515000000000003, "TestQuantizedFunctionalOps": 9.245, "TestQuantizedLinear": 31.515499999999996, "TestQuantizedOps": 172.55550000000005, "TestQuantizedTensor": 2.3774999999999986, "TestRecordHistogramObserver": 0.043, "TestReferenceQuantizedModule": 0.058499999999999996, "TestSerialization": 2.6355000000000004, "TestStaticQuantizedModule": 128.14100000000002, "TestSubgraphRewriter": 1.145, "TestUtils": 0.024, "TestXNNPACKQuantizer": 50.60549999999999, "TestXNNPACKQuantizerModels": 4.0255}, "test_schema_check": {"TestSchemaCheck": 0.15550000000000008}, "test_serialization": {"TestOldSerialization": 59.799500000000016, "TestSerialization": 14.049500000000036, "TestSubclassSerialization": 0.03350000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.3705}, "test_show_pickle": {"TestShowPickle": 0.4}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.0385, "TestSparseMeta": 4.9595, "TestSparseOneOff": 0.003}, "test_sparse_csr": {"TestSparseCSRSampler": 0.6515}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_stateless": {"TestPythonOptimizeMode": 5.390000000000001, "TestStatelessDeprecation": 2.484, "TestStatelessFunctionalAPI": 0.2935000000000001}, "test_subclass": {"TestSubclass": 0.6255000000000002}, "test_sympy_utils": {"TestNumbers": 0.035, "TestSingletonInt": 0.0075, "TestSympyInterp": 12.010499999999997, "TestSympySolve": 0.463, "TestValueRanges": 8.128499999999995}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.028, "TestTensorBoardFigure": 0.0025, "TestTensorBoardNumpy": 0.006500000000000001, "TestTensorBoardPyTorchNumpy": 0.259, "TestTensorBoardPytorchGraph": 46.7585, "TestTensorBoardSummary": 0.06050000000000001, "TestTensorBoardSummaryWriter": 0.01, "TestTensorBoardUtils": 0.216, "TestTensorBoardWriter": 0.13899999999999998, "TestTensorProtoSummary": 0.013000000000000001}, "test_tensorexpr": {"TestTensorExprFuser": 70.93499999999997}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.012, "TestTensorExprPyBind": 1.2720000000000002}, "test_testing": {"TestAssertClose": 0.15550000000000008, "TestAssertCloseContainer": 0.009000000000000001, "TestAssertCloseErrorMessage": 0.07050000000000002, "TestAssertCloseQuantized": 0.043500000000000004, "TestAssertCloseSparseBSC": 0.021, "TestAssertCloseSparseBSR": 0.021, "TestAssertCloseSparseCOO": 0.026000000000000002, "TestAssertCloseSparseCSC": 0.021, "TestAssertCloseSparseCSR": 0.022, "TestFrameworkUtils": 17.586, "TestImports": 16.8425, "TestOpInfos": 0.006, "TestTestParametrization": 0.040500000000000015}, "test_torch": {"TestBasicVitalSigns": 0.0165, "TestTorch": 6.511499999999989}, "test_type_hints": {"TestTypeHints": 0.3595}, "test_type_info": {"TestDTypeInfo": 0.3925}, "test_typing": {"TestTyping": 107.43750000000006}, "test_utils": {"TestAssert": 0.083, "TestBottleneck": 12.703, "TestCheckpoint": 0.10700000000000001, "TestCollectEnv": 1.3275000000000001, "TestCppExtensionUtils": 0.0465, "TestDataLoaderUtils": 0.312, "TestExtensionUtils": 0.006, "TestHipify": 0.0015, "TestHipifyTrie": 0.009000000000000001, "TestONNXUtils": 0.0055, "TestRenderUtils": 0.0195, "TestStandaloneCPPJIT": 3.4130000000000003, "TestTraceback": 0.012}, "test_vulkan": {"TestVulkanRewritePass": 0.003}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.030500000000000003, "WeakKeyDictionaryTestCase": 0.033, "WeakTest": 5.885499999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 7.6965, "TestXNNPACKRewritePass": 2.2065, "TestXNNPACKSerDes": 8.4195}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.003}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.3895, "TestClassGetItem": 0.0015, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0025, "TestMisc": 0.006500000000000001, "TestPickling": 0.14300000000000002, "TestPromotion": 0.0025}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 19.5355, "TestEinsumPath": 0.0015, "TestMisc": 0.0075}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0025, "TestHalf": 0.001, "TestIinfo": 0.4075, "TestMisc": 0.0035, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.0085, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.009000000000000001, "TestIndexing": 0.5340000000000001, "TestMultiIndexingAutomated": 0.009000000000000001, "TestMultipleEllipsisError": 0.004, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.0295, "TestArgmax": 1.325500000000001, "TestArgmaxArgminCommon": 0.07500000000000004, "TestArgmin": 1.383000000000001, "TestArrayAttributeDeletion": 0.01, "TestArrayConstruction": 0.049000000000000016, "TestArrayCreationCopyArgument": 0.001, "TestArrayInterface": 0.020000000000000004, "TestAssignment": 0.012, "TestAttributes": 0.030000000000000006, "TestBinop": 0.022, "TestBool": 29.669500000000006, "TestCequenceMethods": 0.003, "TestChoose": 0.026500000000000003, "TestClip": 0.0075, "TestCompress": 0.006, "TestConversion": 0.043500000000000004, "TestCreation": 0.0015, "TestDelMisc": 0.0025, "TestDot": 0.08900000000000004, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.019500000000000003, "TestFormat": 0.006, "TestFromBuffer": 0.018000000000000006, "TestHash": 0.22199999999999998, "TestHashing": 0.004, "TestIO": 0.0015, "TestInner": 0.2645, "TestLexsort": 0.0235, "TestMatmul": 0.5290000000000001, "TestMatmulOperator": 0.36700000000000005, "TestMethods": 1.7230000000000005, "TestMinMax": 0.0075, "TestMinScalarType": 0.0075, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.001, "TestPutmask": 0.015, "TestRepeat": 0.0165, "TestResize": 0.05750000000000001, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.025500000000000002, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.199, "TestStats": 0.2835, "TestSubscripting": 0.003, "TestTake": 0.046500000000000014, "TestVdot": 0.048, "TestViewDtype": 0.007, "TestWarnings": 0.003, "TestWhere": 0.45250000000000007, "TestWritebackIfCopy": 0.0365}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.025500000000000002, "TestArgwhere": 0.035, "TestArrayComparisons": 0.021, "TestBaseRepr": 0.0145, "TestBinaryRepr": 0.020999999999999998, "TestBoolArray": 2.6189999999999998, "TestBoolCmp": 0.21000000000000002, "TestBoolScalar": 0.0105, "TestBroadcast": 0.0085, "TestClip": 0.23700000000000013, "TestConvolve": 0.020499999999999997, "TestCorrelate": 0.0475, "TestCreationFuncs": 1.326, "TestCross": 0.0615, "TestDtypePositional": 0.0015, "TestFloatExceptions": 0.011, "TestFromiter": 0.0, "TestIndex": 0.013000000000000001, "TestIndices": 0.0495, "TestIsclose": 0.10400000000000001, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.0125, "TestNonarrayArgs": 0.14300000000000007, "TestNonzeroAndCountNonzero": 0.3175000000000001, "TestOuterMisc": 0.006, "TestRequire": 0.006, "TestResize": 0.389, "TestRoll": 0.04, "TestRollaxis": 0.006, "TestSeterr": 0.009000000000000001, "TestStdVar": 0.036000000000000004, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0025, "TestTensordot": 0.018000000000000002, "TestTypes": 0.018000000000000002}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.3735, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.09600000000000007, "TestFromInt": 0.009000000000000001, "TestFromString": 0.3755}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0015, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.0015, "TestIsInteger": 0.001}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0015}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.128, "TestBaseMath": 11.5045, "TestBitShifts": 0.11699999999999999, "TestComplexDivision": 0.07650000000000001, "TestConversion": 0.0685, "TestHash": 0.0015, "TestModulus": 1.26, "TestMultiply": 0.001, "TestNegative": 0.0235, "TestPower": 0.20650000000000002, "TestRepr": 0.0025, "TestScalarOpsMisc": 0.08300000000000005, "TestScalarSubclassingMisc": 0.016000000000000004, "TestSubtract": 0.0235, "TestTypes": 18.561}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.3885, "TestAtleast2d": 0.0205, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.04050000000000002, "TestConcatenate": 0.21800000000000014, "TestHstack": 0.023, "TestStackMisc": 0.011500000000000002, "TestVstack": 0.0235}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.013499999999999998, "TestFFTShift": 8.866499999999998, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.013499999999999998}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.6014999999999997, "TestFFTShift": 0.3715, "TestFFTThreadSafe": 0.982}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.3995}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.003, "TestUnique": 0.6125}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0125, "TestAmin": 0.0115, "TestAngle": 0.013, "TestAny": 0.009000000000000001, "TestAverage": 0.0335, "TestBincount": 0.058, "TestCheckFinite": 0.003, "TestCopy": 0.0105, "TestCorrCoef": 0.07050000000000001, "TestCov": 0.07750000000000001, "TestCumprod": 0.04, "TestCumsum": 0.0655, "TestDelete": 0.0235, "TestDiff": 0.099, "TestDigitize": 0.022000000000000006, "TestExtins": 0.008, "TestFilterwindows": 0.7420000000000005, "TestFlip": 0.04100000000000001, "TestGradient": 0.17750000000000002, "TestInsert": 0.0165, "TestInterp": 0.054000000000000034, "TestKaiser": 0.013000000000000001, "TestMedian": 0.13200000000000003, "TestMeshgrid": 0.07050000000000001, "TestMsort": 0.0, "TestPercentile": 0.08050000000000004, "TestPiecewise": 0.014000000000000002, "TestProd": 0.038, "TestPtp": 0.018000000000000002, "TestQuantile": 0.023000000000000007, "TestRot90": 0.41700000000000004, "TestSelect": 0.0115, "TestSinc": 0.0105, "TestSortComplex": 0.013500000000000002, "TestTrapz": 0.0075, "TestTrimZeros": 0.016000000000000004, "TestUnique": 0.006, "Test_I0": 0.022}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.5175000000000001, "TestHistogramOptimBinNums": 0.047000000000000014, "TestHistogramdd": 0.164}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0015, "TestConcatenator": 0.009000000000000001, "TestDiagIndices": 0.007, "TestDiagIndicesFrom": 0.01, "TestFillDiagonal": 0.034499999999999996, "TestGrid": 0.012, "TestIndexExpression": 0.013500000000000002, "TestIx_": 0.009000000000000001, "TestNdIndex": 0.0015, "TestNdenumerate": 0.0015, "TestRavelUnravelIndex": 0.3885}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.020000000000000004, "TestApplyOverAxes": 0.0025, "TestArraySplit": 0.21550000000000002, "TestColumnStack": 0.013000000000000001, "TestDsplit": 0.012, "TestDstack": 0.023, "TestExpandDims": 0.011, "TestHsplit": 0.018000000000000002, "TestKron": 0.020000000000000004, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.015, "TestSplit": 0.0085, "TestSqueeze": 0.051000000000000004, "TestTakeAlongAxis": 0.433, "TestTile": 0.10700000000000001, "TestVsplit": 0.0115}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.40950000000000003, "TestFliplr": 0.007, "TestFlipud": 0.006, "TestHistogram2d": 0.04050000000000001, "TestTri": 0.10600000000000001, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.0045000000000000005, "TestTriuIndicesFrom": 0.003, "TestVander": 0.0225}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0015, "TestCommonType": 0.389, "TestImag": 0.017, "TestIscomplex": 0.0075, "TestIscomplexobj": 0.0075, "TestIsfinite": 0.021, "TestIsinf": 0.045000000000000005, "TestIsnan": 0.021, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.0115, "TestIsrealobj": 0.0025, "TestIsscalar": 0.003, "TestMintypecode": 0.029500000000000002, "TestNanToNum": 0.020000000000000004, "TestReal": 0.025500000000000002, "TestRealIfClose": 0.006}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.22100000000000003, "TestCond": 0.27149999999999996, "TestDet": 0.198, "TestEig": 0.047500000000000014, "TestEigh": 0.03300000000000001, "TestEighCases": 0.0, "TestEigvals": 0.10650000000000001, "TestEigvalsh": 0.03250000000000001, "TestEigvalshCases": 0.0, "TestInv": 0.066, "TestLstsq": 0.26149999999999995, "TestMatrixRank": 0.487, "TestMisc": 0.031, "TestMisc2": 0.004, "TestMultiDot": 0.07200000000000001, "TestNormDouble": 0.9864999999999999, "TestNormInt64": 0.99, "TestNormSingle": 1.0005000000000002, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.1405, "TestPinvHermitian": 0.05550000000000001, "TestQR": 0.5275000000000001, "TestSVD": 0.06050000000000001, "TestSVDHermitian": 0.12050000000000002, "TestSolve": 0.4325, "TestTensorinv": 0.026499999999999996, "TestTensorsolve": 0.006500000000000001}, "torch_np/test_basic": {"TestArrayToSequence": 0.011000000000000001, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.005, "TestDefaultDtype": 0.0115, "TestDivmod": 0.021500000000000002, "TestExport": 0.0005, "TestMisc": 0.0025, "TestNormalizations": 0.008, "TestOneArr": 0.38500000000000023, "TestOneArrAndAxesTuple": 0.014000000000000002, "TestOneArrAndAxis": 0.20400000000000013, "TestOneArrAndShape": 0.02300000000000001, "TestOneArrToScalar": 0.0235, "TestPythonArgsToArray": 0.0175, "TestSequenceOfArrays": 0.038500000000000006, "TestSequenceOfArraysToSingle": 0.0175, "TestShapeLikeToArray": 0.01, "TestSmokeNotImpl": 0.0015}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5170000000000001}, "torch_np/test_dtype": {"TestConvertDType": 0.43650000000000005}, "torch_np/test_function_base": {"TestAppend": 0.36}, "torch_np/test_ndarray_methods": {"TestAmax": 0.01, "TestAmin": 0.01, "TestArgmax": 1.2765000000000009, "TestArgmaxArgminCommon": 0.07500000000000004, "TestArgmin": 1.504000000000001, "TestContains": 0.003, "TestIndexing": 0.3725, "TestIter": 0.006, "TestNoExtraMethods": 0.009000000000000001, "TestNonzero": 0.1785, "TestRavel": 0.009000000000000001, "TestReshape": 0.006, "TestTranspose": 0.012}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.0215, "TestNEP50Table": 0.0025}, "torch_np/test_random": {"TestChoice": 0.0155, "TestNumpyGlobal": 0.006, "TestScalarReturn": 0.41200000000000003, "TestShuffle": 0.016500000000000004}, "torch_np/test_reductions": {"TestAll": 0.015, "TestAny": 0.0165, "TestFlatnonzero": 0.3485, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.6719999999999393, "TestMean": 0.026000000000000002, "TestSum": 0.26449999999999996}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.3985, "TestIsScalar": 0.03900000000000002}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.9180000000000006, "TestNdarrayDunderVsUfunc": 0.2465000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.41150000000000003}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5485000000000002}}}, "linux-focal-cuda12.1-py3.10-gcc9-experimental-split-build": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 2.329333333333333}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.202}, "distributions/test_distributions": {"TestAgainstScipy": 1.704, "TestConstraints": 0.239, "TestDistributionShapes": 0.18233333333333343, "TestDistributions": 48.37266666666667, "TestFunctors": 0.012666666666666666, "TestJit": 27.44066666666667, "TestKL": 3.3843333333333327, "TestLazyLogitsInitialization": 0.019, "TestNumericalStability": 0.11066666666666669, "TestRsample": 0.924, "TestValidation": 0.5736666666666667}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.576}, "dynamo/test_after_aot": {"TestAfterAot": 6.493333333333332}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 15.111666666666666}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.27, "AOTAutogradCacheTests": 19.24366666666667}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 3.5919999999999987}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.04800000000000001, "TestCustomBackendAPI": 2.3486666666666665, "TestExplainWithBackend": 11.896666666666667, "TestOptimizations": 2.3036666666666665}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 14.948666666666663}, "dynamo/test_base_output": {"TestBaseOutput": 0.006000000000000001}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 5.924666666666667, "BytecodeTests": 0.47300000000000003}, "dynamo/test_compile": {"InPlaceCompilationTests": 7.397333333333332, "PublicTorchCompilerTests": 0.0030000000000000005}, "dynamo/test_comptime": {"ComptimeTests": 0.6843333333333333}, "dynamo/test_config": {"ConfigTests": 0.6473333333333334}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.4079999999999995}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 4.189666666666667}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.3096666666666667}, "dynamo/test_decorators": {"DecoratorTests": 7.563666666666667}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0030000000000000005, "TestDeviceGuard": 0.02}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 259.86133333333333, "DynamicShapesCtxManagerTests": 8.487666666666664, "DynamicShapesExportTests": 35.659000000000006, "DynamicShapesFuncTorchHigherOrderOpTests": 103.57533333333335, "DynamicShapesFunctionTests": 87.83066666666656, "DynamicShapesHigherOrderOpTests": 21.449666666666673, "DynamicShapesMiscTests": 113.78966666666669, "DynamicShapesNNModuleTests": 8.295000000000002, "DynamicShapesReproTests": 125.75, "DynamicShapesSubGraphTests": 14.841999999999999, "DynamicShapesTestSDPA": 0.48300000000000004}, "dynamo/test_exc": {"ExcTests": 2.3480000000000003}, "dynamo/test_exceptions": {"ExceptionTests": 0.5943333333333335}, "dynamo/test_export": {"ExportTests": 20.092666666666663}, "dynamo/test_export_mutations": {"MutationExportTests": 0.6536666666666667}, "dynamo/test_frame_init": {"FrameInitTests": 0.2803333333333333}, "dynamo/test_functions": {"DefaultsTests": 1.0263333333333333, "FunctionTests": 27.881000000000068}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.5170000000000001}, "dynamo/test_global": {"TestGlobals": 0.5986666666666668}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.35000000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.09900000000000002, "FuncTorchHigherOrderOpTests": 14.555333333333335, "HigherOrderOpTests": 10.211666666666666, "HigherOrderOpVmapGuardTests": 5.105666666666667}, "dynamo/test_hooks": {"HooksTests": 32.363000000000014}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 13.27366666666667, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 14.479666666666668, "InlineInbuiltNNModulesFunctionTests": 40.61433333333338, "InlineInbuiltNNModulesHigherOrderOpTests": 9.712666666666662, "InlineInbuiltNNModulesMiscTests": 71.35900000000012, "InlineInbuiltNNModulesNNModuleTests": 5.731333333333332}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 9.430000000000001}, "dynamo/test_interop": {"InteropTests": 0.6313333333333333}, "dynamo/test_logging": {"LoggingTests": 20.117000000000004}, "dynamo/test_minifier": {"MinifierTests": 3.090666666666667}, "dynamo/test_misc": {"MiscTests": 69.94633333333347, "TestTracer": 0.07133333333333335}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.015000000000000006}, "dynamo/test_modules": {"NNModuleTests": 3.569333333333333, "OptimizedModuleTest": 22.088666666666665}, "dynamo/test_nops": {"NopTests": 0.37399999999999994}, "dynamo/test_optimizers": {"End2EndTests": 0.7523333333333334}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.5363333333333333}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.5843333333333334}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.7456666666666667}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.0750000000000002}, "dynamo/test_recompiles": {"RecompileTests": 1.0416666666666667}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.5933333333333334}, "dynamo/test_repros": {"ReproTests": 63.66433333333338}, "dynamo/test_resume": {"ResumeFunctionTests": 0.4586666666666667}, "dynamo/test_sdpa": {"TestSDPA": 0.5419999999999999}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.6286666666666668}, "dynamo/test_sources": {"SourceTests": 0.5343333333333334}, "dynamo/test_structured_trace": {"StructuredTraceTest": 15.132333333333333}, "dynamo/test_subclasses": {"SubclassTests": 5.701999999999998, "TestNestedTensor": 12.964666666666666}, "dynamo/test_subgraphs": {"SubGraphTests": 2.841999999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.12433333333333334, "TraceRuleTests": 1.47}, "dynamo/test_unspec": {"UnspecTests": 16.126666666666665}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.668}, "dynamo/test_view": {"ViewTests": 0.7526666666666667}, "export/test_converter": {"TestConverter": 9.813333333333333}, "export/test_db": {"ExampleTests": 3.975333333333333}, "export/test_experimental": {"TestExperiment": 1.2116666666666667}, "export/test_export": {"TestDynamismExpression": 0.6036666666666667, "TestExport": 32.385, "TestExportCustomClass": 0.08600000000000001, "TestOneOffModelExportResult": 1.4123333333333334}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.548, "NonStrictExportTestExport": 31.898000000000007}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.301}, "export/test_hop": {"TestHOPCUDA": 3.7000000000000006, "TestHOPGeneric": 0.0033333333333333335}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0023333333333333335, "TestLift": 0.12066666666666666}, "export/test_pass_infra": {"TestPassInfra": 1.021}, "export/test_passes": {"TestPasses": 16.767666666666667}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.133, "RetraceExportTestExport": 53.30166666666667}, "export/test_schema": {"TestSchema": 0.3113333333333333}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.6913333333333332, "SerDesExportTestExport": 35.074333333333335}, "export/test_serialize": {"TestDeserialize": 10.524000000000001, "TestSaveLoad": 0.40199999999999997, "TestSchemaVersioning": 0.04133333333333333, "TestSerialize": 1.3703333333333336, "TestSerializeCustomClass": 0.11599999999999999}, "export/test_sparse": {"TestSparseProp": 78.99733333333336}, "export/test_tools": {"TestExportTools": 0.6156666666666667}, "export/test_torchbind": {"TestCompileTorchbind": 1.679, "TestExportTorchbind": 2.599333333333333, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.2836666666666667}, "export/test_unflatten": {"TestUnflatten": 3.888333333333333}, "export/test_verifier": {"TestVerifier": 1.1123333333333332}, "functorch/test_aotdispatch": {"TestAOTAutograd": 18.111333333333334, "TestAOTAutogradWithDynamo": 19.35066666666667, "TestAOTDispatch": 0.6869999999999999, "TestAOTExport": 2.9996666666666663, "TestAOTModuleSimplified": 0.8426666666666667, "TestPartitioning": 4.7909999999999995}, "functorch/test_control_flow": {"TestControlFlow": 1.0796666666666666, "TestControlFlowTraced": 138.12466666666668}, "functorch/test_dims": {"TestMin": 15.177, "TestMinFunctorchOnly": 14.241}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.11566666666666674, "TestAutogradFunctionVmapAPICUDA": 0.024000000000000004, "TestCompileTransformsCUDA": 4.814, "TestComposabilityCUDA": 0.1953333333333334, "TestExamplesCorrectnessCUDA": 4.84, "TestFunctionalizeCUDA": 0.1416666666666667, "TestGradTransformCUDA": 1.5073333333333327, "TestHelpersCUDA": 0.014666666666666666, "TestHessianCUDA": 0.08966666666666667, "TestHigherOrderOperatorInteractionCUDA": 0.035, "TestJacCUDA": 0.9666666666666671, "TestJvpCUDA": 0.07733333333333335, "TestLinearizeCUDA": 0.31866666666666665, "TestMakeFunctional": 0.08833333333333336, "TestSliceArgnums": 0.019333333333333338, "TestVmapJvpInplaceViewCUDA": 0.02366666666666667, "TestVmapOfGradCUDA": 0.5646666666666668}, "functorch/test_logging": {"TestAOTLogging": 0.3213333333333333}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.2426666666666667, "RandomOpTestCase": 0.10866666666666668, "ReduceTestCase": 0.10399999999999998, "TestMemoryEfficientOpAuthoring": 9.383666666666665}, "functorch/test_minifier": {"TestMinifier": 0.5446666666666667}, "functorch/test_ops": {"TestOperatorsCUDA": 5841.288666666663}, "functorch/test_parsing": {"TestAnonymousAxis": 0.2976666666666667, "TestParsedExpression": 0.006000000000000001, "TestParsingUtils": 0.006666666666666667, "TestValidateRearrangeExpressions": 0.006666666666666667}, "functorch/test_rearrange": {"TestRearrange": 0.369}, "functorch/test_vmap": {"TestRandomnessCUDA": 1.1836666666666664, "TestTransformFailureCUDA": 0.3016666666666667, "TestVmapAPI": 0.4130000000000001, "TestVmapBatchedGradientCUDA": 0.2900000000000001, "TestVmapDeviceTypeCUDA": 0.028999999999999998, "TestVmapNestedTensorCUDA": 0.05266666666666669, "TestVmapOperators": 3.906333333333327, "TestVmapOperatorsOpInfoCUDA": 409.7653333333324}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.03833333333318}, "higher_order_ops/test_with_effects": {"TestWithEffects": 8.961333333333334}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 11.901666666666669}, "inductor/test_binary_folding": {"FreezingCpuTests": 50.53366666666667}, "inductor/test_codecache": {"TestFxGraphCache": 50.70366666666664, "TestFxGraphCacheHashing": 1.2859999999999998, "TestUtils": 4.838, "test_codecache": 0.002}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.294}, "inductor/test_compile_worker": {"TestCompileWorker": 15.036000000000001}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 411.69433333333404, "TestCompiledAutograd": 241.5726666666667, "TestCustomOpWithCompiledAutograd": 1.897666666666663}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 0.11233333333333338, "CompiledOptimizerTests": 333.71500000000066}, "inductor/test_config": {"TestInductorConfig": 8.268666666666666}, "inductor/test_control_flow": {"CondTests": 0.03400000000000002, "WhileLoopTests": 0.01800000000000001}, "inductor/test_cpu_repro": {"CPUReproTests": 841.8276666666666}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0030000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 15.490666666666664}, "inductor/test_debug_trace": {"TestDebugTrace": 4.469333333333334}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.004666666666666667}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 49.98466666666667}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 88.17766666666665}, "inductor/test_extension_backend": {"ExtensionBackendTests": 24.335333333333335}, "inductor/test_flex_attention": {"TestFlexAttention": 0.10200000000000008}, "inductor/test_foreach": {"ForeachTests": 23.88366666666686}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 104.58666666666666, "SDPAPatternRewriterCpuTests": 101.052}, "inductor/test_fx_fusion": {"TestFxFusion": 0.259}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.02266666666666667}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.3383333333333334, "TestGroupBatchFusion": 0.0013333333333333333, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.059666666666666666, "TestIndexingSimplification": 0.6579999999999999}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 66.065}, "inductor/test_minifier": {"MinifierTests": 32.35733333333334}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 60.15800000000001}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 127.60133333333333, "TestPatternMatcher": 601.1203333333334}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.02200000000000001}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 24.362666666666666}, "inductor/test_torchbind": {"TestTorchbind": 8.449333333333334}, "inductor/test_torchinductor": {"CpuTests": 1960.5536666666667, "SweepInputsCpuTest": 160.59366666666668, "TestFull": 13.955666666666666}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2110.500333333333}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2245.1929999999998, "TestInductorDynamicCUDA": 0.08300000000000003}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 19.466666666666615}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 2.264}, "inductor/test_triton_kernels": {"KernelTests": 0.1540000000000001, "MutationTests": 0.017000000000000008}, "inductor/test_utils": {"TestUtils": 0.28200000000000003}, "lazy/test_debug_util": {"DebugUtilTest": 0.4143333333333333}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.35633333333333334}, "lazy/test_generator": {"LazyGeneratorTest": 0.35566666666666663}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.5493333333333333}, "lazy/test_step_closures": {"ClosuresTest": 2.2866666666666666}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.22333333333333336, "TestLazyTensor": 0.08533333333333333}, "nn/test_convolution": {"TestConvolutionNN": 25.18733333333334, "TestConvolutionNNDeviceTypeCUDA": 20.92500000000008}, "nn/test_dropout": {"TestDropoutNN": 0.14433333333333334, "TestDropoutNNDeviceTypeCUDA": 1.9316666666666666}, "nn/test_embedding": {"TestEmbeddingNN": 0.18233333333333338, "TestEmbeddingNNDeviceTypeCUDA": 17.40999999999998}, "nn/test_init": {"TestNNInit": 4.474333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 0.40966666666666685}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.7513333333333333, "TestLoadStateDictSwap": 0.07600000000000001}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.02733333333333333, "TestModuleHookNN": 0.07933333333333335, "TestModuleHooks": 0.10566666666666669, "TestStateDictHooks": 0.037000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.0906666666666665, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.37366666666666665}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5796666666666668}, "nn/test_parametrization": {"TestNNParametrization": 1.0843333333333331, "TestNNParametrizationDeviceCUDA": 0.17133333333333334}, "nn/test_pooling": {"TestAvgPool": 0.4206666666666667, "TestPoolingNN": 0.8216666666666667, "TestPoolingNNDeviceTypeCUDA": 10.437333333333328}, "nn/test_pruning": {"TestPruningNN": 0.12033333333333339}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.21366666666666667}, "profiler/test_memory_profiler": {"TestDataFlow": 1.1986666666666665, "TestIdentifyGradients": 0.34166666666666673, "TestMemoryProfiler": 0.3153333333333333, "TestMemoryProfilerE2E": 3.3213333333333335}, "profiler/test_profiler": {"TestExperimentalUtils": 3.939, "TestProfiler": 19.630999999999997, "TestProfilerCUDA": 7.239666666666667, "TestProfilerITT": 0.0026666666666666666}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.41066666666666674}, "profiler/test_record_function": {"TestRecordFunction": 0.38233333333333336}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.599666666666666}, "test_ao_sparsity": {"TestActivationSparsifier": 0.07300000000000001, "TestBaseDataScheduler": 0.037, "TestBaseDataSparsifier": 0.09999999999999999, "TestBaseSparsifier": 0.029666666666666664, "TestBaseStructuredSparsifier": 4.159666666666666, "TestComposability": 2.8343333333333334, "TestCubicScheduler": 0.005666666666666667, "TestFPGMPruner": 0.09933333333333334, "TestFakeSparsity": 0.08333333333333336, "TestFxComposability": 2.389, "TestNearlyDiagonalSparsifier": 1.1463333333333334, "TestNormDataSparsifiers": 1.1689999999999998, "TestQuantizationUtils": 0.021666666666666667, "TestQuantizedSparseKernels": 0.2293333333333333, "TestQuantizedSparseLayers": 0.3746666666666667, "TestSaliencyPruner": 0.030666666666666665, "TestScheduler": 0.015, "TestSparsityUtilFunctions": 0.04566666666666667, "TestWeightNormSparsifier": 0.43933333333333335}, "test_autocast": {"TestAutocastCPU": 1.9166666666666667, "TestAutocastGPU": 0.12633333333333333, "TestTorchAutocast": 0.006000000000000001}, "test_autograd": {"TestAllowMutationOnSaved": 0.034333333333333334, "TestAutograd": 22.406999999999957, "TestAutogradComplex": 0.006333333333333334, "TestAutogradDeviceTypeCUDA": 1.4673333333333325, "TestAutogradForwardMode": 0.08333333333333337, "TestAutogradForwardModeBatchedGrad": 0.021, "TestAutogradFunctional": 15.937666666666663, "TestAutogradInferenceMode": 0.03700000000000002, "TestAutogradLogging": 0.017, "TestAutogradMultipleDispatchCUDA": 0.02466666666666667, "TestMultithreadAutograd": 0.3176666666666667, "TestNestedCheckpoint": 0.6060000000000001, "TestSelectiveActivationCheckpoint": 0.09166666666666667}, "test_autograd_fallback": {"TestAutogradFallback": 0.4476666666666668}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 170.17733333333672}, "test_bundled_inputs": {"TestBundledInputs": 1.3643333333333327}, "test_comparison_utils": {"TestComparisonUtils": 0.30033333333333334}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCUDA": 0.13433333333333333}, "test_content_store": {"TestContentStoreCUDA": 0.121}, "test_cpp_api_parity": {"TestCppApiParity": 12.148333333333284}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.22066666666666668, "TestMAIATensor": 0.008, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0036666666666666666, "TestTorchLibrary": 0.067}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.21833333333333335, "TestMAIATensor": 0.008, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.004, "TestTorchLibrary": 0.07266666666666667}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 137.01233333333332}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.005}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 9.282000000000004}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.001}, "test_cuda": {"TestBlockStateAbsorption": 6.454000000000001, "TestCuda": 84.09000000000003, "TestCudaMallocAsync": 25.706333333333337, "TestCudaOptimsCUDA": 3.7649999999999992}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 6.488, "TestCuda": 85.02466666666668, "TestCudaMallocAsync": 29.072666666666667, "TestCudaOptimsCUDA": 3.710000000000001}, "test_cuda_multigpu": {"TestCudaComm": 0.032000000000000015, "TestCudaMultiGPU": 0.6613333333333333}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.2846666666666667, "TestVisibleDeviceParses": 0.023000000000000003}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0030000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.4020000000000001, "TestEventHandler": 0.02600000000000001, "TestMessages": 0.004}, "test_cuda_trace": {"TestCudaTrace": 1.1743333333333332}, "test_custom_backend": {"TestCustomBackend": 0.11866666666666666}, "test_custom_ops": {"MiniOpTest": 0.7570000000000002, "MiniOpTestOther": 0.07666666666666667, "TestCustomOp": 2.89466666666666, "TestCustomOpAPI": 0.17933333333333337, "TestCustomOpTestingCUDA": 2.139333333333333, "TestCustomOperators": 0.44300000000000006, "TestGenerateOpcheckTests": 4.106000000000001}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 40.75, "TestConcatDataset": 0.012666666666666668, "TestConvAfterFork": 0.03, "TestCustomPinFn": 0.11233333333333334, "TestDataLoader": 92.163, "TestDataLoaderDeviceTypeCUDA": 16.03, "TestDataLoaderPersistentWorkers": 125.33433333333335, "TestDatasetRandomSplit": 0.03333333333333333, "TestDictDataLoader": 0.03833333333333334, "TestIndividualWorkerQueue": 0.0016666666666666668, "TestNamedTupleDataLoader": 0.005, "TestSetAffinity": 0.036666666666666674, "TestStackDataset": 0.038666666666666676, "TestStringDataLoader": 0.04800000000000001, "TestTensorDataset": 0.02666666666666667}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.008, "TestDataChunk": 0.007, "TestDataFramesPipes": 0.007, "TestFunctionalIterDataPipe": 5.19, "TestFunctionalMapDataPipe": 0.039, "TestGraph": 0.015000000000000001, "TestIterDataPipeCountSampleYielded": 0.011000000000000001, "TestIterDataPipeGraphFastForward": 0.05200000000000001, "TestIterDataPipeSingletonConstraint": 0.02466666666666667, "TestIterableDataPipeBasic": 0.03166666666666667, "TestSerialization": 7.509, "TestSharding": 0.1636666666666667, "TestStreamWrapper": 0.2893333333333333, "TestTyping": 0.010000000000000002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.037333333333333336, "HasDecompTest": 0.20366666666666666, "TestDecompCUDA": 13864.440666666691}, "test_deploy": {"TestFreezer": 0.3236666666666667}, "test_dispatch": {"TestDispatch": 39.26133333333334, "TestPythonDispatcher": 0.033}, "test_dlpack": {"TestTorchDlPackCUDA": 0.3876666666666669}, "test_dynamic_shapes": {"TestDimConstraints": 2.419, "TestFloorDiv": 0.014333333333333332, "TestGuardsExpressions": 0.03333333333333333, "TestPySymInt": 1.5476666666666656, "TestSymNumberMagicMethods": 2.393666666666658}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 3.4149999999999974, "TestExpandedWeightHelperFunctionCUDA": 0.14700000000000002, "TestExpandedWeightModuleCUDA": 14.652333333333333}, "test_fake_tensor": {"FakeTensorConstHandling": 0.07066666666666667, "FakeTensorConverterTest": 0.02766666666666667, "FakeTensorDispatchCache": 0.10100000000000002, "FakeTensorOpInfoTestCUDA": 0.12866666666666668, "FakeTensorOperatorInvariants": 0.5473333333333333, "FakeTensorPropTest": 0.08800000000000001, "FakeTensorSerialization": 0.006000000000000001, "FakeTensorTest": 9.912000000000004, "PropagateRealTensorsFakeTensorConstHandling": 0.11200000000000003, "PropagateRealTensorsFakeTensorConverterTest": 0.026333333333333334, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.20400000000000004, "PropagateRealTensorsFakeTensorPropTest": 0.06366666666666666, "PropagateRealTensorsFakeTensorTest": 19.01333333333334}, "test_flop_counter": {"TestFlopCounter": 0.49266666666666664}, "test_foreach": {"TestForeachCUDA": 220.6070000000113}, "test_function_schema": {"TestFunctionSchema": 0.6996666666666668}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 22.364666666666665}, "test_functional_optim": {"TestFunctionalOptimParity": 0.41133333333333333}, "test_functionalization": {"TestCrossRefFunctionalization": 2.345333333333332, "TestFunctionalization": 2.9149999999999987}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 3.3009999999999997}, "test_futures": {"TestFuture": 0.9513333333333334}, "test_fx": {"AnnotationsTest": 0.016333333333333335, "TestCSEPass": 0.3333333333333334, "TestCommonPass": 0.22833333333333342, "TestConstFold": 0.19266666666666668, "TestConstParamShapeInControlFlow": 0.05066666666666667, "TestDCE": 0.035333333333333335, "TestFX": 3.2029999999999936, "TestFXAPIBackwardCompatibility": 0.031, "TestFunctionalTracing": 0.4153333333333336, "TestMatcher": 0.40700000000000003, "TestOperatorSignaturesCUDA": 1.3676666666666664, "TestPassManager": 0.029666666666666664, "TestSourceMatcher": 1.7943333333333333, "TestSubgraphRewriter": 0.34033333333333354, "TestVisionTracing": 303.6376666666666, "TypeCheckerTest": 2.1476666666666655}, "test_fx_experimental": {"TestFXExperimental": 16.688000000000006, "TestNormalizeOperatorsCUDA": 2.0119999999999645, "TestTranslationValidation": 0.1456666666666667}, "test_fx_passes": {"TestFXGraphPasses": 0.6453333333333336, "TestFXMatcherUtils": 0.10200000000000004}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.529}, "test_import_stats": {"TestImportTime": 4.5520000000000005}, "test_indexing": {"NumpyTestsCUDA": 0.05200000000000002, "TestIndexingCUDA": 2.1496666666666617}, "test_itt": {"TestItt": 0.2816666666666667}, "test_jit": {"TestAliasAnalysis": 0.35600000000000004, "TestAsync": 0.36766666666666675, "TestAtenPow": 0.009, "TestAutodiffJit": 0.07, "TestAutodiffSubgraphSlicing": 0.3020000000000001, "TestAwait": 0.2273333333333334, "TestBackends": 0.7296666666666667, "TestBackendsWithCompiler": 0.14633333333333334, "TestBatchMM": 0.08466666666666667, "TestBuiltins": 0.059, "TestCUDA": 0.7563333333333334, "TestClassType": 2.5153333333333334, "TestComplex": 0.9156666666666667, "TestCustomOperators": 0.042666666666666686, "TestDCE": 0.018666666666666668, "TestDataParallel": 0.005, "TestDataclasses": 4.641666666666667, "TestDeviceAnalysis": 4.304666666666667, "TestDict": 0.4190000000000002, "TestDtypeAnalysis": 0.16833333333333336, "TestEnum": 0.19800000000000004, "TestFreezing": 2.266, "TestFrontend": 0.4123333333333333, "TestFrozenOptimizations": 11.589666666666668, "TestFunctionalBlocks": 0.006000000000000001, "TestFunctionalToInplaceActivation": 2.341, "TestGenerator": 0.066, "TestGetDefaultAttr": 0.015666666666666666, "TestGraphRewritePasses": 0.041666666666666664, "TestHash": 0.09133333333333334, "TestHooks": 0.6960000000000002, "TestIgnorableArgs": 0.011000000000000001, "TestIgnoreContextManager": 0.041666666666666664, "TestInplaceToFunctionalActivation": 2.382, "TestIsinstance": 0.22833333333333342, "TestJit": 5.760999999999995, "TestJitGeneratedModule": 11.66733333333336, "TestJitProfiler": 0.001, "TestJitUtils": 0.017000000000000005, "TestList": 1.2890000000000004, "TestLogging": 0.04966666666666667, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.17066666666666672, "TestMixTracingScripting": 1.0973333333333333, "TestModels": 5.940666666666666, "TestModuleAPIs": 0.12933333333333333, "TestModuleContainers": 1.2313333333333334, "TestModuleInterface": 0.6793333333333335, "TestModules": 0.013333333333333334, "TestNamedTuple": 0.067, "TestNnapiBackend": 7.327666666666666, "TestOpDecompositions": 0.016666666666666666, "TestOptimizeForMobilePreserveDebugInfo": 0.1566666666666667, "TestParametrization": 0.08733333333333333, "TestPeephole": 0.46466666666666684, "TestProducerVersion": 0.0016666666666666668, "TestProfiler": 0.5473333333333334, "TestPythonBindings": 0.02900000000000001, "TestPythonBuiltinOP": 0.4070000000000001, "TestPythonIr": 0.023000000000000003, "TestRecursiveScript": 0.6900000000000001, "TestRemoveMutation": 0.12966666666666668, "TestSaveLoad": 41.836333333333336, "TestSaveLoadFlatbuffer": 0.43300000000000005, "TestSaveLoadForOpVersion": 2.374333333333333, "TestScript": 42.0116666666667, "TestScriptDict": 0.025333333333333336, "TestScriptList": 0.8156666666666667, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.19066666666666668, "TestScriptProfile": 0.4163333333333333, "TestSlice": 0.15700000000000006, "TestSparse": 0.04466666666666667, "TestStringFormatting": 0.1166666666666667, "TestSymbolicShapeAnalysis": 1.255333333333333, "TestTensorBuiltins": 0.10033333333333334, "TestTensorCreationOps": 0.04633333333333334, "TestTensorMethods": 0.011000000000000001, "TestTorchbind": 0.1593333333333334, "TestTracer": 4.915999999999996, "TestTypeSharing": 0.4926666666666668, "TestTypesAndAnnotation": 0.124, "TestTyping": 0.3983333333333335, "TestUnion": 0.4313333333333335, "TestUnsupportedOps": 0.029666666666666664, "TestUpgraders": 0.06433333333333335, "TestWarn": 0.04833333333333334, "TestWith": 0.3363333333333334}, "test_jit_autocast": {"TestAutocast": 1.451666666666666, "TestJitTraceAutocast": 34.47833333333333}, "test_jit_disabled": {"TestJitDisabled": 0.435}, "test_jit_fuser_te": {"TestFuserCommon": 0.15566666666666665, "TestNNCOpInfoCUDA": 19.16533333333386, "TestTEFuserDynamic": 495.1836666666665, "TestTEFuserStatic": 421.0013333333331}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.07433333333333332, "TestFusionPatternCUDA": 0.004333333333333334, "TestModel": 0.005, "TestOpCUDA": 0.0023333333333333335}, "test_jiterator": {"TestPythonJiteratorCUDA": 26.319333333333265}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2249999999999994, "TestVmapBatchedGradientLegacyCUDA": 0.6240000000000002, "TestVmapOperatorsLegacy": 1.2876666666666667}, "test_license": {"TestLicense": 0.3013333333333333}, "test_linalg": {"TestLinalgCUDA": 996.1766666666643}, "test_logging": {"LoggingTest": 3.078333333333333}, "test_masked": {"TestMaskedCUDA": 38.43366666666671}, "test_maskedtensor": {"TestBasicsCUDA": 0.25, "TestBinary": 0.3986666666666669, "TestOperatorsCUDA": 7.6839999999999336, "TestReductions": 0.08233333333333336, "TestUnary": 0.2670000000000002}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.02200000000000001, "TestMatmulCudaCUDA": 48.99866666666666, "TestMixedDtypesLinearCudaCUDA": 0.001}, "test_meta": {"TestMetaCUDA": 2858.776333333252, "TestMetaConverter": 0.12166666666666666}, "test_mkl_verbose": {"TestMKLVerbose": 4.938666666666667}, "test_mkldnn_fusion": {"TestMkldnnFusion": 43.17600000000001}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.502999999999999}, "test_mobile_optimizer": {"TestOptimizer": 3.3173333333333335}, "test_model_dump": {"TestModelDump": 1.3916666666666666}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.18200000000000002}, "test_module_tracker": {"TestModuleTracker": 0.30000000000000004}, "test_modules": {"TestModuleCUDA": 957.9746666666593}, "test_monitor": {"TestMonitor": 0.31666666666666665, "TestMonitorTensorboard": 0.158}, "test_multiprocessing": {"TestMultiprocessing": 113.00799999999998}, "test_multiprocessing_spawn": {"ErrorTest": 0.0030000000000000005, "ForkTest": 0.6013333333333334, "SpawnTest": 34.910666666666664}, "test_namedtensor": {"TestNamedTensor": 0.9910000000000002}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.1486666666666667}, "test_native_functions": {"TestNativeFunctions": 0.4190000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.8393333333333338}, "test_nestedtensor": {"TestNestedTensor": 0.16766666666666677, "TestNestedTensorAutogradCUDA": 1.3716666666666668, "TestNestedTensorDeviceTypeCUDA": 1.6186666666666636, "TestNestedTensorSubclassCUDA": 1.7003333333333315}, "test_nn": {"TestAddRelu": 0.004, "TestConstantPadNd": 0.004, "TestFunctionalPickle": 0.0016666666666666668, "TestFusionEval": 0.4033333333333333, "TestFusionUtils": 0.006000000000000001, "TestNN": 66.98033333333346, "TestNNDeviceTypeCUDA": 135.18466666666447, "TestUtils": 0.004}, "test_numba_integration": {"TestNumbaIntegration": 0.16000000000000003}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.19900000000000004}, "test_openmp": {"TestOpenMP_ParallelFor": 4.756}, "test_ops": {"TestCommonCUDA": 3731.01099999999, "TestCompositeComplianceCUDA": 1276.7369999999955, "TestFakeTensorCUDA": 1096.5386666666652, "TestMathBitsCUDA": 99.94333333333333, "TestSelfKwarg": 0.02366666666666667, "TestTagsCUDA": 3.08566666666666}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1422.5746666666862}, "test_ops_gradients": {"TestBwdGradientsCUDA": 2278.344333333347}, "test_ops_jit": {"TestJitCUDA": 1334.9753333333313}, "test_optim": {"TestDifferentiableOptimizer": 0.27, "TestLRScheduler": 1.1179999999999988, "TestOptimRenewedCUDA": 301.6183333333334, "TestSWAUtils": 0.9496666666666668}, "test_out_dtype_op": {"TestOutDtypeOp": 0.4096666666666667}, "test_overrides": {"TestBroadcastAllOverride": 0.0030000000000000005, "TestDisabledTorchFunction": 0.002, "TestDisabledUserWarnings": 0.002, "TestEinsumOverride": 0.004, "TestGradCheckOverride": 0.028666666666666663, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.01, "TestIterator": 0.0023333333333333335, "TestNamedTuple": 0.0030000000000000005, "TestPickle": 0.0026666666666666666, "TestRNN": 0.0030000000000000005, "TestResolveName": 0.14133333333333334, "TestTorchFunctionMode": 0.04800000000000002, "TestTorchFunctionOverride": 3.153999999999876, "TestTorchFunctionWarning": 0.014666666666666666, "TestWrapTorchFunction": 0.002}, "test_package": {"DirectoryReaderTest": 0.046000000000000006, "ModelTest": 0.0030000000000000005, "TestAnalyze": 0.20733333333333334, "TestDependencyAPI": 0.05333333333333335, "TestDependencyHooks": 0.010333333333333333, "TestDiGraph": 0.022000000000000006, "TestGlobGroup": 0.025666666666666674, "TestImporter": 0.012000000000000002, "TestLoadBCPackages": 0.06666666666666667, "TestMangling": 0.020000000000000004, "TestMisc": 0.034333333333333334, "TestPackageFX": 0.072, "TestPackageScript": 2.1313333333333326, "TestRepackage": 0.007, "TestResources": 0.014666666666666666, "TestSaveLoad": 0.03566666666666667}, "test_per_overload_api": {"TestPerOverloadAPI": 0.30833333333333335}, "test_prims": {"TestDecompCUDA": 0.09466666666666668, "TestPrimsBasic": 0.026, "TestPrimsCUDA": 0.3503333333333334, "TestRefsCUDA": 0.012000000000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.13733333333333334, "TestGenericProxyTensorFake": 2.434333333333333, "TestGenericProxyTensorReal": 2.491, "TestGenericProxyTensorSymbolic": 23.194666666666667, "TestRealProxyTensor": 0.019, "TestSymbolicTracing": 4.746666666666666}, "test_pruning_op": {"PruningOpTest": 0.5303333333333334}, "test_public_bindings": {"TestPublicBindings": 6.2189999999999985}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.024333333333333335, "TestPythonDispatch": 0.3800000000000001, "TestPythonDispatcher": 0.007, "TestPythonRegistration": 1.6696666666666662, "TestWrapperSubclassAliasingCUDA": 0.1556666666666667}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 0.41033333333333344, "TestPythonPytree": 0.0706666666666667}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.019000000000000003, "TestAOMigrationNNQuantized": 0.04800000000000001, "TestAOMigrationQuantization": 0.022000000000000002, "TestAOMigrationQuantizationFx": 0.03466666666666667, "TestBackendConfig": 0.04533333333333334, "TestBiasCorrectionEager": 0.8626666666666667, "TestBitsCUDA": 0.03, "TestComparatorOps": 1.561, "TestDeprecatedJitQuantized": 2.9676666666666662, "TestDistributed": 0.028333333333333332, "TestDuplicateDQPass": 4.753333333333333, "TestDynamicQuantizedModule": 25.413333333333338, "TestDynamicQuantizedOps": 12.354999999999999, "TestEqualizeEager": 0.10933333333333332, "TestEqualizeFx": 4.715, "TestFXGraphMatcher": 1.5706666666666667, "TestFXGraphMatcherModels": 10.873333333333335, "TestFXNumericSuiteCoreAPIs": 34.531, "TestFXNumericSuiteCoreAPIsModels": 46.78333333333334, "TestFXNumericSuiteNShadows": 43.72866666666667, "TestFakeQuantize": 0.34366666666666673, "TestFakeQuantizeOps": 29.568, "TestFloat8DtypeCUDA": 0.30200000000000005, "TestFuseEager": 3.095333333333334, "TestFuseFx": 2.3943333333333334, "TestFusedObsFakeQuant": 0.26733333333333337, "TestFusedObsFakeQuantModule": 0.3406666666666667, "TestFusionPasses": 0.024999999999999998, "TestFxDetectInputWeightEqualization": 0.21633333333333335, "TestFxDetectOutliers": 0.2916666666666667, "TestFxModelReportClass": 0.605, "TestFxModelReportDetectDynamicStatic": 0.08133333333333333, "TestFxModelReportDetector": 0.21833333333333335, "TestFxModelReportObserver": 0.26766666666666666, "TestFxModelReportVisualizer": 0.252, "TestGenerateNumericDebugHandle": 1.0346666666666666, "TestGraphUtils": 1.4110000000000003, "TestHistogramObserver": 55.32933333333333, "TestMetaDataPorting": 9.449666666666667, "TestModelNumericsEager": 0.7080000000000001, "TestNumericSuiteEager": 9.171333333333333, "TestObserver": 5.125, "TestPT2ERepresentation": 35.894666666666666, "TestPadding": 11.285666666666666, "TestQNNPackOps": 2.932, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 1.9900000000000002, "TestQuantizeDynamicJitPasses": 4.867, "TestQuantizeEagerOps": 2.0656666666666665, "TestQuantizeEagerPTQDynamic": 8.053333333333333, "TestQuantizeEagerPTQStatic": 29.766333333333332, "TestQuantizeEagerQAT": 8.201, "TestQuantizeEagerQATNumerics": 2.1510000000000002, "TestQuantizeFx": 34.02633333333333, "TestQuantizeFxModels": 12.232666666666667, "TestQuantizeFxOps": 133.99533333333332, "TestQuantizeJit": 24.610666666666663, "TestQuantizeJitOps": 279.26866666666666, "TestQuantizeJitPasses": 5.968333333333334, "TestQuantizePT2E": 104.00866666666667, "TestQuantizePT2EQATModels": 57.12333333333333, "TestQuantizePT2EQAT_ConvBn1d": 879.3973333333333, "TestQuantizePT2EQAT_ConvBn2d": 884.9053333333333, "TestQuantizePT2EX86Inductor": 277.3316666666667, "TestQuantizedConv": 37.339000000000006, "TestQuantizedEmbeddingOps": 0.7899999999999999, "TestQuantizedFunctionalOps": 1.3576666666666668, "TestQuantizedLinear": 16.098, "TestQuantizedOps": 126.01433333333331, "TestQuantizedTensor": 3.2669999999999995, "TestRecordHistogramObserver": 0.034, "TestReferenceQuantizedModule": 0.04900000000000001, "TestSerialization": 1.484, "TestStaticQuantizedModule": 79.163, "TestSubgraphRewriter": 1.042, "TestUtils": 0.01966666666666667, "TestXNNPACKQuantizer": 61.992999999999995, "TestXNNPACKQuantizerModels": 3.9299999999999997}, "test_reductions": {"TestReductionsCUDA": 135.6783333333284}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 19.833666666666662}, "test_schema_check": {"TestSchemaCheck": 0.12666666666666673, "TestSchemaCheckModeOpInfoCUDA": 349.82999999999197}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 6.346}, "test_serialization": {"TestBothSerializationCUDA": 0.13366666666666668, "TestOldSerialization": 27.294, "TestSerialization": 11.646333333333331, "TestSubclassSerialization": 0.03366666666666667}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.28633333333333333}, "test_shape_ops": {"TestShapeOpsCUDA": 1.6366666666666656}, "test_show_pickle": {"TestShowPickle": 0.31666666666666665}, "test_sort_and_select": {"TestSortAndSelectCUDA": 6.263333333333329}, "test_sparse": {"TestSparseAnyCUDA": 810.3923333333347, "TestSparseCUDA": 47.836000000000034, "TestSparseLegacyAndDeprecation": 0.04866666666666667, "TestSparseMaskedReductionsCUDA": 5.223666666666666, "TestSparseMeta": 5.062666666666666, "TestSparseOneOff": 0.08933333333333333, "TestSparseUnaryUfuncsCUDA": 7.683999999999969}, "test_sparse_csr": {"TestSparseCSRCUDA": 214.01266666666712, "TestSparseCSRSampler": 0.8373333333333334, "TestSparseCompressedCUDA": 156.67633333333356, "TestSparseCompressedTritonKernelsCUDA": 0.010000000000000002}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005, "TestSparseSemiStructuredCUDA": 0.09700000000000007, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.028000000000000014, "TestSparseSemiStructuredCUTLASSCUDA": 0.016000000000000007, "TestSparseSemiStructuredTrainingCUDA": 0.02000000000000001}, "test_spectral_ops": {"TestFFTCUDA": 24.789333333333328}, "test_stateless": {"TestPythonOptimizeMode": 4.248666666666667, "TestStatelessDeprecation": 2.1153333333333335, "TestStatelessFunctionalAPI": 0.2683333333333334}, "test_subclass": {"TestSubclass": 0.5473333333333334}, "test_sympy_utils": {"TestNumbers": 0.06133333333333333, "TestSingletonInt": 0.006000000000000001, "TestSympyInterp": 11.304666666666668, "TestSympySolve": 0.20700000000000005, "TestValueRanges": 7.523000000000001}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.7070000000000004, "TestLikeTensorCreationCUDA": 0.011666666666666667, "TestRandomTensorCreationCUDA": 0.3860000000000001, "TestTensorCreationCUDA": 108.59533333333297}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.025333333333333333, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.0033333333333333335, "TestTensorBoardPyTorchNumpy": 0.21333333333333337, "TestTensorBoardPytorchGraph": 32.451666666666675, "TestTensorBoardSummary": 0.038666666666666676, "TestTensorBoardSummaryWriter": 0.009666666666666667, "TestTensorBoardUtils": 0.169, "TestTensorBoardWriter": 0.08166666666666667, "TestTensorProtoSummary": 0.013333333333333334}, "test_tensorexpr": {"TestTensorExprFuser": 138.08966666666666}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.012000000000000002, "TestTensorExprPyBind": 0.9423333333333335}, "test_testing": {"TestAssertClose": 0.15300000000000008, "TestAssertCloseContainer": 0.01, "TestAssertCloseErrorMessage": 0.08966666666666667, "TestAssertCloseMultiDeviceCUDA": 0.013, "TestAssertCloseQuantized": 0.017, "TestAssertCloseSparseBSC": 0.026999999999999996, "TestAssertCloseSparseBSR": 0.026999999999999996, "TestAssertCloseSparseCOO": 0.03166666666666667, "TestAssertCloseSparseCSC": 0.02666666666666667, "TestAssertCloseSparseCSR": 0.026666666666666672, "TestFrameworkUtils": 15.459333333333333, "TestImports": 14.754, "TestMakeTensorCUDA": 1.6909999999999978, "TestOpInfoSampleFunctionsCUDA": 5.195666666666589, "TestOpInfos": 0.0036666666666666666, "TestTestParametrization": 0.03700000000000002, "TestTestParametrizationDeviceTypeCUDA": 4.114333333333334, "TestTestingCUDA": 0.47133333333333344}, "test_torch": {"TestBasicVitalSigns": 0.026000000000000006, "TestDevicePrecisionCUDA": 0.09500000000000003, "TestTorch": 6.998666666666652, "TestTorchDeviceTypeCUDA": 138.8693333333333, "TestVitalSignsCudaCUDA": 0.002}, "test_transformers": {"TestAttnBiasCUDA": 2.0180000000000002, "TestSDPACUDA": 2.868999999999893, "TestSDPACudaOnlyCUDA": 155.02033333333316, "TestSDPAFailureModesCUDA": 0.0726666666666667, "TestTransformersCUDA": 5.708333333333332}, "test_type_hints": {"TestTypeHints": 0.2776666666666667}, "test_type_info": {"TestDTypeInfo": 0.2993333333333333}, "test_type_promotion": {"TestTypePromotionCUDA": 9.557}, "test_typing": {"TestTyping": 86.69233333333331}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 495.8859999999648}, "test_utils": {"TestAssert": 0.07566666666666666, "TestBottleneck": 13.526333333333334, "TestCheckpoint": 0.25133333333333335, "TestCollectEnv": 1.1926666666666668, "TestCppExtensionUtils": 0.032, "TestDataLoaderUtils": 0.19499999999999998, "TestDeviceUtilsCUDA": 17.592000000000496, "TestExtensionUtils": 0.004, "TestHipify": 0.0016666666666666668, "TestHipifyTrie": 0.008, "TestONNXUtils": 0.004, "TestRenderUtils": 0.014, "TestStandaloneCPPJIT": 2.748666666666667, "TestTraceback": 0.01}, "test_view_ops": {"TestOldViewOpsCUDA": 20.457666666666658, "TestViewOpsCUDA": 1.3833333333333329}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.018, "WeakKeyDictionaryTestCase": 0.026, "WeakTest": 4.713333333333334}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 20.871666666666666, "TestXNNPACKOps": 2.339333333333333, "TestXNNPACKRewritePass": 1.0416666666666667, "TestXNNPACKSerDes": 2.8833333333333333}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.007333333333333333}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.30300000000000005, "TestClassGetItem": 0.002, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0026666666666666666, "TestMisc": 0.004333333333333334, "TestPickling": 0.1526666666666667, "TestPromotion": 0.0030000000000000005}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 19.375666666666667, "TestEinsumPath": 0.0013333333333333333, "TestMisc": 0.006666666666666667}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0006666666666666666, "TestFinfo": 0.002, "TestHalf": 0.001, "TestIinfo": 0.30433333333333334, "TestMisc": 0.005, "TestPythonFloat": 0.001, "TestRepr": 0.0033333333333333335, "TestSingle": 0.001}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.006000000000000001, "TestBroadcastedAssignments": 0.017, "TestFancyIndexingCast": 0.004, "TestFloatNonIntegerArgument": 0.01, "TestIndexing": 0.45666666666666683, "TestMultiIndexingAutomated": 0.01, "TestMultipleEllipsisError": 0.002, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.031, "TestArgmax": 1.3829999999999998, "TestArgmaxArgminCommon": 0.21400000000000016, "TestArgmin": 1.5683333333333334, "TestArrayAttributeDeletion": 0.007333333333333333, "TestArrayConstruction": 0.05400000000000001, "TestArrayCreationCopyArgument": 0.004, "TestAssignment": 0.015666666666666672, "TestAttributes": 0.026333333333333337, "TestBinop": 0.024000000000000004, "TestBool": 33.01033333333334, "TestCequenceMethods": 0.002, "TestChoose": 0.028000000000000008, "TestClip": 0.008, "TestCompress": 0.006000000000000001, "TestConversion": 0.049666666666666665, "TestCreation": 0.004333333333333334, "TestDelMisc": 0.002, "TestDot": 0.08533333333333337, "TestDtypedescr": 0.002, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.013333333333333336, "TestFormat": 0.005666666666666667, "TestFromBuffer": 0.016333333333333335, "TestHash": 0.18833333333333332, "TestHashing": 0.0036666666666666666, "TestIO": 0.002, "TestInner": 0.2823333333333333, "TestLexsort": 0.023666666666666673, "TestMatmul": 0.5776666666666669, "TestMatmulOperator": 0.3946666666666667, "TestMethods": 1.8373333333333333, "TestMinMax": 0.006000000000000001, "TestMinScalarType": 0.007666666666666666, "TestNewaxis": 0.005, "TestPEP3118Dtype": 0.001, "TestPutmask": 0.014333333333333335, "TestRepeat": 0.018333333333333337, "TestResize": 0.062, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.027333333333333338, "TestSortFloatMisc": 0.20700000000000007, "TestStats": 0.31633333333333336, "TestSubscripting": 0.002, "TestTake": 0.04366666666666668, "TestVdot": 0.04900000000000001, "TestWarnings": 0.002, "TestWhere": 0.38766666666666666, "TestWritebackIfCopy": 0.031}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.02566666666666667, "TestArgwhere": 0.036000000000000004, "TestArrayComparisons": 0.015333333333333332, "TestBaseRepr": 0.006666666666666667, "TestBinaryRepr": 0.010333333333333333, "TestBoolArray": 2.2143333333333333, "TestBoolCmp": 0.2383333333333333, "TestBoolScalar": 0.011666666666666667, "TestBroadcast": 0.008666666666666668, "TestClip": 0.23133333333333347, "TestConvolve": 0.023333333333333334, "TestCorrelate": 0.038000000000000006, "TestCreationFuncs": 1.4666666666666668, "TestCross": 0.06766666666666667, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.011333333333333334, "TestFromiter": 0.002, "TestIndex": 0.007333333333333333, "TestIndices": 0.05000000000000001, "TestIsclose": 0.10966666666666668, "TestIsscalar": 0.0023333333333333335, "TestLikeFuncs": 0.0013333333333333333, "TestMoveaxis": 0.010333333333333333, "TestNonarrayArgs": 0.14266666666666675, "TestNonzeroAndCountNonzero": 0.3413333333333333, "TestOuterMisc": 0.006666666666666667, "TestRequire": 0.007666666666666666, "TestResize": 0.33233333333333337, "TestRoll": 0.04033333333333334, "TestRollaxis": 0.005, "TestSeterr": 0.007333333333333333, "TestStdVar": 0.035333333333333335, "TestStdVarComplex": 0.016, "TestStringFunction": 0.002, "TestTensordot": 0.017333333333333336, "TestTypes": 0.019000000000000003}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0016666666666666668, "TestCommonType": 0.29, "TestDocStrings": 0.0006666666666666666, "TestIsSubDType": 0.01, "TestScalarTypeNames": 0.03566666666666669}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.10266666666666674, "TestFromInt": 0.008333333333333333, "TestFromString": 0.284}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.005666666666666667, "TestBitCount": 0.0016666666666666668, "TestClassGetItem": 0.0033333333333333335, "TestClassGetitemMisc": 0.0030000000000000005, "TestIsInteger": 0.0033333333333333335}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.13533333333333333, "TestBaseMath": 13.328666666666669, "TestBitShifts": 0.124, "TestComplexDivision": 0.082, "TestConversion": 0.07666666666666667, "TestHash": 0.0023333333333333335, "TestModulus": 1.4036666666666668, "TestMultiply": 0.0003333333333333333, "TestNegative": 0.02466666666666667, "TestPower": 0.17966666666666667, "TestRepr": 0.0016666666666666668, "TestScalarOpsMisc": 0.06700000000000005, "TestScalarSubclassingMisc": 0.07800000000000006, "TestSubtract": 0.02466666666666667, "TestTypes": 20.929333333333332}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.307, "TestAtleast2d": 0.018000000000000002, "TestAtleast3d": 0.016, "TestBlock": 0.03333333333333335, "TestConcatenate": 0.17466666666666675, "TestHstack": 0.02066666666666667, "TestStackMisc": 0.021000000000000008, "TestVstack": 0.02466666666666667}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.014333333333333332, "TestFFTShift": 8.624, "TestIRFFTN": 0.0030000000000000005, "TestRFFTFreq": 0.014}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.458999999999999, "TestFFTShift": 0.285, "TestFFTThreadSafe": 0.6613333333333333}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.323}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.008333333333333333, "TestUnique": 0.47700000000000004}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.008, "TestAmax": 0.01, "TestAmin": 0.008, "TestAngle": 0.011666666666666667, "TestAny": 0.008, "TestAverage": 0.037666666666666675, "TestBincount": 0.051333333333333335, "TestCheckFinite": 0.0036666666666666666, "TestCopy": 0.009666666666666669, "TestCorrCoef": 0.04333333333333334, "TestCov": 0.07966666666666668, "TestCumprod": 0.042666666666666665, "TestCumsum": 0.05733333333333334, "TestDelete": 0.020000000000000004, "TestDiff": 0.10566666666666669, "TestDigitize": 0.02066666666666667, "TestExtins": 0.007, "TestFilterwindows": 0.7303333333333338, "TestFlip": 0.039666666666666676, "TestGradient": 0.18300000000000002, "TestInsert": 0.013000000000000003, "TestInterp": 0.052666666666666695, "TestKaiser": 0.013666666666666667, "TestMedian": 0.14300000000000002, "TestMeshgrid": 0.07, "TestMsort": 0.0006666666666666666, "TestPercentile": 0.18000000000000013, "TestPiecewise": 0.014333333333333335, "TestProd": 0.041666666666666664, "TestPtp": 0.015333333333333332, "TestQuantile": 0.03900000000000002, "TestRot90": 0.26, "TestSelect": 0.012333333333333333, "TestSinc": 0.011000000000000001, "TestSortComplex": 0.013333333333333334, "TestTrapz": 0.007333333333333333, "TestTrimZeros": 0.014333333333333332, "TestUnique": 0.005, "Test_I0": 0.017666666666666667}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4566666666666668, "TestHistogramOptimBinNums": 0.03500000000000001, "TestHistogramdd": 0.17833333333333334}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0016666666666666668, "TestConcatenator": 0.010666666666666666, "TestDiagIndices": 0.006666666666666667, "TestDiagIndicesFrom": 0.009666666666666669, "TestFillDiagonal": 0.031, "TestGrid": 0.014333333333333335, "TestIndexExpression": 0.012666666666666668, "TestIx_": 0.009, "TestNdIndex": 0.0016666666666666668, "TestNdenumerate": 0.002, "TestRavelUnravelIndex": 0.30933333333333335}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.017666666666666667, "TestApplyOverAxes": 0.002, "TestArraySplit": 0.2333333333333334, "TestColumnStack": 0.011666666666666667, "TestDsplit": 0.014, "TestDstack": 0.01966666666666667, "TestExpandDims": 0.009333333333333334, "TestHsplit": 0.015666666666666666, "TestKron": 0.02233333333333334, "TestMayShareMemory": 0.002, "TestPutAlongAxis": 0.012333333333333335, "TestSplit": 0.008666666666666668, "TestSqueeze": 0.038666666666666676, "TestTakeAlongAxis": 0.33, "TestTile": 0.11366666666666665, "TestVsplit": 0.011666666666666667}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.038000000000000006, "TestEye": 0.336, "TestFliplr": 0.007, "TestFlipud": 0.006666666666666667, "TestHistogram2d": 0.04566666666666667, "TestTri": 0.12766666666666668, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.0030000000000000005, "TestTriuIndicesFrom": 0.002, "TestVander": 0.023333333333333334}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0016666666666666668, "TestCommonType": 0.288, "TestImag": 0.015333333333333332, "TestIscomplex": 0.006000000000000001, "TestIscomplexobj": 0.005666666666666667, "TestIsfinite": 0.014, "TestIsinf": 0.012000000000000002, "TestIsnan": 0.014, "TestIsneginf": 0.0026666666666666666, "TestIsposinf": 0.0026666666666666666, "TestIsreal": 0.01, "TestIsrealobj": 0.002, "TestIsscalar": 0.002, "TestMintypecode": 0.005333333333333333, "TestNanToNum": 0.021000000000000005, "TestReal": 0.017333333333333336, "TestRealIfClose": 0.005666666666666667}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.17066666666666672, "TestCond": 0.2993333333333334, "TestDet": 0.205, "TestEig": 0.04400000000000001, "TestEigh": 0.03300000000000001, "TestEighCases": 0.0, "TestEigvals": 0.07333333333333335, "TestEigvalsh": 0.028000000000000008, "TestEigvalshCases": 0.0, "TestInv": 0.06633333333333334, "TestLstsq": 0.2753333333333334, "TestMatrixRank": 0.5073333333333333, "TestMisc": 0.022000000000000002, "TestMisc2": 0.004, "TestMultiDot": 0.06366666666666666, "TestNormDouble": 1.1333333333333335, "TestNormInt64": 1.117, "TestNormSingle": 1.1366666666666667, "TestNorm_NonSystematic": 0.004333333333333334, "TestPinv": 0.1456666666666667, "TestPinvHermitian": 0.043666666666666666, "TestQR": 0.6390000000000001, "TestSVD": 0.056000000000000015, "TestSVDHermitian": 0.128, "TestSolve": 0.32633333333333336, "TestTensorinv": 0.021333333333333333, "TestTensorsolve": 0.007}, "torch_np/test_basic": {"TestArrayToSequence": 0.011000000000000001, "TestCopyTo": 0.006666666666666667, "TestCtorNested": 0.004, "TestDefaultDtype": 0.008, "TestDivmod": 0.019000000000000003, "TestExport": 0.0006666666666666666, "TestMisc": 0.2713333333333333, "TestNormalizations": 0.006000000000000001, "TestOneArr": 0.43366666666666703, "TestOneArrAndAxesTuple": 0.016666666666666666, "TestOneArrAndAxis": 0.2430000000000002, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.016666666666666666, "TestPythonArgsToArray": 0.018000000000000002, "TestSequenceOfArrays": 0.02800000000000001, "TestSequenceOfArraysToSingle": 0.014, "TestShapeLikeToArray": 0.007333333333333333, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.4433333333333334}, "torch_np/test_dtype": {"TestConvertDType": 0.36533333333333334}, "torch_np/test_function_base": {"TestAppend": 0.3273333333333333}, "torch_np/test_ndarray_methods": {"TestAmax": 0.010333333333333333, "TestAmin": 0.009666666666666665, "TestArgmax": 1.3053333333333332, "TestArgmaxArgminCommon": 0.20233333333333348, "TestArgmin": 1.432666666666666, "TestContains": 0.002, "TestIndexing": 0.26933333333333337, "TestIter": 0.006000000000000001, "TestNoExtraMethods": 0.010666666666666666, "TestNonzero": 0.21966666666666668, "TestRavel": 0.008, "TestReshape": 0.005, "TestTranspose": 0.010666666666666666}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.0716666666666667, "TestNEP50Table": 0.004666666666666667}, "torch_np/test_random": {"TestChoice": 0.012999999999999998, "TestNumpyGlobal": 0.004333333333333334, "TestScalarReturn": 0.33100000000000007, "TestShuffle": 0.012666666666666668}, "torch_np/test_reductions": {"TestAll": 0.013666666666666667, "TestAny": 0.014333333333333332, "TestFlatnonzero": 0.21066666666666667, "TestGenericCumSumProd": 0.023333333333333334, "TestGenericReductions": 2.5706666666666336, "TestMean": 0.025333333333333336, "TestSum": 0.29433333333333334}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.3166666666666667, "TestIsScalar": 0.03533333333333335}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.6980000000000005, "TestNdarrayDunderVsUfunc": 0.2643333333333334, "TestUfuncDtypeKwd": 0.006333333333333334, "TestUnaryUfuncs": 0.34966666666666674}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.4483333333333335}}}, "linux-focal-cuda12.1-py3.10-gcc9-sm86": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 1.7026666666666668}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.8359999999999996}, "distributions/test_distributions": {"TestAgainstScipy": 1.045, "TestConstraints": 0.1366666666666667, "TestDistributionShapes": 0.1143333333333334, "TestDistributions": 43.73866666666667, "TestFunctors": 0.008, "TestJit": 19.559, "TestKL": 2.615333333333333, "TestLazyLogitsInitialization": 0.011666666666666667, "TestNumericalStability": 0.066, "TestRsample": 0.6216666666666667, "TestValidation": 0.3413333333333333}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 13.370000000000003}, "dynamo/test_after_aot": {"TestAfterAot": 4.798333333333333}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.9650000000000002}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 10.485000000000001}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.21566666666666667, "AOTAutogradCacheTests": 14.324333333333334}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.085}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.031, "TestCustomBackendAPI": 1.7779999999999998, "TestExplainWithBackend": 8.533000000000001, "TestOptimizations": 1.6903333333333332}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.564333333333332}, "dynamo/test_base_output": {"TestBaseOutput": 0.0016666666666666668}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 4.674333333333333}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.3340000000000005, "BytecodeTests": 0.336}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.403666666666666, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.48833333333333345}, "dynamo/test_config": {"ConfigTests": 0.47800000000000004}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.19600000000000004, "CppGuardManagerFuncTorchHigherOrderOpTests": 10.014333333333335, "CppGuardManagerFunctionTests": 23.617666666666683, "CppGuardManagerHigherOrderOpTests": 6.265666666666667, "CppGuardManagerMiscTests": 41.19266666666672, "CppGuardManagerReproTests": 36.05833333333333}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.782999999999999}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.353666666666667}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.30833333333333335}, "dynamo/test_decorators": {"DecoratorTests": 5.243666666666666}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.013333333333333334}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 30.180000000000003, "DynamicShapesCtxManagerTests": 7.773000000000001, "DynamicShapesExportTests": 24.187333333333328, "DynamicShapesFuncTorchHigherOrderOpTests": 93.58033333333334, "DynamicShapesFunctionTests": 65.98899999999999, "DynamicShapesHigherOrderOpTests": 14.619999999999997, "DynamicShapesMiscTests": 80.44433333333342, "DynamicShapesNNModuleTests": 5.589333333333333, "DynamicShapesReproTests": 94.3456666666667, "DynamicShapesSubGraphTests": 10.462666666666665, "DynamicShapesTestSDPA": 0.3213333333333333}, "dynamo/test_exc": {"ExcTests": 1.684333333333333}, "dynamo/test_exceptions": {"ExceptionTests": 0.4403333333333334}, "dynamo/test_export": {"ExportTests": 14.035333333333336}, "dynamo/test_export_mutations": {"MutationExportTests": 0.458}, "dynamo/test_frame_init": {"FrameInitTests": 0.21033333333333334}, "dynamo/test_functions": {"DefaultsTests": 0.6496666666666667, "FunctionTests": 31.70300000000002}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.1283333333333332}, "dynamo/test_global": {"TestGlobals": 0.4370000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.2316666666666667}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 5.553666666666667, "FuncTorchHigherOrderOpTests": 9.585333333333333, "HigherOrderOpTests": 6.779666666666665, "HigherOrderOpVmapGuardTests": 3.5046666666666666}, "dynamo/test_hooks": {"HooksTests": 23.842333333333343}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 8.827, "InlineInbuiltNNModulesExportTests": 13.151000000000002, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 9.214333333333334, "InlineInbuiltNNModulesFunctionTests": 20.00566666666668, "InlineInbuiltNNModulesHigherOrderOpTests": 6.429333333333332, "InlineInbuiltNNModulesMiscTests": 49.42133333333339, "InlineInbuiltNNModulesNNModuleTests": 3.814999999999999}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.580333333333333}, "dynamo/test_interop": {"InteropTests": 0.47633333333333333}, "dynamo/test_logging": {"LoggingTests": 16.740333333333336}, "dynamo/test_minifier": {"MinifierTests": 2.0356666666666667}, "dynamo/test_misc": {"MiscTests": 49.88900000000007, "TestTracer": 0.05000000000000001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.002}, "dynamo/test_modules": {"NNModuleTests": 2.375999999999999, "OptimizedModuleTest": 15.437666666666663}, "dynamo/test_nops": {"NopTests": 0.2786666666666667}, "dynamo/test_optimizers": {"End2EndTests": 0.537, "OptimizerTests": 1.4646666666666668}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.3913333333333333}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.1276666666666666}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.5386666666666667}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.7306666666666669}, "dynamo/test_recompiles": {"RecompileTests": 0.7393333333333333}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.4363333333333334}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.7450000000000001}, "dynamo/test_repros": {"ReproTests": 43.38266666666666}, "dynamo/test_resume": {"ResumeFunctionTests": 0.35200000000000004}, "dynamo/test_sdpa": {"TestSDPA": 0.391}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.46433333333333343}, "dynamo/test_sources": {"SourceTests": 0.4716666666666667}, "dynamo/test_structured_trace": {"StructuredTraceTest": 14.078000000000001}, "dynamo/test_subclasses": {"SubclassTests": 3.9839999999999987, "TestNestedTensor": 12.813666666666668}, "dynamo/test_subgraphs": {"SubGraphTests": 1.9409999999999992}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.09066666666666667, "TraceRuleTests": 1.0673333333333332}, "dynamo/test_triton_kernels": {"KernelTests": 50.16566666666665, "MutationTests": 2.5780000000000003, "NoOptimizationKernelTests": 7.606333333333333, "no_opt_test_class": 9.116}, "dynamo/test_unspec": {"UnspecTests": 10.653333333333334}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.4773333333333334}, "dynamo/test_view": {"ViewTests": 0.5369999999999999}, "export/test_converter": {"TestConverter": 6.3723333333333345}, "export/test_db": {"ExampleTests": 2.858}, "export/test_experimental": {"TestExperiment": 0.8220000000000001}, "export/test_export": {"TestDynamismExpression": 0.43766666666666665, "TestExport": 22.47533333333334, "TestExportCustomClass": 0.06033333333333333, "TestOneOffModelExportResult": 1.04}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.38199999999999995, "NonStrictExportTestExport": 22.01233333333333}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.46366666666666667, "PreDispatchExportTestExport": 23.387333333333334}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.211}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.6066666666666666}, "export/test_hop": {"TestHOPCUDA": 2.397666666666667, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.08333333333333333, "TestLiftUnlift": 0.014666666666666666}, "export/test_pass_infra": {"TestPassInfra": 0.7193333333333336}, "export/test_passes": {"TestPasses": 10.959333333333333}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.805, "RetraceExportTestExport": 35.13299999999999}, "export/test_safeguard": {"TestSafeguard": 0.8446666666666668}, "export/test_schema": {"TestSchema": 0.23900000000000002}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.21833333333333335, "SerDesExportPreDispatchTestExport": 17.980666666666654, "SerDesExportTestDynamismExpression": 0.49433333333333335, "SerDesExportTestExport": 24.293999999999997}, "export/test_serialize": {"TestDeserialize": 7.223, "TestOpVersioning": 0.0036666666666666666, "TestSaveLoad": 0.2803333333333334, "TestSchemaVersioning": 0.029, "TestSerialize": 0.9666666666666668, "TestSerializeCustomClass": 0.081}, "export/test_sparse": {"TestSparseProp": 54.36533333333322}, "export/test_tools": {"TestExportTools": 0.45933333333333337}, "export/test_torchbind": {"TestCompileTorchbind": 1.1020000000000003, "TestExportTorchbind": 1.6266666666666658, "TestRegisterFakeClass": 0.0030000000000000005}, "export/test_tree_utils": {"TestTreeUtils": 0.209}, "export/test_unflatten": {"TestUnflatten": 2.817666666666667}, "export/test_upgrade": {"TestUpgrade": 0.3746666666666667}, "export/test_verifier": {"TestVerifier": 0.7516666666666666}, "functorch/test_ac": {"MemoryBudgetTest": 12.15}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.496, "TestAOTAutogradWithDynamo": 12.483333333333334, "TestAOTDispatch": 0.4296666666666667, "TestAOTExport": 1.9993333333333332, "TestAOTModuleSimplified": 0.5313333333333333, "TestPartitioning": 2.9086666666666665}, "functorch/test_control_flow": {"TestControlFlow": 0.7236666666666669, "TestControlFlowTraced": 98.49300000000001}, "functorch/test_dims": {"TestMin": 13.686333333333335, "TestMinFunctorchOnly": 13.307666666666668}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.08866666666666671, "TestAutogradFunctionVmapAPICUDA": 0.018666666666666668, "TestCompileTransformsCUDA": 4.314333333333334, "TestComposabilityCUDA": 0.1363333333333334, "TestExamplesCorrectnessCUDA": 2.197666666666666, "TestFunctionalizeCUDA": 0.09900000000000003, "TestGradTransformCUDA": 0.9550000000000002, "TestHelpersCUDA": 0.012333333333333335, "TestHessianCUDA": 0.06233333333333333, "TestHigherOrderOperatorInteractionCUDA": 0.024000000000000004, "TestJacCUDA": 0.6570000000000004, "TestJvpCUDA": 0.05266666666666669, "TestLinearizeCUDA": 0.22366666666666665, "TestMakeFunctional": 0.07700000000000001, "TestSliceArgnums": 0.015000000000000001, "TestVmapJvpInplaceViewCUDA": 0.015333333333333332, "TestVmapOfGradCUDA": 0.6703333333333333}, "functorch/test_logging": {"TestAOTLogging": 0.25366666666666665}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.17800000000000002, "RandomOpTestCase": 0.07233333333333332, "ReduceTestCase": 0.06533333333333334, "TestMemoryEfficientOpAuthoring": 7.252999999999999}, "functorch/test_minifier": {"TestMinifier": 0.39133333333333337}, "functorch/test_ops": {"TestOperatorsCUDA": 3917.2216666666386}, "functorch/test_parsing": {"TestAnonymousAxis": 0.216, "TestParsedExpression": 0.0036666666666666666, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.2416666666666667}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.775333333333334, "TestTransformFailureCUDA": 0.245, "TestVmapAPI": 0.3386666666666667, "TestVmapBatchedGradientCUDA": 0.1980000000000001, "TestVmapDeviceTypeCUDA": 0.020000000000000004, "TestVmapNestedTensorCUDA": 0.03833333333333334, "TestVmapOperators": 2.589999999999995, "TestVmapOperatorsOpInfoCUDA": 270.37199999999933}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 1.9756666666665625}, "higher_order_ops/test_with_effects": {"TestWithEffects": 6.456333333333333}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 674.4186666666665, "AOTInductorTestABICompatibleCpuWithStackAllocation": 466.85600000000005, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 205.7103333333333, "AOTInductorTestABICompatibleCuda": 1288.9560000000001, "AOTInductorTestNonABICompatibleCpu": 1406.2639999999994, "AOTInductorTestNonABICompatibleCuda": 2139.801}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.716, "BenchmarkFusionCudaTest": 75.94566666666667, "BenchmarkMultiTemplateFusionCudaTest": 13.516333333333334}, "inductor/test_binary_folding": {"FreezingCpuTests": 37.214, "FreezingCudaTests": 2.2615, "FreezingGpuTests": 2.5593333333333335}, "inductor/test_codecache": {"TestFxGraphCache": 121.296, "TestFxGraphCacheHashing": 0.759, "TestUtils": 3.3573333333333335, "test_codecache": 2.4493333333333336}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.19933333333333333}, "inductor/test_compile_worker": {"TestCompileWorker": 8.744333333333334}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 223.49600000000058, "TestAutogradWithCompiledAutograd": 293.3863333333339, "TestCompiledAutograd": 143.8323333333333, "TestCustomOpWithCompiledAutograd": 1.911333333333329}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 657.0983333333332, "CompiledOptimizerTests": 1329.023}, "inductor/test_config": {"TestInductorConfig": 5.183000000000001}, "inductor/test_control_flow": {"CondTests": 87.46500000000002, "WhileLoopTests": 36.123999999999995}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.1663333333333337}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 791.5023333333334, "DynamicShapesCudaWrapperCudaTests": 819.991, "TestCppWrapper": 827.9209999999999, "TestCudaWrapper": 737.8870000000001}, "inductor/test_cpu_repro": {"CPUReproTests": 600.3626666666668}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1020.9853333333334, "TestCudaWrapper": 983.6626666666667}, "inductor/test_cuda_repro": {"CudaReproTests": 92.17333333333333}, "inductor/test_cudacodecache": {"TestCUDACodeCache": 1.7060000000000002}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 70.20233333333333}, "inductor/test_custom_lowering": {"TestCustomLowering": 2.9033333333333338}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.291333333333334}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 82.967}, "inductor/test_debug_trace": {"TestDebugTrace": 12.658666666666667}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 30.101000000000003}, "inductor/test_dependencies": {"TestDependencies": 0.18766666666666668}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.060333333333325}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 60.612, "EfficientConvBNEvalCudaTests": 38.458333333333336}, "inductor/test_extension_backend": {"ExtensionBackendTests": 17.320333333333334}, "inductor/test_flex_attention": {"TestFlexAttention": 624.2253333333332, "TestTemplatedSDPA": 247.38133333333334}, "inductor/test_foreach": {"ForeachTests": 283.99166666666673}, "inductor/test_fp8": {"TestFP8Types": 0.009666666666666669}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 73.30266666666667, "SDPAPatternRewriterCpuTests": 69.379, "SDPAPatternRewriterCudaDynamicTests": 40.69733333333334, "SDPAPatternRewriterCudaTests": 29.578999999999997}, "inductor/test_fx_fusion": {"TestFxFusion": 0.17833333333333332}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.012000000000000002}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.02366666666666667, "TestGroupBatchFusion": 99.84400000000001, "TestPostGradBatchLinearFusion": 1.9286666666666668}, "inductor/test_indexing": {"ExprPrinterTests": 0.04200000000000001, "TestIndexingSimplification": 2.2763333333333335}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 48.673, "FreezingCudaTests": 31.125999999999994}, "inductor/test_inductor_utils": {"TestBench": 0.4286666666666667}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 5.446666666666666}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 151.855}, "inductor/test_layout_optim": {"TestLayoutOptim": 10.937666666666667}, "inductor/test_loop_ordering": {"LoopOrderingTest": 3.6346666666666665}, "inductor/test_max_autotune": {"TestMaxAutotune": 289.0729999999999, "TestTuningProcess": 10.387}, "inductor/test_memory_planning": {"TestMemoryPlanning": 28.024999999999995}, "inductor/test_metrics": {"TestMetrics": 3.6253333333333337}, "inductor/test_minifier": {"MinifierTests": 28.727666666666664}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 97.15033333333334}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 85.61266666666666, "TestPatternMatcher": 414.74999999999983}, "inductor/test_mmdecomp": {"TestDecompCUDA": 6.512000000000003}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.723333333333334}, "inductor/test_multi_kernel": {"MultiKernelTest": 69.395}, "inductor/test_pad_mm": {"PadMMTest": 124.67866666666667}, "inductor/test_padding": {"PaddingTest": 9.256666666666666, "PerfTestBetweenGoodAndBadShape": 0.002, "PerfTestWithAndWithoutPadding": 3.8636666666666666}, "inductor/test_pattern_matcher": {"TestPaternMatcher": 54.224999999999994, "TestPatternMatcher": 95.68933333333332}, "inductor/test_perf": {"FusionTests": 13.397999999999998, "InplacingTests": 5.499000000000001, "MinCutPartitioningTests": 10.529666666666666, "NoopTests": 0.8483333333333335, "NumBytesMetricTests": 20.515333333333334, "SchedulerFusionTests": 8.603, "TilingTests": 1.8953333333333333}, "inductor/test_profiler": {"DynamoProfilerTests": 6.137666666666667}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 110.51566666666668}, "inductor/test_smoke": {"SmokeTest": 5.1815}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 2.885, "MemoryBoundedTests": 1.9016666666666666, "TestCommAnalysis": 3.622666666666667, "UnsupportedTests": 0.223}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 97.88433333333334}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 17.721333333333334}, "inductor/test_storage_offset": {"StorageOffsetTests": 1.0573333333333335}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 92.8336666666667}, "inductor/test_torchbind": {"TestTorchbind": 6.410999999999999}, "inductor/test_torchinductor": {"CpuTests": 1423.8673333333334, "CudaTests": 328.85699999999997, "GPUTests": 875.1323333333333, "NanCheckerTest": 0.848, "RNNTest": 0.026000000000000006, "SweepInputsCpuTest": 111.84866666666666, "SweepInputsCudaTest": 11.02066666666667, "SweepInputsGPUTest": 24.295666666666662, "TestFull": 10.132666666666667, "TritonCodeGenTests": 79.20933333333336}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1503.854, "DynamicShapesCodegenCudaTests": 384.68, "DynamicShapesCodegenGPUTests": 947.5356666666661}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1608.1686666666667, "DynamicShapesCudaTests": 625.7516666666667, "DynamicShapesGPUTests": 1328.7106666666666, "TestInductorDynamicCUDA": 45.39166666666667}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 8858.622333333331}, "inductor/test_torchinductor_strided_blocks": {"TritonBlockPointerTest": 17.931}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.8236666666666667}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 19.883}, "inductor/test_triton_kernels": {"KernelTests": 88.55766666666666, "MutationTests": 0.5670000000000002, "NoOptimizationKernelTests": 53.486333333333356, "no_opt_test_class": 53.76866666666667}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 8.627666666666666}, "inductor/test_unbacked_symints": {"TestUnbackedSymints": 5.823333333333333, "TestUnbackedSymintsCUDA": 18.181}, "inductor/test_utils": {"TestUtils": 0.206}, "lazy/test_debug_util": {"DebugUtilTest": 0.24666666666666667}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.264}, "lazy/test_generator": {"LazyGeneratorTest": 0.26733333333333337}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.43900000000000006}, "lazy/test_step_closures": {"ClosuresTest": 2.201333333333333}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.22433333333333336, "TestLazyTensor": 0.05933333333333333}, "nn/test_convolution": {"TestConvolutionNN": 20.727333333333334, "TestConvolutionNNDeviceTypeCUDA": 50.05533333333279}, "nn/test_dropout": {"TestDropoutNN": 0.09933333333333334, "TestDropoutNNDeviceTypeCUDA": 0.4916666666666667}, "nn/test_embedding": {"TestEmbeddingNN": 0.10300000000000002, "TestEmbeddingNNDeviceTypeCUDA": 11.465333333333334}, "nn/test_init": {"TestNNInit": 3.479333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 0.28533333333333344}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.631, "TestLoadStateDictSwap": 0.04800000000000001}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.016666666666666666, "TestModuleHookNN": 0.056000000000000015, "TestModuleHooks": 0.06833333333333334, "TestStateDictHooks": 0.02500000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 4.395333333333334, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.23233333333333336}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.4370000000000001}, "nn/test_parametrization": {"TestNNParametrization": 0.7360000000000001, "TestNNParametrizationDeviceCUDA": 0.13933333333333334}, "nn/test_pooling": {"TestAvgPool": 0.25166666666666665, "TestPoolingNN": 0.6883333333333334, "TestPoolingNNDeviceTypeCUDA": 4.679666666666663}, "nn/test_pruning": {"TestPruningNN": 0.08933333333333338}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.1636666666666664}, "profiler/test_memory_profiler": {"TestDataFlow": 1.106, "TestIdentifyGradients": 0.2346666666666667, "TestMemoryProfiler": 0.229, "TestMemoryProfilerE2E": 2.473333333333333}, "profiler/test_profiler": {"TestExecutionTrace": 5.258333333333334, "TestExperimentalUtils": 3.7486666666666655, "TestProfiler": 18.326999999999998, "TestProfilerCUDA": 5.191666666666666, "TestProfilerITT": 0.002, "TestRecordFunction": 0.04, "TestTorchTidyProfiler": 4.896}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.277}, "profiler/test_record_function": {"TestRecordFunction": 0.26433333333333336}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.6556666666666664}, "test_ao_sparsity": {"TestActivationSparsifier": 0.05433333333333334, "TestBaseDataScheduler": 0.027, "TestBaseDataSparsifier": 0.06433333333333334, "TestBaseSparsifier": 0.021, "TestBaseStructuredSparsifier": 2.6733333333333325, "TestComposability": 1.987, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.05866666666666667, "TestFakeSparsity": 0.05766666666666667, "TestFxComposability": 1.6456666666666664, "TestNearlyDiagonalSparsifier": 0.7336666666666667, "TestNormDataSparsifiers": 0.6670000000000001, "TestQuantizationUtils": 0.014666666666666666, "TestQuantizedSparseKernels": 0.25866666666666666, "TestQuantizedSparseLayers": 0.3436666666666666, "TestSaliencyPruner": 0.022333333333333334, "TestScheduler": 0.011333333333333334, "TestSparsityUtilFunctions": 0.030333333333333334, "TestWeightNormSparsifier": 0.26833333333333337}, "test_autocast": {"TestAutocastCPU": 1.206, "TestAutocastGPU": 0.21533333333333335, "TestTorchAutocast": 0.0030000000000000005}, "test_autograd": {"TestAllowMutationOnSaved": 0.023000000000000003, "TestAutograd": 16.332000000000004, "TestAutogradComplex": 0.005, "TestAutogradDeviceTypeCUDA": 0.9850000000000003, "TestAutogradForwardMode": 0.05466666666666669, "TestAutogradForwardModeBatchedGrad": 0.014333333333333335, "TestAutogradFunctional": 9.034, "TestAutogradInferenceMode": 0.026333333333333344, "TestAutogradLogging": 0.013333333333333334, "TestAutogradMultipleDispatchCUDA": 0.018000000000000002, "TestMultithreadAutograd": 0.19400000000000006, "TestNestedCheckpoint": 0.35733333333333334, "TestSelectiveActivationCheckpoint": 0.06466666666666666}, "test_autograd_fallback": {"TestAutogradFallback": 0.3246666666666667}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 119.32700000000223}, "test_bundled_inputs": {"TestBundledInputs": 0.8816666666666668}, "test_comparison_utils": {"TestComparisonUtils": 0.20966666666666667}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.08633333333333333}, "test_content_store": {"TestContentStoreCUDA": 2.732999999999999}, "test_cpp_api_parity": {"TestCppApiParity": 8.517666666666655}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.25866666666666677, "TestMAIATensor": 0.006333333333333333, "TestORTTensor": 0.01066666666666667, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.043000000000000003}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.23933333333333337, "TestMAIATensor": 0.006333333333333333, "TestORTTensor": 0.01066666666666667, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.04466666666666667}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 95.65833333333335}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.001}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.223666666666669}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.001}, "test_cuda": {"TestBlockStateAbsorption": 5.392666666666666, "TestCuda": 60.97733333333334, "TestCudaMallocAsync": 9.325333333333335, "TestCudaOptimsCUDA": 2.6510000000000002}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.562, "TestCuda": 62.00999999999999, "TestCudaMallocAsync": 12.63133333333333, "TestCudaOptimsCUDA": 2.709333333333333}, "test_cuda_multigpu": {"TestCudaComm": 0.016000000000000004, "TestCudaMultiGPU": 0.466}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.26299999999999996, "TestVisibleDeviceParses": 0.017333333333333336}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0030000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.30733333333333335, "TestEventHandler": 0.026333333333333344, "TestMessages": 0.004}, "test_cuda_trace": {"TestCudaTrace": 1.8223333333333336}, "test_custom_backend": {"TestCustomBackend": 0.073}, "test_custom_ops": {"MiniOpTest": 0.47500000000000014, "MiniOpTestOther": 0.049000000000000016, "TestCustomOp": 2.126666666666662, "TestCustomOpAPI": 0.11800000000000005, "TestCustomOpTestingCUDA": 1.4053333333333333, "TestCustomOperators": 0.347, "TestGenerateOpcheckTests": 2.9456666666666664}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 32.586666666666666, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.03166666666666667, "TestCustomPinFn": 0.10200000000000002, "TestDataLoader": 83.50166666666667, "TestDataLoaderDeviceTypeCUDA": 14.752, "TestDataLoaderPersistentWorkers": 108.51033333333332, "TestDatasetRandomSplit": 0.022333333333333334, "TestDictDataLoader": 0.03366666666666667, "TestIndividualWorkerQueue": 0.0013333333333333333, "TestNamedTupleDataLoader": 0.0030000000000000005, "TestSetAffinity": 0.04066666666666666, "TestStackDataset": 0.023333333333333334, "TestStringDataLoader": 0.052333333333333336, "TestTensorDataset": 0.017666666666666667}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006000000000000001, "TestDataChunk": 0.006333333333333333, "TestDataFramesPipes": 0.001, "TestFunctionalIterDataPipe": 3.008666666666666, "TestFunctionalMapDataPipe": 0.028666666666666663, "TestGraph": 0.01066666666666667, "TestIterDataPipeCountSampleYielded": 0.006333333333333334, "TestIterDataPipeGraphFastForward": 0.036000000000000004, "TestIterDataPipeSingletonConstraint": 0.018333333333333333, "TestIterableDataPipeBasic": 0.022000000000000002, "TestSerialization": 6.443666666666668, "TestSharding": 0.19966666666666666, "TestStreamWrapper": 0.20866666666666667, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.031, "HasDecompTest": 0.13633333333333333, "TestDecompCUDA": 10425.872333333326}, "test_deploy": {"TestFreezer": 0.20166666666666666}, "test_dispatch": {"TestDispatch": 32.34533333333335, "TestPythonDispatcher": 0.029333333333333333}, "test_dlpack": {"TestTorchDlPackCUDA": 0.25400000000000017}, "test_dynamic_shapes": {"TestDimConstraints": 1.6833333333333333, "TestFloorDiv": 0.011000000000000001, "TestGuardsExpressions": 0.02266666666666667, "TestPySymInt": 1.030666666666667, "TestSymNumberMagicMethods": 1.4809999999999939}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 2.5016666666666647, "TestExpandedWeightHelperFunctionCUDA": 0.10433333333333335, "TestExpandedWeightModuleCUDA": 10.055333333333335}, "test_fake_tensor": {"FakeTensorConstHandling": 0.045333333333333344, "FakeTensorConverterTest": 0.018000000000000002, "FakeTensorDispatchCache": 0.064, "FakeTensorOpInfoTestCUDA": 0.08633333333333333, "FakeTensorOperatorInvariants": 0.44, "FakeTensorPropTest": 0.056333333333333326, "FakeTensorSerialization": 0.004666666666666667, "FakeTensorTest": 5.305666666666664, "PropagateRealTensorsFakeTensorConstHandling": 0.07200000000000001, "PropagateRealTensorsFakeTensorConverterTest": 0.017666666666666667, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.155, "PropagateRealTensorsFakeTensorPropTest": 0.041666666666666664, "PropagateRealTensorsFakeTensorTest": 9.956333333333346}, "test_flop_counter": {"TestFlopCounter": 0.6443333333333333}, "test_foreach": {"TestForeachCUDA": 372.74366666667356}, "test_function_schema": {"TestFunctionSchema": 0.47433333333333333}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 16.470666666666663}, "test_functional_optim": {"TestFunctionalOptimParity": 0.3106666666666667}, "test_functionalization": {"TestCrossRefFunctionalization": 1.7223333333333326, "TestFunctionalization": 2.0286666666666657}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.1016666666666666}, "test_futures": {"TestFuture": 0.8403333333333333}, "test_fx": {"AnnotationsTest": 0.01166666666666667, "TestCSEPass": 0.21000000000000005, "TestCommonPass": 0.14466666666666672, "TestConstFold": 0.13000000000000003, "TestConstParamShapeInControlFlow": 0.031000000000000003, "TestDCE": 0.022999999999999996, "TestFX": 2.237333333333331, "TestFXAPIBackwardCompatibility": 0.021666666666666667, "TestFunctionalTracing": 0.2630000000000002, "TestMatcher": 0.2826666666666667, "TestOperatorSignaturesCUDA": 0.7036666666666672, "TestPassManager": 0.018333333333333337, "TestSourceMatcher": 1.2069999999999999, "TestSubgraphRewriter": 0.22666666666666677, "TestVisionTracing": 212.29399999999998, "TypeCheckerTest": 1.4336666666666646}, "test_fx_experimental": {"TestFXExperimental": 11.948333333333332, "TestNormalizeOperatorsCUDA": 1.3413333333333324, "TestTranslationValidation": 0.10233333333333333}, "test_fx_passes": {"TestFXGraphPasses": 0.43600000000000017, "TestFXMatcherUtils": 0.07200000000000001}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.36933333333333346}, "test_import_stats": {"TestImportTime": 3.622}, "test_indexing": {"NumpyTestsCUDA": 0.03966666666666668, "TestIndexingCUDA": 1.5493333333333321}, "test_itt": {"TestItt": 0.24100000000000002}, "test_jit": {"TestAliasAnalysis": 0.27666666666666667, "TestAsync": 0.25633333333333336, "TestAtenPow": 0.006000000000000001, "TestAutodiffJit": 0.04700000000000001, "TestAutodiffSubgraphSlicing": 0.21766666666666676, "TestAwait": 0.14600000000000002, "TestBackends": 0.5306666666666667, "TestBackendsWithCompiler": 0.11299999999999999, "TestBatchMM": 0.06133333333333333, "TestBuiltins": 0.04466666666666667, "TestCUDA": 0.5840000000000001, "TestClassType": 1.8896666666666662, "TestComplex": 0.5910000000000001, "TestCustomOperators": 0.027333333333333338, "TestDCE": 0.013666666666666666, "TestDataParallel": 0.0, "TestDataclasses": 3.378, "TestDeviceAnalysis": 3.063, "TestDict": 0.2896666666666668, "TestDtypeAnalysis": 0.11299999999999999, "TestEnum": 0.14200000000000002, "TestFreezing": 1.6333333333333337, "TestFrontend": 0.324, "TestFrozenOptimizations": 9.165333333333331, "TestFunctionalBlocks": 0.004666666666666667, "TestFunctionalToInplaceActivation": 1.6893333333333336, "TestGenerator": 0.04566666666666667, "TestGetDefaultAttr": 0.011666666666666667, "TestGraphRewritePasses": 0.030666666666666665, "TestHash": 0.05299999999999999, "TestHooks": 0.48666666666666686, "TestIgnorableArgs": 0.007, "TestIgnoreContextManager": 0.035333333333333335, "TestInplaceToFunctionalActivation": 1.5236666666666665, "TestIsinstance": 0.1453333333333334, "TestJit": 4.110999999999996, "TestJitGeneratedModule": 8.266999999999996, "TestJitProfiler": 0.001, "TestJitUtils": 0.011333333333333336, "TestList": 0.9050000000000002, "TestLogging": 0.03666666666666666, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.36966666666666675, "TestMixTracingScripting": 0.8330000000000002, "TestModels": 4.397333333333333, "TestModuleAPIs": 0.09133333333333334, "TestModuleContainers": 0.8643333333333335, "TestModuleInterface": 0.4983333333333335, "TestModules": 0.01, "TestNamedTuple": 0.04666666666666668, "TestNnapiBackend": 9.238333333333332, "TestOpDecompositions": 0.011666666666666667, "TestOptimizeForMobilePreserveDebugInfo": 0.12533333333333332, "TestParametrization": 0.065, "TestPeephole": 0.3223333333333334, "TestProducerVersion": 0.001, "TestProfiler": 0.43933333333333335, "TestPythonBindings": 0.021, "TestPythonBuiltinOP": 0.25533333333333336, "TestPythonIr": 0.016, "TestRecursiveScript": 0.5163333333333334, "TestRemoveMutation": 0.08966666666666667, "TestSaveLoad": 0.5000000000000001, "TestSaveLoadFlatbuffer": 0.26933333333333337, "TestSaveLoadForOpVersion": 1.7979999999999998, "TestScript": 31.347666666666708, "TestScriptDict": 0.016666666666666666, "TestScriptList": 0.5516666666666667, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.13033333333333338, "TestScriptProfile": 0.26933333333333337, "TestSlice": 0.10500000000000002, "TestSparse": 0.033, "TestStringFormatting": 0.07900000000000004, "TestSymbolicShapeAnalysis": 0.9823333333333332, "TestTensorBuiltins": 0.07500000000000001, "TestTensorCreationOps": 0.03266666666666667, "TestTensorMethods": 0.008, "TestTorchbind": 0.11766666666666671, "TestTracer": 3.847333333333328, "TestTypeSharing": 0.3463333333333334, "TestTypesAndAnnotation": 0.085, "TestTyping": 0.2663333333333335, "TestUnion": 0.30500000000000016, "TestUnsupportedOps": 0.020666666666666667, "TestUpgraders": 0.04533333333333334, "TestWarn": 0.03866666666666667, "TestWith": 0.2323333333333333}, "test_jit_autocast": {"TestAutocast": 1.131, "TestJitTraceAutocast": 25.69033333333333}, "test_jit_disabled": {"TestJitDisabled": 0.3033333333333334}, "test_jit_fuser_te": {"TestFuserCommon": 0.12866666666666668, "TestNNCOpInfoCUDA": 12.721000000000894, "TestTEFuserDynamic": 384.5209999999999, "TestTEFuserStatic": 342.51400000000007}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.057666666666666665, "TestFusionPatternCUDA": 0.0, "TestModel": 0.001, "TestOpCUDA": 0.0013333333333333333}, "test_jiterator": {"TestPythonJiteratorCUDA": 19.16266666666667}, "test_legacy_vmap": {"TestVmapAPI": 1.1116666666666644, "TestVmapAPILegacy": 0.9323333333333333, "TestVmapBatchedGradientCUDA": 0.8290000000000002, "TestVmapBatchedGradientLegacyCUDA": 0.3823333333333334, "TestVmapOperators": 0.8510000000000001, "TestVmapOperatorsLegacy": 0.9696666666666668}, "test_license": {"TestLicense": 0.208}, "test_linalg": {"TestLinalgCUDA": 817.7316666666649}, "test_logging": {"LoggingTest": 2.553666666666667}, "test_masked": {"TestMaskedCUDA": 24.791666666666657}, "test_maskedtensor": {"TestBasicsCUDA": 0.19566666666666668, "TestBinary": 0.3413333333333335, "TestOperatorsCUDA": 5.77933333333329, "TestReductions": 0.06666666666666667, "TestUnary": 0.2880000000000002}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.005666666666666667, "TestMatmulCudaCUDA": 88.15633333333335, "TestMixedDtypesLinearCudaCUDA": 0.7683333333333332}, "test_meta": {"TestMetaCUDA": 1687.2026666666118, "TestMetaConverter": 0.10500000000000002}, "test_mkl_verbose": {"TestMKLVerbose": 3.989666666666666}, "test_mkldnn_fusion": {"TestMkldnnFusion": 44.072}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.2996666666666665}, "test_mobile_optimizer": {"TestOptimizer": 2.631333333333333}, "test_model_dump": {"TestModelDump": 0.8713333333333334}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.12233333333333334}, "test_module_init": {"TestModuleInitCUDA": 1.209999999999994}, "test_module_tracker": {"TestModuleTracker": 0.209}, "test_modules": {"TestModuleCUDA": 636.2243333333196}, "test_monitor": {"TestMonitor": 0.21233333333333335, "TestMonitorTensorboard": 0.10333333333333335}, "test_multiprocessing": {"TestMultiprocessing": 97.32600000000001}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.531, "SpawnTest": 25.299666666666667}, "test_namedtensor": {"TestNamedTensor": 0.5690000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.6829999999999998}, "test_native_functions": {"TestNativeFunctions": 0.3206666666666667}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.5536666666666669}, "test_nestedtensor": {"TestNestedTensor": 0.1133333333333334, "TestNestedTensorAutogradCUDA": 1.0843333333333331, "TestNestedTensorDeviceTypeCUDA": 1.1836666666666646, "TestNestedTensorSubclassCUDA": 5.9679999999999955}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.25833333333333336, "TestFusionUtils": 0.004, "TestNN": 46.92366666666674, "TestNNDeviceTypeCUDA": 124.39433333333757, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.08866666666666667}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.12666666666666673}, "test_openmp": {"TestOpenMP_ParallelFor": 3.542}, "test_ops": {"TestCommonCUDA": 2546.7893333333163, "TestCompositeComplianceCUDA": 820.1636666666647, "TestFakeTensorCUDA": 660.0513333333323, "TestMathBitsCUDA": 82.21933333333341, "TestSelfKwarg": 0.021, "TestTagsCUDA": 2.0503333333333345}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1009.2639999999795}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1716.5433333332692}, "test_ops_jit": {"TestJitCUDA": 944.6753333333335}, "test_optim": {"TestDifferentiableOptimizer": 0.16633333333333336, "TestLRScheduler": 0.8010000000000003, "TestOptim": 54.83200000000001, "TestOptimRenewedCUDA": 204.4929999999997, "TestSWAUtils": 0.7879999999999999}, "test_out_dtype_op": {"TestOutDtypeOp": 0.2936666666666667}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.017333333333333336, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.002, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.005333333333333333, "TestResolveName": 0.09500000000000001, "TestTorchFunctionMode": 0.026000000000000013, "TestTorchFunctionOverride": 1.6953333333332594, "TestTorchFunctionWarning": 0.010333333333333333, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.03, "ModelTest": 0.0, "TestAnalyze": 0.13833333333333334, "TestDependencyAPI": 0.048000000000000015, "TestDependencyHooks": 0.006999999999999999, "TestDiGraph": 0.012333333333333337, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.008333333333333333, "TestLoadBCPackages": 0.046000000000000006, "TestMangling": 0.012000000000000002, "TestMisc": 0.02333333333333334, "TestPackageFX": 0.04899999999999999, "TestPackageScript": 1.414666666666666, "TestRepackage": 0.004666666666666667, "TestResources": 0.009333333333333334, "TestSaveLoad": 0.026333333333333337}, "test_per_overload_api": {"TestPerOverloadAPI": 0.21033333333333334}, "test_prims": {"TestDecompCUDA": 0.06833333333333333, "TestPrimsBasic": 0.012000000000000002, "TestPrimsCUDA": 0.214, "TestRefsCUDA": 0.009333333333333334}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.08866666666666669, "TestGenericProxyTensorFake": 1.6696666666666669, "TestGenericProxyTensorReal": 1.7629999999999997, "TestGenericProxyTensorSymbolic": 16.722666666666665, "TestRealProxyTensor": 0.012333333333333335, "TestSymbolicTracing": 3.2336666666666662}, "test_pruning_op": {"PruningOpTest": 0.3906666666666667}, "test_public_bindings": {"TestPublicBindings": 4.589666666666667}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.023000000000000003, "TestPythonDispatch": 0.3083333333333334, "TestPythonDispatcher": 0.004333333333333334, "TestPythonRegistration": 1.2276666666666662, "TestWrapperSubclassAliasingCUDA": 0.10433333333333338}, "test_pytree": {"TestCxxPytree": 0.013000000000000005, "TestGenericPytree": 0.3036666666666667, "TestPythonPytree": 0.043666666666666694}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.013666666666666669, "TestAOMigrationNNQuantized": 0.027000000000000007, "TestAOMigrationQuantization": 0.016333333333333335, "TestAOMigrationQuantizationFx": 0.021, "TestBackendConfig": 0.03166666666666667, "TestBiasCorrectionEager": 0.5949999999999999, "TestBits": 0.0030000000000000005, "TestBitsCUDA": 0.016, "TestComparatorOps": 1.0239999999999998, "TestDeprecatedJitQuantized": 2.046, "TestDistributed": 0.021333333333333333, "TestDuplicateDQPass": 3.3379999999999996, "TestDynamicQuantizedModule": 38.038000000000004, "TestDynamicQuantizedOps": 21.119666666666664, "TestEqualizeEager": 0.06666666666666667, "TestEqualizeFx": 3.8056666666666668, "TestFXGraphMatcher": 2.031, "TestFXGraphMatcherModels": 8.625, "TestFXNumericSuiteCoreAPIs": 24.752333333333336, "TestFXNumericSuiteCoreAPIsModels": 35.90666666666667, "TestFXNumericSuiteNShadows": 35.57566666666667, "TestFakeQuantize": 0.223, "TestFakeQuantizeOps": 23.171666666666667, "TestFloat8DtypeCUDA": 0.18666666666666668, "TestFuseEager": 2.210333333333333, "TestFuseFx": 1.6226666666666663, "TestFusedObsFakeQuant": 0.16100000000000003, "TestFusedObsFakeQuantModule": 0.23233333333333336, "TestFusionPasses": 0.016666666666666666, "TestFxDetectInputWeightEqualization": 0.16033333333333336, "TestFxDetectOutliers": 0.20033333333333334, "TestFxModelReportClass": 0.4336666666666667, "TestFxModelReportDetectDynamicStatic": 0.05433333333333334, "TestFxModelReportDetector": 0.207, "TestFxModelReportObserver": 0.159, "TestFxModelReportVisualizer": 0.1723333333333333, "TestGenerateNumericDebugHandle": 0.7010000000000001, "TestGraphUtils": 1.054, "TestHistogramObserver": 33.766999999999996, "TestMetaDataPorting": 6.3933333333333335, "TestModelNumericsEager": 0.5486666666666666, "TestNumericSuiteEager": 6.398333333333333, "TestObserver": 2.998666666666667, "TestPT2ERepresentation": 24.222333333333335, "TestPadding": 7.614999999999999, "TestQNNPackOps": 5.5616666666666665, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 1.9656666666666667, "TestQuantizeDynamicJitPasses": 4.046333333333333, "TestQuantizeEagerOps": 1.4213333333333331, "TestQuantizeEagerPTQDynamic": 5.750666666666667, "TestQuantizeEagerPTQStatic": 22.951999999999998, "TestQuantizeEagerQAT": 8.366333333333332, "TestQuantizeEagerQATNumerics": 1.4876666666666665, "TestQuantizeFx": 24.904999999999998, "TestQuantizeFxModels": 9.187, "TestQuantizeFxOps": 100.734, "TestQuantizeJit": 18.771333333333335, "TestQuantizeJitOps": 223.36866666666666, "TestQuantizeJitPasses": 4.9209999999999985, "TestQuantizePT2E": 69.28933333333335, "TestQuantizePT2EQAT": 62.19166666666666, "TestQuantizePT2EQATModels": 40.49999999999999, "TestQuantizePT2EQAT_ConvBn1d": 592.2346666666667, "TestQuantizePT2EQAT_ConvBn2d": 595.904, "TestQuantizePT2EX86Inductor": 190.50300000000001, "TestQuantizedConv": 240.75733333333335, "TestQuantizedEmbeddingOps": 0.48133333333333334, "TestQuantizedFunctionalOps": 2.282666666666667, "TestQuantizedLinear": 17.082, "TestQuantizedOps": 120.1606666666667, "TestQuantizedTensor": 1.9003333333333332, "TestRecordHistogramObserver": 0.024999999999999998, "TestReferenceQuantizedModule": 0.03966666666666666, "TestSerialization": 1.5436666666666667, "TestStaticQuantizedModule": 81.61833333333333, "TestSubgraphRewriter": 0.7843333333333334, "TestUtils": 0.013333333333333336, "TestXNNPACKQuantizer": 43.16733333333334, "TestXNNPACKQuantizerModels": 2.4916666666666667}, "test_reductions": {"TestReductionsCUDA": 132.97900000000175}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 22.374}, "test_schema_check": {"TestSchemaCheck": 0.12233333333333339, "TestSchemaCheckModeOpInfoCUDA": 227.41633333332774}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 2.062}, "test_serialization": {"TestBothSerializationCUDA": 0.08, "TestOldSerialization": 15.497333333333335, "TestSerialization": 6.422333333333328, "TestSubclassSerialization": 0.022333333333333334}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.207}, "test_shape_ops": {"TestShapeOpsCUDA": 1.1976666666666655}, "test_show_pickle": {"TestShowPickle": 0.22233333333333336}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.6976666666666618}, "test_sparse": {"TestSparseAnyCUDA": 646.7176666666609, "TestSparseCUDA": 55.23399999999997, "TestSparseLegacyAndDeprecation": 0.041666666666666664, "TestSparseMaskedReductionsCUDA": 2.163666666666667, "TestSparseMeta": 2.9979999999999998, "TestSparseOneOff": 0.022000000000000002, "TestSparseUnaryUfuncsCUDA": 4.877999999999951}, "test_sparse_csr": {"TestSparseCSRCUDA": 182.88433333333282, "TestSparseCSRSampler": 0.5056666666666666, "TestSparseCompressedCUDA": 117.50600000000014, "TestSparseCompressedTritonKernelsCUDA": 1045.7569999999998}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 9.950000000000001, "TestCUSPARSELTCUDA": 0.18333333333333343, "TestSparseSemiStructuredCUDA": 2.192999999999993, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.19833333333333344, "TestSparseSemiStructuredCUTLASSCUDA": 13.587666666666669, "TestSparseSemiStructuredTrainingCUDA": 4.243333333333332}, "test_spectral_ops": {"TestFFTCUDA": 18.755333333333294}, "test_stateless": {"TestPythonOptimizeMode": 3.171333333333333, "TestStatelessDeprecation": 1.590333333333333, "TestStatelessFunctionalAPI": 0.17833333333333337}, "test_subclass": {"TestSubclass": 0.37733333333333346}, "test_sympy_utils": {"TestNumbers": 0.03233333333333333, "TestSingletonInt": 0.004, "TestSympyInterp": 7.217333333333333, "TestSympySolve": 0.1376666666666667, "TestValueRanges": 5.2253333333333325}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.43600000000000033, "TestLikeTensorCreationCUDA": 0.007, "TestRandomTensorCreationCUDA": 0.13233333333333339, "TestTensorCreationCUDA": 85.44366666666683}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.019666666666666666, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.14200000000000002, "TestTensorBoardPytorchGraph": 22.340000000000003, "TestTensorBoardSummary": 0.027666666666666676, "TestTensorBoardSummaryWriter": 0.006333333333333334, "TestTensorBoardUtils": 0.10666666666666667, "TestTensorBoardWriter": 0.066, "TestTensorProtoSummary": 0.008}, "test_tensorexpr": {"TestTensorExprFuser": 114.21366666666667}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.007333333333333333, "TestTensorExprPyBind": 0.7700000000000001}, "test_testing": {"TestAssertClose": 0.09933333333333338, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.04600000000000001, "TestAssertCloseMultiDeviceCUDA": 0.008666666666666668, "TestAssertCloseQuantized": 0.008333333333333333, "TestAssertCloseSparseBSC": 0.012333333333333335, "TestAssertCloseSparseBSR": 0.013666666666666667, "TestAssertCloseSparseCOO": 0.034, "TestAssertCloseSparseCSC": 0.015666666666666666, "TestAssertCloseSparseCSR": 0.016333333333333335, "TestFrameworkUtils": 12.884, "TestImports": 11.521666666666667, "TestMakeTensorCUDA": 1.047333333333328, "TestOpInfoSampleFunctionsCUDA": 4.044666666666657, "TestOpInfos": 0.0033333333333333335, "TestTestParametrization": 0.02600000000000001, "TestTestParametrizationDeviceTypeCUDA": 3.3079999999999976, "TestTestingCUDA": 0.31766666666666676}, "test_torch": {"TestBasicVitalSigns": 0.02366666666666667, "TestDevicePrecisionCUDA": 0.05766666666666668, "TestTorch": 5.07433333333332, "TestTorchDeviceTypeCUDA": 70.68900000000004, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 1.258333333333333, "TestAttnMasksCUDA": 0.03466666666666667, "TestSDPACUDA": 1.3843333333333343, "TestSDPACudaOnlyCUDA": 1463.9039999994893, "TestSDPAFailureModesCUDA": 0.16900000000000004, "TestTransformersCUDA": 4.288}, "test_type_hints": {"TestTypeHints": 0.20433333333333334}, "test_type_info": {"TestDTypeInfo": 0.224}, "test_type_promotion": {"TestTypePromotionCUDA": 7.908333333333316}, "test_typing": {"TestTyping": 60.163333333333306}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 327.1479999999513}, "test_utils": {"TestAssert": 0.052, "TestBottleneck": 9.911333333333333, "TestCheckpoint": 0.15666666666666668, "TestCollectEnv": 0.9646666666666666, "TestCppExtensionUtils": 0.026, "TestDataLoaderUtils": 0.2793333333333334, "TestDeviceUtilsCUDA": 11.767666666667255, "TestExtensionUtils": 0.0036666666666666666, "TestHipify": 0.001, "TestHipifyTrie": 0.005, "TestONNXUtils": 0.0026666666666666666, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.188, "TestTraceback": 0.006333333333333334}, "test_view_ops": {"TestOldViewOpsCUDA": 13.799333333333335, "TestViewOpsCUDA": 0.9500000000000005}, "test_vulkan": {"TestVulkanRewritePass": 0.0003333333333333333}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.016333333333333335, "WeakKeyDictionaryTestCase": 0.016, "WeakTest": 3.471999999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 28.59166666666667, "TestXNNPACKOps": 3.2936666666666667, "TestXNNPACKRewritePass": 1.375333333333333, "TestXNNPACKSerDes": 3.9919999999999995}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0033333333333333335}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.218, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.09500000000000001, "TestPromotion": 0.0}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 11.951333333333332, "TestEinsumPath": 0.0003333333333333333, "TestMisc": 0.005333333333333333}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.21833333333333335, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.004333333333333334, "TestBroadcastedAssignments": 0.013000000000000003, "TestFancyIndexingCast": 0.0030000000000000005, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.3253333333333334, "TestMultiIndexingAutomated": 0.006000000000000001, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.013000000000000003, "TestArgmax": 0.9330000000000007, "TestArgmaxArgminCommon": 0.04400000000000002, "TestArgmin": 1.104666666666667, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.03000000000000001, "TestArrayCreationCopyArgument": 0.0, "TestArrayInterface": 0.020000000000000004, "TestAssignment": 0.008333333333333333, "TestAttributes": 0.019000000000000003, "TestBinop": 0.015, "TestBool": 20.462000000000003, "TestCequenceMethods": 0.0013333333333333333, "TestChoose": 0.013000000000000003, "TestClip": 0.004333333333333334, "TestCompress": 0.0030000000000000005, "TestConversion": 0.030333333333333334, "TestCreation": 0.001, "TestDelMisc": 0.001, "TestDot": 0.05300000000000002, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.022333333333333334, "TestFlag": 0.009666666666666669, "TestFormat": 0.0036666666666666666, "TestFromBuffer": 0.009666666666666669, "TestHash": 0.12566666666666668, "TestHashing": 0.002, "TestIO": 0.001, "TestInner": 0.18333333333333335, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.3536666666666668, "TestMatmulOperator": 0.254, "TestMethods": 1.1470000000000005, "TestMinMax": 0.0033333333333333335, "TestMinScalarType": 0.004, "TestNewaxis": 0.0030000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.010666666666666666, "TestResize": 0.038000000000000006, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.017333333333333336, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.12000000000000005, "TestStats": 0.19200000000000003, "TestSubscripting": 0.001, "TestTake": 0.02566666666666667, "TestVdot": 0.029333333333333333, "TestViewDtype": 0.006000000000000001, "TestWarnings": 0.001, "TestWhere": 0.2846666666666667, "TestWritebackIfCopy": 0.01966666666666667}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.01966666666666667, "TestArgwhere": 0.026333333333333334, "TestArrayComparisons": 0.015000000000000001, "TestBaseRepr": 0.004666666666666667, "TestBinaryRepr": 0.006333333333333333, "TestBoolArray": 1.7546666666666664, "TestBoolCmp": 0.15733333333333333, "TestBoolScalar": 0.007666666666666666, "TestBroadcast": 0.004, "TestClip": 0.17233333333333345, "TestConvolve": 0.032, "TestCorrelate": 0.049999999999999996, "TestCreationFuncs": 0.984, "TestCross": 0.04766666666666667, "TestDtypePositional": 0.0013333333333333333, "TestFloatExceptions": 0.008, "TestFromiter": 0.0016666666666666668, "TestIndex": 0.004333333333333334, "TestIndices": 0.030000000000000002, "TestIsclose": 0.06933333333333334, "TestIsscalar": 0.002, "TestLikeFuncs": 0.0003333333333333333, "TestMoveaxis": 0.007666666666666666, "TestNonarrayArgs": 0.09400000000000004, "TestNonzeroAndCountNonzero": 0.2146666666666667, "TestOuterMisc": 0.004333333333333334, "TestRequire": 0.004, "TestResize": 0.2366666666666667, "TestRoll": 0.029333333333333336, "TestRollaxis": 0.0036666666666666666, "TestSeterr": 0.004666666666666667, "TestStdVar": 0.026333333333333334, "TestStdVarComplex": 0.009666666666666667, "TestStringFunction": 0.0013333333333333333, "TestTensordot": 0.012000000000000002, "TestTypes": 0.011333333333333334}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.21033333333333334, "TestDocStrings": 0.0, "TestIsSubDType": 0.006000000000000001, "TestScalarTypeNames": 0.021000000000000008}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06066666666666671, "TestFromInt": 0.006333333333333333, "TestFromString": 0.21633333333333335}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.0, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.083, "TestBaseMath": 7.966666666666666, "TestBitShifts": 0.07466666666666666, "TestComplexDivision": 0.05066666666666667, "TestConversion": 0.043333333333333335, "TestHash": 0.0, "TestModulus": 0.847, "TestMultiply": 0.0, "TestNegative": 0.015666666666666666, "TestPower": 0.11066666666666668, "TestRepr": 0.001, "TestScalarOpsMisc": 0.028666666666666684, "TestScalarSubclassingMisc": 0.009333333333333334, "TestSubtract": 0.015, "TestTypes": 13.539333333333332}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.21633333333333335, "TestAtleast2d": 0.013000000000000003, "TestAtleast3d": 0.012000000000000002, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.11866666666666674, "TestHstack": 0.013000000000000003, "TestStackMisc": 0.0026666666666666666, "TestVstack": 0.015333333333333332}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.008666666666666666, "TestFFTShift": 5.147666666666667, "TestIRFFTN": 0.002, "TestRFFTFreq": 0.008333333333333333}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.1636666666666664, "TestFFTShift": 0.20933333333333334, "TestFFTThreadSafe": 0.5546666666666668}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.21933333333333338}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.001, "TestUnique": 0.3383333333333334}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.005666666666666667, "TestAmax": 0.005, "TestAmin": 0.005, "TestAngle": 0.007, "TestAny": 0.005333333333333333, "TestAverage": 0.021, "TestBincount": 0.03233333333333333, "TestCheckFinite": 0.002, "TestCopy": 0.006000000000000001, "TestCorrCoef": 0.026, "TestCov": 0.04866666666666667, "TestCumprod": 0.026, "TestCumsum": 0.034333333333333334, "TestDelete": 0.016, "TestDiff": 0.063, "TestDigitize": 0.011666666666666667, "TestExtins": 0.004333333333333334, "TestFilterwindows": 0.4563333333333337, "TestFlip": 0.023000000000000003, "TestGradient": 0.11733333333333335, "TestInsert": 0.008, "TestInterp": 0.032666666666666684, "TestKaiser": 0.009000000000000001, "TestMedian": 0.08566666666666668, "TestMeshgrid": 0.04466666666666668, "TestMsort": 0.0, "TestPercentile": 0.06100000000000003, "TestPiecewise": 0.008, "TestProd": 0.025666666666666667, "TestPtp": 0.008, "TestQuantile": 0.013333333333333336, "TestRot90": 0.16966666666666666, "TestSelect": 0.007, "TestSinc": 0.007, "TestSortComplex": 0.008, "TestTrapz": 0.004333333333333334, "TestTrimZeros": 0.008, "TestUnique": 0.0030000000000000005, "Test_I0": 0.011333333333333334}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.29800000000000004, "TestHistogramOptimBinNums": 0.020000000000000004, "TestHistogramdd": 0.10766666666666667}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006000000000000001, "TestDiagIndices": 0.004, "TestDiagIndicesFrom": 0.006000000000000001, "TestFillDiagonal": 0.02033333333333333, "TestGrid": 0.007, "TestIndexExpression": 0.008, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.21333333333333337}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.010000000000000002, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.1376666666666667, "TestColumnStack": 0.007666666666666666, "TestDsplit": 0.008, "TestDstack": 0.013333333333333336, "TestExpandDims": 0.005, "TestHsplit": 0.010000000000000002, "TestKron": 0.010666666666666666, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.008, "TestSplit": 0.005, "TestSqueeze": 0.02133333333333334, "TestTakeAlongAxis": 0.23233333333333336, "TestTile": 0.06866666666666667, "TestVsplit": 0.007}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.025333333333333333, "TestEye": 0.24766666666666667, "TestFliplr": 0.004666666666666667, "TestFlipud": 0.004666666666666667, "TestHistogram2d": 0.03833333333333334, "TestTri": 0.113, "TestTrilIndicesFrom": 0.0013333333333333333, "TestTriuIndices": 0.0026666666666666666, "TestTriuIndicesFrom": 0.001, "TestVander": 0.015}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.20466666666666666, "TestImag": 0.01, "TestIscomplex": 0.004, "TestIscomplexobj": 0.0030000000000000005, "TestIsfinite": 0.007666666666666666, "TestIsinf": 0.006333333333333334, "TestIsnan": 0.008, "TestIsneginf": 0.0016666666666666668, "TestIsposinf": 0.002, "TestIsreal": 0.007, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.0033333333333333335, "TestNanToNum": 0.010333333333333333, "TestReal": 0.011000000000000001, "TestRealIfClose": 0.0036666666666666666}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.11933333333333336, "TestCond": 0.19833333333333333, "TestDet": 0.13733333333333334, "TestEig": 0.037333333333333336, "TestEigh": 0.020000000000000004, "TestEighCases": 0.0, "TestEigvals": 0.04833333333333334, "TestEigvalsh": 0.019000000000000003, "TestEigvalshCases": 0.0, "TestInv": 0.044000000000000004, "TestLstsq": 0.18033333333333332, "TestMatrixRank": 0.3466666666666667, "TestMisc": 0.018333333333333333, "TestMisc2": 0.0016666666666666668, "TestMultiDot": 0.04266666666666668, "TestNormDouble": 0.7043333333333334, "TestNormInt64": 0.6993333333333333, "TestNormSingle": 0.7033333333333335, "TestNorm_NonSystematic": 0.0030000000000000005, "TestPinv": 0.09566666666666668, "TestPinvHermitian": 0.030666666666666665, "TestQR": 0.37800000000000006, "TestSVD": 0.04033333333333334, "TestSVDHermitian": 0.09300000000000001, "TestSolve": 0.25866666666666666, "TestTensorinv": 0.013000000000000003, "TestTensorsolve": 0.0023333333333333335}, "torch_np/test_basic": {"TestArrayToSequence": 0.006000000000000001, "TestCopyTo": 0.004666666666666667, "TestCtorNested": 0.0023333333333333335, "TestDefaultDtype": 0.004333333333333334, "TestDivmod": 0.011333333333333336, "TestExport": 0.0, "TestMisc": 0.17366666666666664, "TestNormalizations": 0.0033333333333333335, "TestOneArr": 0.24066666666666683, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.0023333333333333335, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.017333333333333336, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.2806666666666667}, "torch_np/test_dtype": {"TestConvertDType": 0.24833333333333338}, "torch_np/test_function_base": {"TestAppend": 0.20766666666666667}, "torch_np/test_ndarray_methods": {"TestAmax": 0.007333333333333333, "TestAmin": 0.006333333333333334, "TestArgmax": 0.892333333333334, "TestArgmaxArgminCommon": 0.04566666666666668, "TestArgmin": 1.038666666666667, "TestContains": 0.0013333333333333333, "TestIndexing": 0.20633333333333334, "TestIter": 0.0036666666666666666, "TestNoExtraMethods": 0.006000000000000001, "TestNonzero": 0.11966666666666666, "TestRavel": 0.005, "TestReshape": 0.0036666666666666666, "TestTranspose": 0.007}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.011666666666666667, "TestNEP50Table": 0.0003333333333333333}, "torch_np/test_random": {"TestChoice": 0.008666666666666668, "TestNumpyGlobal": 0.0030000000000000005, "TestScalarReturn": 0.24466666666666667, "TestShuffle": 0.009333333333333334}, "torch_np/test_reductions": {"TestAll": 0.011000000000000001, "TestAny": 0.011333333333333334, "TestFlatnonzero": 0.17600000000000002, "TestGenericCumSumProd": 0.016, "TestGenericReductions": 1.8389999999999598, "TestMean": 0.031, "TestSum": 0.20266666666666666}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.23433333333333337, "TestIsScalar": 0.02200000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3893333333333336, "TestNdarrayDunderVsUfunc": 0.1633333333333334, "TestUfuncDtypeKwd": 0.004333333333333334, "TestUnaryUfuncs": 0.2316666666666667}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.2966666666666667}}, "slow": {"backends/xeon/test_launch": {"TestTorchrun": 1.75}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 314.2929999999999}, "distributions/test_distributions": {"TestAgainstScipy": 0.004, "TestConstraints": 0.002, "TestDistributionShapes": 0.04300000000000003, "TestDistributions": 0.1370000000000001, "TestFunctors": 0.004, "TestJit": 0.008, "TestKL": 0.013000000000000005, "TestLazyLogitsInitialization": 0.002, "TestNumericalStability": 0.010000000000000002, "TestRsample": 0.007, "TestValidation": 0.004}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.232}, "dynamo/test_after_aot": {"TestAfterAot": 0.201}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.188}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 0.23000000000000004}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.20400000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 0.22500000000000003}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0, "NormalizeIRTests": 0.001, "TestCustomBackendAPI": 0.003, "TestExplainWithBackend": 0.001, "TestOptimizations": 0.21300000000000002}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 0.20800000000000002}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 0.206}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 0.001, "BytecodeTests": 0.20400000000000001}, "dynamo/test_compile": {"InPlaceCompilationTests": 0.211, "PublicTorchCompilerTests": 0.001}, "dynamo/test_comptime": {"ComptimeTests": 0.227}, "dynamo/test_config": {"ConfigTests": 0.202}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.003, "CppGuardManagerFuncTorchHigherOrderOpTests": 0.07400000000000005, "CppGuardManagerFunctionTests": 0.2800000000000002, "CppGuardManagerHigherOrderOpTests": 0.09800000000000007, "CppGuardManagerMiscTests": 0.46100000000000035, "CppGuardManagerReproTests": 0.21400000000000016}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.056000000000000036}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 0.20400000000000001}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.20400000000000001}, "dynamo/test_decorators": {"DecoratorTests": 0.21400000000000002}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.012}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 0.032000000000000015, "DynamicShapesCtxManagerTests": 0.045000000000000026, "DynamicShapesExportTests": 2558.9889999999978, "DynamicShapesFuncTorchHigherOrderOpTests": 0.10600000000000007, "DynamicShapesFunctionTests": 0.2890000000000002, "DynamicShapesHigherOrderOpTests": 0.11900000000000006, "DynamicShapesMiscTests": 0.4650000000000003, "DynamicShapesNNModuleTests": 0.398, "DynamicShapesReproTests": 0.7220000000000002, "DynamicShapesSubGraphTests": 0.060000000000000026, "DynamicShapesTestSDPA": 0.004}, "dynamo/test_exc": {"ExcTests": 0.011}, "dynamo/test_exceptions": {"ExceptionTests": 0.20600000000000002}, "dynamo/test_export": {"ExportTests": 0.18800000000000014}, "dynamo/test_export_mutations": {"MutationExportTests": 0.208}, "dynamo/test_frame_init": {"FrameInitTests": 0.196}, "dynamo/test_functions": {"DefaultsTests": 0.02000000000000001, "FunctionTests": 0.5970000000000003}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.197}, "dynamo/test_global": {"TestGlobals": 0.20900000000000002}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.23000000000000004}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.010000000000000002, "FuncTorchHigherOrderOpTests": 0.07700000000000005, "HigherOrderOpTests": 0.2920000000000001, "HigherOrderOpVmapGuardTests": 0.013000000000000001}, "dynamo/test_hooks": {"HooksTests": 0.22500000000000003}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 0.03200000000000002, "InlineInbuiltNNModulesExportTests": 0.18000000000000013, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 0.07400000000000005, "InlineInbuiltNNModulesFunctionTests": 0.2910000000000002, "InlineInbuiltNNModulesHigherOrderOpTests": 0.09700000000000007, "InlineInbuiltNNModulesMiscTests": 0.5960000000000003, "InlineInbuiltNNModulesNNModuleTests": 0.07500000000000005}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 0.231}, "dynamo/test_interop": {"InteropTests": 0.20400000000000001}, "dynamo/test_logging": {"LoggingTests": 0.23600000000000004}, "dynamo/test_minifier": {"MinifierTests": 0.224}, "dynamo/test_misc": {"MiscTests": 0.46400000000000036, "TestTracer": 0.001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0}, "dynamo/test_modules": {"NNModuleTests": 0.2740000000000001, "OptimizedModuleTest": 0.037000000000000026}, "dynamo/test_nops": {"NopTests": 0.203}, "dynamo/test_optimizers": {"End2EndTests": 0.207, "OptimizerTests": 0.128}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.20400000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.213}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.24200000000000002}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.20400000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.20400000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.20700000000000002}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.129}, "dynamo/test_repros": {"ReproTests": 0.23100000000000018}, "dynamo/test_resume": {"ResumeFunctionTests": 0.202}, "dynamo/test_sdpa": {"TestSDPA": 0.198}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.20500000000000002}, "dynamo/test_sources": {"SourceTests": 0.202}, "dynamo/test_structured_trace": {"StructuredTraceTest": 0.21100000000000002}, "dynamo/test_subclasses": {"SubclassTests": 0.23600000000000004, "TestNestedTensor": 0.024000000000000014}, "dynamo/test_subgraphs": {"SubGraphTests": 0.24400000000000005}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.001, "TraceRuleTests": 0.224}, "dynamo/test_triton_kernels": {"KernelTests": 0.2440000000000001, "MutationTests": 0.024000000000000014, "NoOptimizationKernelTests": 0.12500000000000008, "no_opt_test_class": 0.12500000000000008}, "dynamo/test_unspec": {"UnspecTests": 0.23300000000000004}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.20400000000000001}, "dynamo/test_view": {"ViewTests": 0.20400000000000001}, "export/test_converter": {"TestConverter": 0.21900000000000003}, "export/test_db": {"ExampleTests": 0.23100000000000004}, "export/test_experimental": {"TestExperiment": 0.215}, "export/test_export": {"TestDynamismExpression": 0.005, "TestExport": 0.1510000000000001, "TestExportCustomClass": 0.28900000000000003, "TestOneOffModelExportResult": 0.012000000000000004}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.005, "NonStrictExportTestExport": 0.1520000000000001}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.004, "PreDispatchExportTestExport": 0.1410000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.198}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.5870000000000001}, "export/test_hop": {"TestHOPCUDA": 0.02000000000000001, "TestHOPGeneric": 0.001}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.08, "TestLiftUnlift": 0.01}, "export/test_pass_infra": {"TestPassInfra": 0.2}, "export/test_passes": {"TestPasses": 0.21900000000000003}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.005, "RetraceExportTestExport": 0.1530000000000001}, "export/test_safeguard": {"TestSafeguard": 0.20500000000000002}, "export/test_schema": {"TestSchema": 0.2}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.004, "SerDesExportPreDispatchTestExport": 0.1410000000000001, "SerDesExportTestDynamismExpression": 0.005, "SerDesExportTestExport": 0.1530000000000001}, "export/test_serialize": {"TestDeserialize": 0.05500000000000004, "TestOpVersioning": 0.003, "TestSaveLoad": 0.006, "TestSchemaVersioning": 0.001, "TestSerialize": 0.21300000000000002, "TestSerializeCustomClass": 0.002}, "export/test_sparse": {"TestSparseProp": 0.35400000000000015}, "export/test_tools": {"TestExportTools": 0.20400000000000001}, "export/test_torchbind": {"TestCompileTorchbind": 0.9040000000000001, "TestExportTorchbind": 1.5379999999999991, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.203}, "export/test_unflatten": {"TestUnflatten": 0.22100000000000003}, "export/test_upgrade": {"TestUpgrade": 0.20800000000000002}, "export/test_verifier": {"TestVerifier": 0.23800000000000002}, "functorch/test_ac": {"MemoryBudgetTest": 0.20600000000000002}, "functorch/test_aotdispatch": {"TestAOTAutograd": 0.11900000000000009, "TestAOTAutogradWithDynamo": 0.11900000000000009, "TestAOTDispatch": 0.009000000000000001, "TestAOTExport": 0.02900000000000002, "TestAOTModuleSimplified": 0.007, "TestPartitioning": 0.011000000000000003}, "functorch/test_control_flow": {"TestControlFlow": 0.132, "TestControlFlowTraced": 0.21800000000000017}, "functorch/test_dims": {"TestMin": 0.23800000000000004, "TestMinFunctorchOnly": 0.03400000000000002}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.02900000000000002, "TestAutogradFunctionVmapAPICUDA": 0.009000000000000001, "TestCompileTransformsCUDA": 0.002, "TestComposabilityCUDA": 0.04500000000000003, "TestExamplesCorrectnessCUDA": 0.02000000000000001, "TestFunctionalizeCUDA": 0.01800000000000001, "TestGradTransformCUDA": 0.06300000000000004, "TestHelpersCUDA": 0.005, "TestHessianCUDA": 0.004, "TestHigherOrderOperatorInteractionCUDA": 0.009000000000000001, "TestJacCUDA": 0.08200000000000006, "TestJvpCUDA": 0.022000000000000013, "TestLinearizeCUDA": 0.005, "TestMakeFunctional": 0.02000000000000001, "TestSliceArgnums": 0.009000000000000001, "TestVmapJvpInplaceViewCUDA": 0.005, "TestVmapOfGradCUDA": 0.007}, "functorch/test_logging": {"TestAOTLogging": 0.204}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.005, "RandomOpTestCase": 0.001, "ReduceTestCase": 0.009000000000000001, "TestMemoryEfficientOpAuthoring": 0.215}, "functorch/test_minifier": {"TestMinifier": 0.20400000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 2000.693999999943}, "functorch/test_parsing": {"TestAnonymousAxis": 0.202, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.005}, "functorch/test_rearrange": {"TestRearrange": 0.216}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.2720000000000002, "TestTransformFailureCUDA": 0.007, "TestVmapAPI": 0.06400000000000004, "TestVmapBatchedGradientCUDA": 0.03100000000000002, "TestVmapDeviceTypeCUDA": 0.005, "TestVmapNestedTensorCUDA": 0.013000000000000005, "TestVmapOperators": 0.16500000000000012, "TestVmapOperatorsOpInfoCUDA": 5.799000000000076}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 1.916999999999901}, "higher_order_ops/test_with_effects": {"TestWithEffects": 5.718000000000001}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.12600000000000008, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.10700000000000008, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.07500000000000005, "AOTInductorTestABICompatibleCuda": 0.1360000000000001, "AOTInductorTestNonABICompatibleCpu": 0.1350000000000001, "AOTInductorTestNonABICompatibleCuda": 64.1450000000005}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 8.978, "BenchmarkFusionCudaTest": 38.787, "BenchmarkMultiTemplateFusionCudaTest": 0.003}, "inductor/test_binary_folding": {"FreezingCpuTests": 0.002, "FreezingCudaTests": 0.002}, "inductor/test_codecache": {"TestFxGraphCache": 0.03800000000000003, "TestFxGraphCacheHashing": 0.005, "TestUtils": 0.001, "test_codecache": 2.7790000000000004}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.125}, "inductor/test_compile_worker": {"TestCompileWorker": 0.218}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 0.32500000000000023, "TestAutogradWithCompiledAutograd": 0.43500000000000033, "TestCompiledAutograd": 0.08600000000000005, "TestCustomOpWithCompiledAutograd": 0.12800000000000006}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 69.85100000000003, "CompiledOptimizerTests": 0.9010000000000006}, "inductor/test_config": {"TestInductorConfig": 0.23700000000000002}, "inductor/test_control_flow": {"CondTests": 0.269, "WhileLoopTests": 0.019000000000000006}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 0.21}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 0.05000000000000004, "DynamicShapesCudaWrapperCudaTests": 0.03900000000000003, "TestCppWrapper": 35.55299999999991, "TestCudaWrapper": 0.03950000000000003}, "inductor/test_cpu_repro": {"CPUReproTests": 917.0179999999992}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 0.048000000000000036, "TestCudaWrapper": 0.04900000000000004}, "inductor/test_cuda_repro": {"CudaReproTests": 0.05300000000000004}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 0.08300000000000006}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.124}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 0.124}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 76.51100000000008}, "inductor/test_debug_trace": {"TestDebugTrace": 0.002}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.21700000000000003}, "inductor/test_dependencies": {"TestDependencies": 0.125}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 0.23}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 179.328, "EfficientConvBNEvalCudaTests": 114.663}, "inductor/test_extension_backend": {"ExtensionBackendTests": 1.867}, "inductor/test_flex_attention": {"TestFlexAttention": 0.1370000000000001, "TestTemplatedSDPA": 0.10500000000000008}, "inductor/test_foreach": {"ForeachTests": 0.19700000000000015}, "inductor/test_fp8": {"TestFP8Types": 0.008}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 0.01900000000000001, "SDPAPatternRewriterCpuTests": 0.01900000000000001, "SDPAPatternRewriterCudaDynamicTests": 0.025000000000000015, "SDPAPatternRewriterCudaTests": 0.033000000000000015}, "inductor/test_fx_fusion": {"TestFxFusion": 0.137}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.011}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.002, "TestGroupBatchFusion": 67.343, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.009000000000000001, "TestIndexingSimplification": 0.231}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 0.022000000000000013, "FreezingCudaTests": 0.02400000000000001}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 0.208}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 0.027000000000000007}, "inductor/test_layout_optim": {"TestLayoutOptim": 0.023000000000000007}, "inductor/test_loop_ordering": {"LoopOrderingTest": 0.198}, "inductor/test_max_autotune": {"TestMaxAutotune": 0.17500000000000004, "TestTuningProcess": 0.002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.21}, "inductor/test_metrics": {"TestMetrics": 0.006}, "inductor/test_minifier": {"MinifierTests": 0.20800000000000002}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 0.201}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 0.010000000000000002, "TestPatternMatcher": 0.23800000000000007}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.026000000000000016}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 0.019000000000000003}, "inductor/test_multi_kernel": {"MultiKernelTest": 0.225}, "inductor/test_pad_mm": {"PadMMTest": 0.14300000000000002}, "inductor/test_padding": {"PaddingTest": 0.131, "PerfTestBetweenGoodAndBadShape": 0.003, "PerfTestWithAndWithoutPadding": 0.136}, "inductor/test_pattern_matcher": {"TestPaternMatcher": 0.03900000000000002, "TestPatternMatcher": 0.044000000000000025}, "inductor/test_perf": {"FusionTests": 0.01800000000000001, "InplacingTests": 0.009000000000000001, "MinCutPartitioningTests": 0.009000000000000001, "NoopTests": 0.006, "NumBytesMetricTests": 0.14500000000000002, "SchedulerFusionTests": 0.004, "TilingTests": 0.002}, "inductor/test_profiler": {"DynamoProfilerTests": 0.20600000000000002}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 0.14200000000000002}, "inductor/test_smoke": {"SmokeTest": 0.225}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 0.007, "MemoryBoundedTests": 0.004, "TestCommAnalysis": 0.009000000000000001, "UnsupportedTests": 0.123}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 0.138}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 0.24000000000000002}, "inductor/test_storage_offset": {"StorageOffsetTests": 0.001}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.05100000000000003}, "inductor/test_torchbind": {"TestTorchbind": 0.203}, "inductor/test_torchinductor": {"CpuTests": 223.85800000000208, "CudaTests": 0.46000000000000035, "GPUTests": 81.17700000000198, "NanCheckerTest": 0.002, "RNNTest": 0.001, "SweepInputsCpuTest": 0.06400000000000004, "SweepInputsCudaTest": 0.06400000000000004, "SweepInputsGPUTest": 0.06400000000000004, "TestFull": 0.001, "TritonCodeGenTests": 161.57100000000005}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 232.03100000000185, "DynamicShapesCodegenCudaTests": 55.709999999999376, "DynamicShapesCodegenGPUTests": 168.6920000000019}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 291.9179999999912, "DynamicShapesCudaTests": 62.377999999999325, "DynamicShapesGPUTests": 175.416000000002, "TestInductorDynamicCUDA": 0.05100000000000004}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 6.74300000000062}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.001}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.214}, "inductor/test_triton_kernels": {"KernelTests": 0.3560000000000001, "MutationTests": 0.02900000000000002, "NoOptimizationKernelTests": 0.1440000000000001, "no_opt_test_class": 0.2430000000000001}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 0.201}, "inductor/test_unbacked_symints": {"TestUnbackedSymints": 0.20400000000000001, "TestUnbackedSymintsCUDA": 0.010000000000000002}, "inductor/test_utils": {"TestUtils": 0.208}, "lazy/test_debug_util": {"DebugUtilTest": 0.201}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.206}, "lazy/test_generator": {"LazyGeneratorTest": 0.203}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.213}, "lazy/test_step_closures": {"ClosuresTest": 0.201}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.002, "TestLazyTensor": 0.003}, "nn/test_convolution": {"TestConvolutionNN": 0.13700000000000004, "TestConvolutionNNDeviceTypeCUDA": 0.5500000000000004}, "nn/test_dropout": {"TestDropoutNN": 0.004, "TestDropoutNNDeviceTypeCUDA": 0.007}, "nn/test_embedding": {"TestEmbeddingNN": 0.022000000000000013, "TestEmbeddingNNDeviceTypeCUDA": 0.12800000000000009}, "nn/test_init": {"TestNNInit": 0.344}, "nn/test_lazy_modules": {"TestLazyModules": 0.06600000000000004}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.03600000000000002, "TestLoadStateDictSwap": 0.002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.007, "TestModuleHookNN": 0.016000000000000007, "TestModuleHooks": 0.02800000000000001, "TestStateDictHooks": 0.014000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 0.007, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.012000000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.20800000000000002}, "nn/test_parametrization": {"TestNNParametrization": 0.057000000000000044, "TestNNParametrizationDeviceCUDA": 0.002}, "nn/test_pooling": {"TestAvgPool": 0.008, "TestPoolingNN": 0.014000000000000005, "TestPoolingNNDeviceTypeCUDA": 23.215000000000078}, "nn/test_pruning": {"TestPruningNN": 0.044000000000000025}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.015000000000000003}, "profiler/test_memory_profiler": {"TestDataFlow": 0.010000000000000002, "TestIdentifyGradients": 0.005, "TestMemoryProfiler": 0.204, "TestMemoryProfilerE2E": 0.017000000000000008}, "profiler/test_profiler": {"TestExecutionTrace": 0.007, "TestExperimentalUtils": 0.02600000000000001, "TestProfiler": 0.04100000000000003, "TestProfilerCUDA": 0.003, "TestProfilerITT": 0.001, "TestRecordFunction": 0.004, "TestTorchTidyProfiler": 0.022000000000000013}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.21}, "profiler/test_record_function": {"TestRecordFunction": 0.20600000000000002}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 0.22300000000000003}, "test_ao_sparsity": {"TestActivationSparsifier": 0.001, "TestBaseDataScheduler": 0.004, "TestBaseDataSparsifier": 0.004, "TestBaseSparsifier": 0.009000000000000001, "TestBaseStructuredSparsifier": 0.01800000000000001, "TestComposability": 0.007, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.002, "TestFakeSparsity": 0.004, "TestFxComposability": 0.005, "TestNearlyDiagonalSparsifier": 0.005, "TestNormDataSparsifiers": 0.003, "TestQuantizationUtils": 0.002, "TestQuantizedSparseKernels": 0.123, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.002, "TestScheduler": 0.004, "TestSparsityUtilFunctions": 0.008, "TestWeightNormSparsifier": 0.006}, "test_autocast": {"TestAutocastCPU": 0.218, "TestAutocastGPU": 0.002, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.012000000000000004, "TestAutograd": 4.156000000000038, "TestAutogradComplex": 0.002, "TestAutogradDeviceTypeCUDA": 0.06400000000000004, "TestAutogradForwardMode": 0.02900000000000002, "TestAutogradForwardModeBatchedGrad": 0.005, "TestAutogradFunctional": 0.12500000000000008, "TestAutogradInferenceMode": 0.01900000000000001, "TestAutogradLogging": 0.003, "TestAutogradMultipleDispatchCUDA": 0.008, "TestMultithreadAutograd": 0.012000000000000004, "TestNestedCheckpoint": 0.014000000000000005}, "test_autograd_fallback": {"TestAutogradFallback": 0.23600000000000002}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 18.288999999998584}, "test_bundled_inputs": {"TestBundledInputs": 0.21200000000000002}, "test_comparison_utils": {"TestComparisonUtils": 0.215}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.017000000000000005}, "test_content_store": {"TestContentStoreCUDA": 0.004}, "test_cpp_api_parity": {"TestCppApiParity": 0.4920000000000004}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.017000000000000005, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.016000000000000004, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 130.31800000000004}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.001}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 2.0689999999999977}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0}, "test_cuda": {"TestBlockStateAbsorption": 0.011000000000000003, "TestCuda": 15.863999999999981, "TestCudaMallocAsync": 0.01800000000000001, "TestCudaOptimsCUDA": 0.013000000000000005}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.011000000000000003, "TestCuda": 16.25499999999999, "TestCudaMallocAsync": 0.017000000000000008, "TestCudaOptimsCUDA": 0.013000000000000005}, "test_cuda_multigpu": {"TestCudaComm": 0.015000000000000006, "TestCudaMultiGPU": 0.028000000000000004}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.006, "TestVisibleDeviceParses": 0.003}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.003}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.20800000000000002, "TestEventHandler": 0.02100000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 1.7010000000000003}, "test_custom_backend": {"TestCustomBackend": 0.074}, "test_custom_ops": {"MiniOpTest": 0.06700000000000005, "MiniOpTestOther": 0.012000000000000004, "TestCustomOp": 0.08900000000000007, "TestCustomOpAPI": 0.02900000000000002, "TestCustomOpTestingCUDA": 0.028000000000000018, "TestCustomOperators": 0.29800000000000004, "TestGenerateOpcheckTests": 0.010000000000000002}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 91.89, "TestConcatDataset": 0.006, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.003, "TestDataLoader": 200.9340000000001, "TestDataLoaderDeviceTypeCUDA": 0.003, "TestDataLoaderPersistentWorkers": 198.20600000000013, "TestDatasetRandomSplit": 0.009000000000000001, "TestDictDataLoader": 0.004, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.001, "TestSetAffinity": 0.001, "TestStackDataset": 0.009000000000000001, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.005}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.002, "TestDataChunk": 0.006, "TestDataFramesPipes": 0.001, "TestFunctionalIterDataPipe": 0.01900000000000001, "TestFunctionalMapDataPipe": 0.009000000000000001, "TestGraph": 0.006, "TestIterDataPipeCountSampleYielded": 0.005, "TestIterDataPipeGraphFastForward": 0.005, "TestIterDataPipeSingletonConstraint": 0.005, "TestIterableDataPipeBasic": 0.022, "TestSerialization": 0.002, "TestSharding": 0.008, "TestStreamWrapper": 0.21, "TestTyping": 0.003}, "test_decomp": {"DecompOneOffTestsCUDA": 0.010000000000000002, "HasDecompTest": 0.002, "TestDecompCUDA": 5141.326000000731}, "test_deploy": {"TestFreezer": 0.201}, "test_dispatch": {"TestDispatch": 0.16200000000000003, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCUDA": 0.11800000000000009}, "test_dynamic_shapes": {"TestDimConstraints": 0.004, "TestFloorDiv": 0.004, "TestPySymInt": 0.29200000000000004, "TestSymNumberMagicMethods": 0.35400000000000026}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 0.09100000000000007, "TestExpandedWeightHelperFunctionCUDA": 0.009000000000000001, "TestExpandedWeightModuleCUDA": 0.1240000000000001}, "test_fake_tensor": {"FakeTensorConstHandling": 0.010000000000000002, "FakeTensorConverterTest": 0.010000000000000002, "FakeTensorDispatchCache": 0.02000000000000001, "FakeTensorOpInfoTestCUDA": 0.011000000000000003, "FakeTensorOperatorInvariants": 0.012000000000000004, "FakeTensorPropTest": 0.004, "FakeTensorSerialization": 0.002, "FakeTensorTest": 0.05600000000000004, "PropagateRealTensorsFakeTensorConstHandling": 0.010000000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.010000000000000002, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.012000000000000004, "PropagateRealTensorsFakeTensorPropTest": 0.004, "PropagateRealTensorsFakeTensorTest": 0.05600000000000004}, "test_flop_counter": {"TestFlopCounter": 0.026000000000000013}, "test_foreach": {"TestForeachCUDA": 3.4859999999997298}, "test_function_schema": {"TestFunctionSchema": 0.21400000000000002}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 78.369}, "test_functional_optim": {"TestFunctionalOptimParity": 0.228}, "test_functionalization": {"TestCrossRefFunctionalization": 0.05600000000000004, "TestFunctionalization": 0.25200000000000006}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 0.010000000000000002}, "test_futures": {"TestFuture": 0.22200000000000003}, "test_fx": {"AnnotationsTest": 0.007, "TestCSEPass": 0.015000000000000006, "TestCommonPass": 0.016000000000000007, "TestConstFold": 0.02000000000000001, "TestConstParamShapeInControlFlow": 0.006, "TestDCE": 0.007, "TestFX": 0.18500000000000014, "TestFXAPIBackwardCompatibility": 0.005, "TestFunctionalTracing": 0.12500000000000008, "TestMatcher": 0.008, "TestOperatorSignaturesCUDA": 0.6920000000000005, "TestPassManager": 0.006, "TestSourceMatcher": 0.005, "TestSubgraphRewriter": 0.027000000000000017, "TestVisionTracing": 209.526, "TypeCheckerTest": 0.03100000000000002}, "test_fx_experimental": {"TestFXExperimental": 0.04100000000000003, "TestNormalizeOperatorsCUDA": 0.6690000000000005, "TestTranslationValidation": 0.004}, "test_fx_passes": {"TestFXGraphPasses": 0.22800000000000004, "TestFXMatcherUtils": 0.016000000000000007}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.20600000000000002}, "test_import_stats": {"TestImportTime": 0.207}, "test_indexing": {"NumpyTestsCUDA": 0.02100000000000001, "TestIndexingCUDA": 0.06600000000000004}, "test_itt": {"TestItt": 0.207}, "test_jit": {"TestAliasAnalysis": 0.004, "TestAsync": 0.02100000000000001, "TestAtenPow": 0.001, "TestAutodiffJit": 0.005, "TestAutodiffSubgraphSlicing": 0.01900000000000001, "TestAwait": 0.017000000000000008, "TestBackends": 0.003, "TestBackendsWithCompiler": 0.002, "TestBatchMM": 0.008, "TestBuiltins": 0.004, "TestCUDA": 0.004, "TestClassType": 0.04500000000000003, "TestComplex": 0.014000000000000005, "TestCustomOperators": 0.014000000000000005, "TestDCE": 0.002, "TestDataParallel": 0.0, "TestDataclasses": 0.007, "TestDeviceAnalysis": 0.016000000000000007, "TestDict": 0.028000000000000018, "TestDtypeAnalysis": 0.278, "TestEnum": 0.017000000000000008, "TestFreezing": 0.05400000000000004, "TestFrontend": 0.002, "TestFrozenOptimizations": 0.03400000000000002, "TestFunctionalBlocks": 0.001, "TestFunctionalToInplaceActivation": 0.004, "TestGenerator": 0.005, "TestGetDefaultAttr": 0.003, "TestGraphRewritePasses": 0.001, "TestHash": 0.009000000000000001, "TestHooks": 0.023000000000000013, "TestIgnorableArgs": 0.002, "TestIgnoreContextManager": 0.003, "TestInplaceToFunctionalActivation": 0.002, "TestIsinstance": 0.02900000000000002, "TestJit": 0.6890000000000001, "TestJitGeneratedModule": 6.1500000000000155, "TestJitProfiler": 0.001, "TestJitUtils": 0.008, "TestList": 0.08100000000000006, "TestLogging": 0.006, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.024000000000000014, "TestMixTracingScripting": 0.022000000000000013, "TestModels": 5.260000000000002, "TestModuleAPIs": 0.003, "TestModuleContainers": 0.01800000000000001, "TestModuleInterface": 0.016000000000000007, "TestModules": 0.001, "TestNamedTuple": 0.013000000000000005, "TestNnapiBackend": 8.940999999999997, "TestOpDecompositions": 0.002, "TestOptimizeForMobilePreserveDebugInfo": 0.007, "TestParametrization": 0.002, "TestPeephole": 0.03900000000000003, "TestProducerVersion": 0.001, "TestProfiler": 0.453, "TestPythonBindings": 0.008, "TestPythonBuiltinOP": 0.015000000000000006, "TestPythonIr": 0.004, "TestRecursiveScript": 0.03200000000000002, "TestRemoveMutation": 0.008, "TestSaveLoad": 0.015000000000000006, "TestSaveLoadFlatbuffer": 0.010000000000000002, "TestSaveLoadForOpVersion": 0.011000000000000003, "TestScript": 0.5940000000000004, "TestScriptDict": 0.010000000000000002, "TestScriptList": 0.017000000000000008, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.01800000000000001, "TestScriptProfile": 0.005, "TestSlice": 0.01800000000000001, "TestSparse": 0.004, "TestStringFormatting": 0.022000000000000013, "TestSymbolicShapeAnalysis": 0.025000000000000015, "TestTensorBuiltins": 0.006, "TestTensorCreationOps": 0.006, "TestTensorMethods": 0.002, "TestTorchbind": 0.12900000000000006, "TestTracer": 0.1310000000000001, "TestTypeSharing": 0.025000000000000015, "TestTypesAndAnnotation": 0.016000000000000007, "TestTyping": 0.03900000000000003, "TestUnion": 0.04900000000000004, "TestUnsupportedOps": 0.002, "TestUpgraders": 0.014000000000000005, "TestWarn": 0.007, "TestWith": 0.006}, "test_jit_autocast": {"TestAutocast": 0.04900000000000003, "TestJitTraceAutocast": 0.008}, "test_jit_disabled": {"TestJitDisabled": 0.211}, "test_jit_fuser_te": {"TestFuserCommon": 0.001, "TestNNCOpInfoCUDA": 12.118000000000128, "TestTEFuserDynamic": 241.75400000000002, "TestTEFuserStatic": 233.67500000000007}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCUDA": 0.0, "TestModel": 0.001, "TestOpCUDA": 0.0}, "test_jiterator": {"TestPythonJiteratorCUDA": 0.2910000000000002}, "test_legacy_vmap": {"TestVmapAPI": 0.36600000000000005, "TestVmapAPILegacy": 0.046000000000000034, "TestVmapBatchedGradientCUDA": 0.02900000000000002, "TestVmapBatchedGradientLegacyCUDA": 0.02900000000000002, "TestVmapOperators": 0.05200000000000004, "TestVmapOperatorsLegacy": 0.05200000000000004}, "test_license": {"TestLicense": 0.201}, "test_linalg": {"TestLinalgCUDA": 1553.4379999999906}, "test_logging": {"LoggingTest": 0.2}, "test_masked": {"TestMaskedCUDA": 0.1460000000000001}, "test_maskedtensor": {"TestBasicsCUDA": 0.016000000000000007, "TestBinary": 0.06800000000000005, "TestOperatorsCUDA": 0.7240000000000005, "TestReductions": 0.01900000000000001, "TestUnary": 0.1210000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.001, "TestMatmulCudaCUDA": 0.028000000000000018, "TestMixedDtypesLinearCudaCUDA": 0.002}, "test_meta": {"TestMetaCUDA": 269.1849999997492, "TestMetaConverter": 0.02000000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 0.202}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.215}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 0.208}, "test_mobile_optimizer": {"TestOptimizer": 0.203}, "test_model_dump": {"TestModelDump": 0.213}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.199}, "test_module_init": {"TestModuleInitCUDA": 0.3880000000000003}, "test_module_tracker": {"TestModuleTracker": 0.203}, "test_modules": {"TestModuleCUDA": 455.5439999999491}, "test_monitor": {"TestMonitor": 0.202, "TestMonitorTensorboard": 0.101}, "test_multiprocessing": {"TestMultiprocessing": 31.451000000000032}, "test_multiprocessing_spawn": {"ErrorTest": 0.001, "ForkTest": 0.008, "SpawnTest": 0.225}, "test_namedtensor": {"TestNamedTensor": 0.08600000000000006}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 0.207}, "test_native_functions": {"TestNativeFunctions": 0.226}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.05400000000000004}, "test_nestedtensor": {"TestNestedTensor": 0.04900000000000004, "TestNestedTensorAutogradCUDA": 0.05600000000000004, "TestNestedTensorDeviceTypeCUDA": 0.1500000000000001, "TestNestedTensorSubclassCUDA": 0.23200000000000018}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.001, "TestFusionUtils": 0.002, "TestNN": 1.232999999999976, "TestNNDeviceTypeCUDA": 1.1999999999999795, "TestUtils": 0.001}, "test_numba_integration": {"TestNumbaIntegration": 0.013000000000000001}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.04100000000000003}, "test_openmp": {"TestOpenMP_ParallelFor": 0.19}, "test_ops": {"TestCommonCUDA": 139.87200000004788, "TestCompositeComplianceCUDA": 655.5129999999943, "TestFakeTensorCUDA": 666.9909999999956, "TestMathBitsCUDA": 3.1429999999998315, "TestSelfKwarg": 0.001, "TestTagsCUDA": 1.0159999999999993}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 95.9220000000137}, "test_ops_gradients": {"TestBwdGradientsCUDA": 749.3059999999405}, "test_ops_jit": {"TestJitCUDA": 76.87600000000157}, "test_optim": {"TestDifferentiableOptimizer": 0.011000000000000003, "TestLRScheduler": 0.28700000000000014, "TestOptim": 0.653, "TestOptimRenewedCUDA": 0.5090000000000003, "TestSWAUtils": 0.013000000000000005}, "test_out_dtype_op": {"TestOutDtypeOp": 0.02200000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.001, "TestGradCheckOverride": 0.001, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.001, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 1.660999999999929, "TestTorchFunctionWarning": 0.001, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.007, "ModelTest": 0.0, "TestAnalyze": 0.195, "TestDependencyAPI": 0.017000000000000008, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006, "TestLoadBCPackages": 0.003, "TestMangling": 0.010000000000000002, "TestMisc": 0.011000000000000003, "TestPackageFX": 0.006, "TestPackageScript": 0.023000000000000013, "TestRepackage": 0.001, "TestResources": 0.004, "TestSaveLoad": 0.011000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.20500000000000002}, "test_prims": {"TestDecompCUDA": 0.002, "TestPrimsBasic": 0.003, "TestPrimsCUDA": 0.012000000000000004, "TestRefsCUDA": 0.005}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.006, "TestGenericProxyTensorFake": 0.035000000000000024, "TestGenericProxyTensorReal": 0.037000000000000026, "TestGenericProxyTensorSymbolic": 0.035000000000000024, "TestRealProxyTensor": 0.001, "TestSymbolicTracing": 0.060000000000000046}, "test_pruning_op": {"PruningOpTest": 0.20400000000000001}, "test_public_bindings": {"TestPublicBindings": 0.22}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.001, "TestPythonDispatch": 0.07100000000000005, "TestPythonDispatcher": 0.002, "TestPythonRegistration": 0.01800000000000001, "TestWrapperSubclassAliasingCUDA": 0.01900000000000001}, "test_pytree": {"TestCxxPytree": 0.013000000000000005, "TestGenericPytree": 0.23900000000000005, "TestPythonPytree": 0.03000000000000002}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.018000000000000006, "TestAOMigrationQuantization": 0.011, "TestAOMigrationQuantizationFx": 0.012, "TestBackendConfig": 0.019000000000000003, "TestBiasCorrectionEager": 0.002, "TestBits": 0.002, "TestBitsCUDA": 0.004, "TestComparatorOps": 0.002, "TestDeprecatedJitQuantized": 0.004, "TestDistributed": 0.005, "TestDuplicateDQPass": 0.004, "TestDynamicQuantizedModule": 0.01, "TestDynamicQuantizedOps": 0.016, "TestEqualizeEager": 0.005, "TestEqualizeFx": 0.01, "TestFXGraphMatcher": 0.014000000000000002, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 0.04800000000000003, "TestFXNumericSuiteCoreAPIsModels": 0.013000000000000003, "TestFXNumericSuiteNShadows": 0.024000000000000007, "TestFakeQuantize": 0.003, "TestFakeQuantizeOps": 0.032000000000000015, "TestFloat8DtypeCUDA": 0.014000000000000002, "TestFuseEager": 0.010000000000000002, "TestFuseFx": 0.016, "TestFusedObsFakeQuant": 0.004, "TestFusedObsFakeQuantModule": 0.008, "TestFusionPasses": 0.001, "TestFxDetectInputWeightEqualization": 0.003, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.007, "TestFxModelReportObserver": 0.004, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.003, "TestHistogramObserver": 0.007, "TestMetaDataPorting": 0.006, "TestModelNumericsEager": 0.004, "TestNumericSuiteEager": 0.020000000000000004, "TestObserver": 0.014, "TestPT2ERepresentation": 0.008, "TestPadding": 0.003, "TestQNNPackOps": 0.012, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 0.003, "TestQuantizeDynamicJitPasses": 0.01, "TestQuantizeEagerOps": 0.011, "TestQuantizeEagerPTQDynamic": 0.013000000000000001, "TestQuantizeEagerPTQStatic": 0.021000000000000005, "TestQuantizeEagerQAT": 0.014, "TestQuantizeEagerQATNumerics": 0.009000000000000001, "TestQuantizeFx": 0.1530000000000001, "TestQuantizeFxModels": 0.008, "TestQuantizeFxOps": 0.05800000000000004, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.03000000000000001, "TestQuantizeJitPasses": 0.04000000000000002, "TestQuantizePT2E": 0.04000000000000002, "TestQuantizePT2EQAT": 441.7819999999999, "TestQuantizePT2EQATModels": 114.771, "TestQuantizePT2EQAT_ConvBn1d": 603.755, "TestQuantizePT2EQAT_ConvBn2d": 637.49, "TestQuantizePT2EX86Inductor": 191.34700000000004, "TestQuantizedConv": 0.029000000000000012, "TestQuantizedEmbeddingOps": 0.008, "TestQuantizedFunctionalOps": 0.005, "TestQuantizedLinear": 0.015, "TestQuantizedOps": 71.09900000000007, "TestQuantizedTensor": 0.06600000000000004, "TestRecordHistogramObserver": 0.002, "TestReferenceQuantizedModule": 0.004, "TestSerialization": 0.019000000000000006, "TestStaticQuantizedModule": 81.75499999999997, "TestSubgraphRewriter": 0.014000000000000002, "TestUtils": 0.006, "TestXNNPACKQuantizer": 0.02500000000000001, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCUDA": 4.772999999999932}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 0.07300000000000005}, "test_schema_check": {"TestSchemaCheck": 0.036000000000000025, "TestSchemaCheckModeOpInfoCUDA": 7.23900000000089}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 0.07400000000000005}, "test_serialization": {"TestBothSerializationCUDA": 0.002, "TestOldSerialization": 0.08000000000000003, "TestSerialization": 0.11500000000000006, "TestSubclassSerialization": 0.008}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.203}, "test_shape_ops": {"TestShapeOpsCUDA": 0.09300000000000007}, "test_show_pickle": {"TestShowPickle": 0.21}, "test_sort_and_select": {"TestSortAndSelectCUDA": 0.11200000000000009}, "test_sparse": {"TestSparseAnyCUDA": 286.91299999997153, "TestSparseCUDA": 0.2770000000000002, "TestSparseLegacyAndDeprecation": 0.001, "TestSparseMaskedReductionsCUDA": 0.04200000000000003, "TestSparseMeta": 0.04000000000000003, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCUDA": 1.3499999999999632}, "test_sparse_csr": {"TestSparseCSRCUDA": 2.063999999999885, "TestSparseCSRSampler": 0.001, "TestSparseCompressedCUDA": 2.981999999999785, "TestSparseCompressedTritonKernelsCUDA": 473.38299999999884}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.003, "TestCUSPARSELTCUDA": 0.1870000000000001, "TestSparseSemiStructuredCUDA": 2.3269999999999946, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.1870000000000001, "TestSparseSemiStructuredCUTLASSCUDA": 13.105000000000004, "TestSparseSemiStructuredTrainingCUDA": 5.288000000000002}, "test_spectral_ops": {"TestFFTCUDA": 0.34800000000000025}, "test_stateless": {"TestPythonOptimizeMode": 0.001, "TestStatelessDeprecation": 0.002, "TestStatelessFunctionalAPI": 0.054000000000000034}, "test_subclass": {"TestSubclass": 0.2690000000000001}, "test_sympy_utils": {"TestNumbers": 0.005, "TestSingletonInt": 0.001, "TestSympyInterp": 0.05600000000000004, "TestSympySolve": 0.028000000000000018, "TestValueRanges": 0.06800000000000005}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.1450000000000001, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.024000000000000014, "TestTensorCreationCUDA": 0.34100000000000025}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.002, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.131, "TestTensorBoardPytorchGraph": 0.006, "TestTensorBoardSummary": 0.01900000000000001, "TestTensorBoardSummaryWriter": 0.003, "TestTensorBoardUtils": 0.004, "TestTensorBoardWriter": 0.001, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 0.26500000000000007}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.001, "TestTensorExprPyBind": 0.226}, "test_testing": {"TestAssertClose": 0.03300000000000002, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.014000000000000005, "TestAssertCloseMultiDeviceCUDA": 0.002, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.004, "TestAssertCloseSparseBSR": 0.004, "TestAssertCloseSparseCOO": 0.006, "TestAssertCloseSparseCSC": 0.004, "TestAssertCloseSparseCSR": 0.004, "TestFrameworkUtils": 0.001, "TestImports": 0.006, "TestMakeTensorCUDA": 0.7320000000000005, "TestOpInfoSampleFunctionsCUDA": 1.3629999999999614, "TestOpInfos": 0.002, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCUDA": 0.027000000000000017, "TestTestingCUDA": 5.786000000000009}, "test_torch": {"TestBasicVitalSigns": 0.003, "TestDevicePrecisionCUDA": 0.02000000000000001, "TestTorch": 0.21500000000000016, "TestTorchDeviceTypeCUDA": 24.224000000000878, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 0.02100000000000001, "TestAttnMasksCUDA": 0.013500000000000005, "TestSDPACUDA": 1.3079999999999679, "TestSDPACudaOnlyCUDA": 77.67700000000633, "TestSDPAFailureModesCUDA": 0.04500000000000003, "TestTransformersCUDA": 0.654}, "test_type_hints": {"TestTypeHints": 0.225}, "test_type_info": {"TestDTypeInfo": 0.21}, "test_type_promotion": {"TestTypePromotionCUDA": 0.4260000000000003}, "test_typing": {"TestTyping": 59.177999999999976}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 25.78300000000862}, "test_utils": {"TestAssert": 0.002, "TestBottleneck": 0.001, "TestCheckpoint": 0.016000000000000007, "TestCollectEnv": 0.001, "TestCppExtensionUtils": 0.002, "TestDataLoaderUtils": 0.004, "TestDeviceUtilsCUDA": 6.042000000000369, "TestExtensionUtils": 0.002, "TestHipify": 0.001, "TestHipifyTrie": 0.004, "TestONNXUtils": 0.002, "TestRenderUtils": 0.001, "TestStandaloneCPPJIT": 0.001, "TestTraceback": 0.005}, "test_view_ops": {"TestOldViewOpsCUDA": 0.11600000000000009, "TestViewOpsCUDA": 0.16300000000000012}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.016, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 0.21200000000000002}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 294.85400000000004, "TestXNNPACKOps": 0.21, "TestXNNPACKRewritePass": 0.002, "TestXNNPACKSerDes": 0.004}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.001}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.228, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.017000000000000008, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 0.24100000000000005, "TestEinsumPath": 0.0, "TestMisc": 0.001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.2, "TestMisc": 0.001, "TestPythonFloat": 0.002, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.003, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.001, "TestFloatNonIntegerArgument": 0.004, "TestIndexing": 0.23900000000000005, "TestMultiIndexingAutomated": 0.003, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.012000000000000004, "TestArgmax": 0.06300000000000004, "TestArgmaxArgminCommon": 0.027000000000000017, "TestArgmin": 0.06300000000000004, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.134, "TestArrayCreationCopyArgument": 0.0, "TestArrayInterface": 0.012000000000000004, "TestAssignment": 0.003, "TestAttributes": 0.019000000000000006, "TestBinop": 0.001, "TestBool": 637.1739999999999, "TestCequenceMethods": 0.001, "TestChoose": 0.014, "TestClip": 0.002, "TestCompress": 0.003, "TestConversion": 0.002, "TestCreation": 0.0, "TestDelMisc": 0.001, "TestDot": 2.9330000000000003, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.006, "TestFlag": 0.012000000000000002, "TestFormat": 0.003, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.12, "TestHashing": 0.002, "TestIO": 0.0, "TestInner": 0.004, "TestLexsort": 0.012000000000000004, "TestMatmul": 0.3420000000000001, "TestMatmulOperator": 0.013000000000000005, "TestMethods": 0.11500000000000009, "TestMinMax": 0.002, "TestMinScalarType": 0.004, "TestNewaxis": 0.001, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.011, "TestResize": 0.008, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.018, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.016000000000000007, "TestStats": 0.19999999999999998, "TestSubscripting": 0.001, "TestTake": 0.008, "TestVdot": 0.004, "TestViewDtype": 0.006, "TestWarnings": 0.001, "TestWhere": 0.008, "TestWritebackIfCopy": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.005, "TestArgwhere": 0.005, "TestArrayComparisons": 0.004, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006, "TestBoolArray": 0.003, "TestBoolCmp": 0.002, "TestBoolScalar": 0.007, "TestBroadcast": 0.005, "TestClip": 0.05300000000000004, "TestConvolve": 0.004, "TestCorrelate": 0.004, "TestCreationFuncs": 0.005, "TestCross": 0.006, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006, "TestFromiter": 0.0, "TestIndex": 0.002, "TestIndices": 0.016000000000000007, "TestIsclose": 0.008, "TestIsscalar": 0.001, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.005, "TestNonarrayArgs": 0.03900000000000003, "TestNonzeroAndCountNonzero": 0.023000000000000013, "TestOuterMisc": 0.001, "TestRequire": 0.004, "TestResize": 0.20600000000000002, "TestRoll": 0.003, "TestRollaxis": 0.002, "TestSeterr": 0.004, "TestStdVar": 0.005, "TestStdVarComplex": 0.002, "TestStringFunction": 0.001, "TestTensordot": 0.003, "TestTypes": 0.005}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.208, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.060000000000000046, "TestFromInt": 0.002, "TestFromString": 0.20500000000000002}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.001, "TestClassGetitemMisc": 0.001, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.010000000000000002, "TestBaseMath": 0.002, "TestBitShifts": 0.010000000000000002, "TestComplexDivision": 0.002, "TestConversion": 0.006, "TestHash": 0.0, "TestModulus": 44.54899999999999, "TestMultiply": 0.0, "TestNegative": 0.002, "TestPower": 0.004, "TestRepr": 0.001, "TestScalarOpsMisc": 0.028000000000000018, "TestScalarSubclassingMisc": 0.010000000000000002, "TestSubtract": 0.002, "TestTypes": 0.208}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.212, "TestAtleast2d": 0.005, "TestAtleast3d": 0.004, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.047000000000000035, "TestHstack": 0.007, "TestStackMisc": 0.003, "TestVstack": 0.007}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.001, "TestFFTShift": 0.214, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.07400000000000005, "TestFFTShift": 0.204, "TestFFTThreadSafe": 0.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.20700000000000002}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.001, "TestUnique": 0.212}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.002, "TestAmax": 0.001, "TestAmin": 0.001, "TestAngle": 0.001, "TestAny": 0.002, "TestAverage": 0.004, "TestBincount": 0.013000000000000005, "TestCheckFinite": 0.002, "TestCopy": 0.002, "TestCorrCoef": 0.009000000000000001, "TestCov": 0.013000000000000005, "TestCumprod": 0.001, "TestCumsum": 0.001, "TestDelete": 0.015, "TestDiff": 0.006, "TestDigitize": 0.011000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.1210000000000001, "TestFlip": 0.007, "TestGradient": 0.01800000000000001, "TestInsert": 0.006, "TestInterp": 0.02900000000000002, "TestKaiser": 0.002, "TestMedian": 0.015000000000000006, "TestMeshgrid": 0.011000000000000003, "TestMsort": 0.0, "TestPercentile": 0.02900000000000002, "TestPiecewise": 0.008, "TestProd": 0.001, "TestPtp": 0.001, "TestQuantile": 0.006, "TestRot90": 0.2, "TestSelect": 0.006, "TestSinc": 0.002, "TestSortComplex": 0.007, "TestTrapz": 0.002, "TestTrimZeros": 0.008, "TestUnique": 0.002, "Test_I0": 0.002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.43600000000000005, "TestHistogramOptimBinNums": 0.017000000000000008, "TestHistogramdd": 0.017000000000000008}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.001, "TestDiagIndicesFrom": 0.003, "TestFillDiagonal": 0.007, "TestGrid": 0.007, "TestIndexExpression": 0.002, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.215}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.010000000000000002, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.009000000000000001, "TestColumnStack": 0.004, "TestDsplit": 0.005, "TestDstack": 0.006, "TestExpandDims": 0.004, "TestHsplit": 0.004, "TestKron": 0.001, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.002, "TestSplit": 0.002, "TestSqueeze": 0.005, "TestTakeAlongAxis": 0.209, "TestTile": 0.004, "TestVsplit": 0.004}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.005, "TestEye": 0.213, "TestFliplr": 0.001, "TestFlipud": 0.001, "TestHistogram2d": 0.006, "TestTri": 0.007, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.205, "TestImag": 0.002, "TestIscomplex": 0.002, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.003, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.003, "TestReal": 0.002, "TestRealIfClose": 0.001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.02100000000000001, "TestCond": 0.28500000000000003, "TestDet": 0.191, "TestEig": 0.047, "TestEigh": 0.007, "TestEighCases": 0.0, "TestEigvals": 0.07100000000000001, "TestEigvalsh": 0.007, "TestEigvalshCases": 0.0, "TestInv": 0.07300000000000001, "TestLstsq": 0.012000000000000004, "TestMatrixRank": 0.003, "TestMisc": 0.274, "TestMisc2": 0.001, "TestMultiDot": 0.011000000000000003, "TestNormDouble": 0.010000000000000002, "TestNormInt64": 0.010000000000000002, "TestNormSingle": 0.010000000000000002, "TestNorm_NonSystematic": 0.001, "TestPinv": 0.20500000000000002, "TestPinvHermitian": 0.057, "TestQR": 0.012000000000000004, "TestSVD": 0.046000000000000006, "TestSVDHermitian": 0.138, "TestSolve": 0.277, "TestTensorinv": 0.007, "TestTensorsolve": 0.003}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.003, "TestCtorNested": 0.001, "TestDefaultDtype": 0.004, "TestDivmod": 0.005, "TestExport": 0.0, "TestMisc": 0.002, "TestNormalizations": 0.003, "TestOneArr": 0.23400000000000018, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.003, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.24300000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.263}, "torch_np/test_function_base": {"TestAppend": 0.209}, "torch_np/test_ndarray_methods": {"TestAmax": 0.001, "TestAmin": 0.001, "TestArgmax": 0.07500000000000005, "TestArgmaxArgminCommon": 0.028000000000000018, "TestArgmin": 0.07500000000000005, "TestContains": 0.001, "TestIndexing": 0.205, "TestIter": 0.002, "TestNoExtraMethods": 0.006, "TestNonzero": 0.005, "TestRavel": 0.002, "TestReshape": 0.002, "TestTranspose": 0.002}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.011, "TestNEP50Table": 0.001}, "torch_np/test_random": {"TestChoice": 0.002, "TestNumpyGlobal": 0.001, "TestScalarReturn": 0.22600000000000003, "TestShuffle": 0.006}, "torch_np/test_reductions": {"TestAll": 0.003, "TestAny": 0.003, "TestFlatnonzero": 0.196, "TestGenericCumSumProd": 0.008, "TestGenericReductions": 0.9330000000000007, "TestMean": 0.004, "TestSum": 0.010000000000000002}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.217, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3080000000000002, "TestNdarrayDunderVsUfunc": 0.03000000000000002, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.21000000000000002}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.24200000000000005}}}, "linux-focal-cuda12.4-py3.10-gcc9": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 3.316}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.8884999999999996}, "distributions/test_distributions": {"TestAgainstScipy": 2.549, "TestConstraints": 0.324, "TestDistributionShapes": 0.2610000000000001, "TestDistributions": 76.40100000000001, "TestFunctors": 0.019500000000000003, "TestJit": 39.9565, "TestKL": 4.961, "TestLazyLogitsInitialization": 0.028000000000000004, "TestNumericalStability": 0.15000000000000005, "TestRsample": 1.354, "TestValidation": 0.8225}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 1.0190000000000001}, "dynamo/test_after_aot": {"TestAfterAot": 9.982}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 26.787000000000003}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.5139999999999993, "AOTAutogradCacheTests": 18.858999999999998}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 5.318999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.07200000000000001, "TestCustomBackendAPI": 3.4899999999999993, "TestExplainWithBackend": 17.5795, "TestOptimizations": 3.5254999999999996}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 23.0795}, "dynamo/test_base_output": {"TestBaseOutput": 0.009000000000000001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.342}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 9.1585, "BytecodeTests": 0.9195}, "dynamo/test_compile": {"InPlaceCompilationTests": 11.982, "PublicTorchCompilerTests": 0.0045000000000000005}, "dynamo/test_comptime": {"ComptimeTests": 1.1690000000000003}, "dynamo/test_config": {"ConfigTests": 1.1560000000000001}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.738999999999998}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 6.555499999999999}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.47750000000000004}, "dynamo/test_decorators": {"DecoratorTests": 10.314999999999998}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0045000000000000005, "TestDeviceGuard": 0.03}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 725.9025000000003, "DynamicShapesCtxManagerTests": 13.776499999999999, "DynamicShapesExportTests": 57.653499999999994, "DynamicShapesFuncTorchHigherOrderOpTests": 149.99150000000003, "DynamicShapesFunctionTests": 124.48350000000008, "DynamicShapesHigherOrderOpTests": 32.2375, "DynamicShapesMiscTests": 170.226, "DynamicShapesNNModuleTests": 13.1645, "DynamicShapesReproTests": 186.8685000000001, "DynamicShapesSubGraphTests": 17.323, "DynamicShapesTestSDPA": 0.7075}, "dynamo/test_exc": {"ExcTests": 3.732}, "dynamo/test_exceptions": {"ExceptionTests": 1.06}, "dynamo/test_export": {"ExportTests": 29.740999999999993}, "dynamo/test_export_mutations": {"MutationExportTests": 1.1030000000000002}, "dynamo/test_frame_init": {"FrameInitTests": 0.4025}, "dynamo/test_functions": {"DefaultsTests": 1.479, "FunctionTests": 57.606500000000224}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 2.1065}, "dynamo/test_global": {"TestGlobals": 1.0665000000000002}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.4660000000000001}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.15400000000000003, "FuncTorchHigherOrderOpTests": 15.913499999999999, "HigherOrderOpTests": 15.270000000000003, "HigherOrderOpVmapGuardTests": 7.671}, "dynamo/test_hooks": {"HooksTests": 50.64350000000002}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 19.963, "InlineInbuiltNNModulesExportTests": 39.951999999999984, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 16.132500000000004, "InlineInbuiltNNModulesFunctionTests": 31.391000000000005, "InlineInbuiltNNModulesHigherOrderOpTests": 14.988499999999995, "InlineInbuiltNNModulesMiscTests": 106.80050000000023, "InlineInbuiltNNModulesNNModuleTests": 9.240999999999998}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 13.151999999999997}, "dynamo/test_interop": {"InteropTests": 1.1480000000000001}, "dynamo/test_logging": {"LoggingTests": 29.994500000000006}, "dynamo/test_minifier": {"MinifierTests": 4.6375}, "dynamo/test_misc": {"MiscTests": 104.02050000000023, "TestTracer": 0.10600000000000001}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.02250000000000001}, "dynamo/test_modules": {"NNModuleTests": 5.860499999999995, "OptimizedModuleTest": 30.9465}, "dynamo/test_nops": {"NopTests": 0.571}, "dynamo/test_optimizers": {"End2EndTests": 1.289}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.9855}, "dynamo/test_profiler": {"DynamoProfilerTests": 2.6825}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.381}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.8394999999999997}, "dynamo/test_recompiles": {"RecompileTests": 1.7715}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 1.1215000000000002}, "dynamo/test_repros": {"ReproTests": 87.46100000000007}, "dynamo/test_resume": {"ResumeFunctionTests": 0.8714999999999999}, "dynamo/test_sdpa": {"TestSDPA": 0.978}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 1.1125}, "dynamo/test_sources": {"SourceTests": 1.0294999999999999}, "dynamo/test_structured_trace": {"StructuredTraceTest": 23.4565}, "dynamo/test_subclasses": {"SubclassTests": 5.7609999999999975, "TestNestedTensor": 19.7875}, "dynamo/test_subgraphs": {"SubGraphTests": 4.435499999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.2025, "TraceRuleTests": 2.3625}, "dynamo/test_unspec": {"UnspecTests": 23.637999999999998}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 1.1435000000000002}, "dynamo/test_view": {"ViewTests": 1.26}, "export/test_converter": {"TestConverter": 10.275500000000001}, "export/test_db": {"ExampleTests": 6.1695}, "export/test_experimental": {"TestExperiment": 1.997}, "export/test_export": {"TestDynamismExpression": 0.903, "TestExport": 51.239000000000004, "TestExportCustomClass": 0.1295, "TestOneOffModelExportResult": 2.1245000000000003}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.7894999999999999, "NonStrictExportTestExport": 45.24899999999999}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.396}, "export/test_hop": {"TestHOPCUDA": 5.956, "TestHOPGeneric": 0.006}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0035, "TestLift": 0.1835}, "export/test_pass_infra": {"TestPassInfra": 1.7715}, "export/test_passes": {"TestPasses": 24.3455}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.906, "RetraceExportTestExport": 81.20600000000002}, "export/test_schema": {"TestSchema": 0.46799999999999997}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 1.0574999999999999, "SerDesExportTestExport": 54.355500000000035}, "export/test_serialize": {"TestDeserialize": 15.8385, "TestSaveLoad": 0.584, "TestSchemaVersioning": 0.0595, "TestSerialize": 2.123, "TestSerializeCustomClass": 0.168}, "export/test_sparse": {"TestSparseProp": 123.95549999999992}, "export/test_tools": {"TestExportTools": 1.073}, "export/test_torchbind": {"TestCompileTorchbind": 2.0625000000000004, "TestExportTorchbind": 3.557999999999999, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.4055}, "export/test_unflatten": {"TestUnflatten": 6.305000000000001}, "export/test_verifier": {"TestVerifier": 1.9385}, "functorch/test_aotdispatch": {"TestAOTAutograd": 26.439000000000004, "TestAOTAutogradWithDynamo": 27.994, "TestAOTDispatch": 1.0645, "TestAOTExport": 4.367999999999999, "TestAOTModuleSimplified": 1.259, "TestPartitioning": 6.734}, "functorch/test_control_flow": {"TestControlFlow": 1.7039999999999997, "TestControlFlowTraced": 211.20450000000005}, "functorch/test_dims": {"TestMin": 24.408500000000004, "TestMinFunctorchOnly": 23.398000000000003}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.1750000000000001, "TestAutogradFunctionVmapAPICUDA": 0.052500000000000005, "TestCompileTransformsCUDA": 7.0235, "TestComposabilityCUDA": 0.2975000000000001, "TestExamplesCorrectnessCUDA": 6.853, "TestFunctionalizeCUDA": 0.20650000000000007, "TestGradTransformCUDA": 2.173999999999999, "TestHelpersCUDA": 0.0325, "TestHessianCUDA": 0.162, "TestHigherOrderOperatorInteractionCUDA": 0.051000000000000004, "TestJacCUDA": 1.3555000000000006, "TestJvpCUDA": 0.12450000000000003, "TestLinearizeCUDA": 0.5215000000000001, "TestMakeFunctional": 0.13350000000000004, "TestSliceArgnums": 0.030000000000000006, "TestVmapJvpInplaceViewCUDA": 0.035500000000000004, "TestVmapOfGradCUDA": 0.8035000000000001}, "functorch/test_logging": {"TestAOTLogging": 0.511}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.5960000000000001, "RandomOpTestCase": 0.1615, "ReduceTestCase": 0.159, "TestMemoryEfficientOpAuthoring": 10.3305}, "functorch/test_minifier": {"TestMinifier": 0.8635000000000002}, "functorch/test_ops": {"TestOperatorsCUDA": 7612.255000000001}, "functorch/test_parsing": {"TestAnonymousAxis": 0.4045, "TestParsedExpression": 0.009000000000000001, "TestParsingUtils": 0.0105, "TestValidateRearrangeExpressions": 0.009000000000000001}, "functorch/test_rearrange": {"TestRearrange": 0.4935000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 2.0225, "TestTransformFailureCUDA": 0.199, "TestVmapAPI": 0.5960000000000001, "TestVmapBatchedGradientCUDA": 0.4270000000000001, "TestVmapDeviceTypeCUDA": 0.044, "TestVmapNestedTensorCUDA": 0.08549999999999999, "TestVmapOperators": 5.565499999999995, "TestVmapOperatorsOpInfoCUDA": 611.7870000000006}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 4.631499999999825}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.958}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 18.3655}, "inductor/test_binary_folding": {"FreezingCpuTests": 74.3675}, "inductor/test_codecache": {"TestFxGraphCache": 74.57399999999996, "TestFxGraphCacheHashing": 1.6249999999999998, "TestUtils": 7.125, "test_codecache": 0.001}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.43499999999999994}, "inductor/test_compile_worker": {"TestCompileWorker": 14.685}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 615.8835000000012, "TestCompiledAutograd": 365.287, "TestCustomOpWithCompiledAutograd": 2.048499999999999}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 0.1715000000000001, "CompiledOptimizerTests": 491.1729999999999}, "inductor/test_config": {"TestInductorConfig": 12.4095}, "inductor/test_control_flow": {"CondTests": 0.05250000000000003, "WhileLoopTests": 0.027000000000000014}, "inductor/test_cpu_repro": {"CPUReproTests": 1219.1635000000003}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0045000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 23.211}, "inductor/test_debug_trace": {"TestDebugTrace": 6.9435}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.005}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 77.3465}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0025}, "inductor/test_extension_backend": {"ExtensionBackendTests": 36.346000000000004}, "inductor/test_flex_attention": {"TestFlexAttention": 0.1540000000000001}, "inductor/test_foreach": {"ForeachTests": 36.19800000000029}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 154.58399999999997, "SDPAPatternRewriterCpuTests": 149.895}, "inductor/test_fx_fusion": {"TestFxFusion": 0.3825}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.028999999999999998}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.3155, "TestGroupBatchFusion": 0.0015, "TestPostGradBatchLinearFusion": 0.0015}, "inductor/test_indexing": {"ExprPrinterTests": 0.08499999999999999, "TestIndexingSimplification": 1.1565}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 99.68499999999997}, "inductor/test_minifier": {"MinifierTests": 48.599500000000006}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 85.66300000000001}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 181.07750000000001, "TestPatternMatcher": 895.1395000000002}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.033000000000000015}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 36.6035}, "inductor/test_torchbind": {"TestTorchbind": 12.778}, "inductor/test_torchinductor": {"CpuTests": 2788.9324999999994, "SweepInputsCpuTest": 244.89799999999997, "TestFull": 21.1405}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2984.9004999999993}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 3155.2454999999995, "TestInductorDynamicCUDA": 0.12650000000000006}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 25.019999999999918}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 1.081}, "inductor/test_triton_kernels": {"KernelTests": 0.22950000000000015, "MutationTests": 0.025500000000000012}, "inductor/test_utils": {"TestUtils": 0.396}, "lazy/test_debug_util": {"DebugUtilTest": 0.5445}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.5855}, "lazy/test_generator": {"LazyGeneratorTest": 0.585}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.8355}, "lazy/test_step_closures": {"ClosuresTest": 3.4749999999999996}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.334, "TestLazyTensor": 0.135}, "nn/test_convolution": {"TestConvolutionNN": 37.33850000000001, "TestConvolutionNNDeviceTypeCUDA": 30.209500000000176}, "nn/test_dropout": {"TestDropoutNN": 0.241, "TestDropoutNNDeviceTypeCUDA": 1.221}, "nn/test_embedding": {"TestEmbeddingNN": 0.24250000000000005, "TestEmbeddingNNDeviceTypeCUDA": 27.34649999999999}, "nn/test_init": {"TestNNInit": 6.916999999999998}, "nn/test_lazy_modules": {"TestLazyModules": 0.5875000000000002}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.084, "TestLoadStateDictSwap": 0.11050000000000001}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.0395, "TestModuleHookNN": 0.1175, "TestModuleHooks": 0.15100000000000002, "TestStateDictHooks": 0.055999999999999994}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 9.507, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.5155000000000001}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.7895000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.5525, "TestNNParametrizationDeviceCUDA": 0.2485}, "nn/test_pooling": {"TestAvgPool": 0.623, "TestPoolingNN": 1.2189999999999999, "TestPoolingNNDeviceTypeCUDA": 15.360499999999995}, "nn/test_pruning": {"TestPruningNN": 0.1775000000000001}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.355}, "profiler/test_memory_profiler": {"TestDataFlow": 1.6564999999999999, "TestIdentifyGradients": 0.518, "TestMemoryProfiler": 0.5095000000000001, "TestMemoryProfilerE2E": 5.019000000000001}, "profiler/test_profiler": {"TestExperimentalUtils": 5.3934999999999995, "TestProfiler": 28.8955, "TestProfilerCUDA": 10.3355, "TestProfilerITT": 0.0035}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.5980000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.542}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.817499999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.1095, "TestBaseDataScheduler": 0.0565, "TestBaseDataSparsifier": 0.14650000000000002, "TestBaseSparsifier": 0.0445, "TestBaseStructuredSparsifier": 5.031499999999999, "TestComposability": 3.7575000000000003, "TestCubicScheduler": 0.0085, "TestFPGMPruner": 0.1235, "TestFakeSparsity": 0.12550000000000003, "TestFxComposability": 3.133, "TestNearlyDiagonalSparsifier": 1.4845000000000002, "TestNormDataSparsifiers": 1.8664999999999998, "TestQuantizationUtils": 0.036500000000000005, "TestQuantizedSparseKernels": 0.355, "TestQuantizedSparseLayers": 0.4945, "TestSaliencyPruner": 0.042, "TestScheduler": 0.0225, "TestSparsityUtilFunctions": 0.0685, "TestWeightNormSparsifier": 0.603}, "test_autocast": {"TestAutocastCPU": 3.7405, "TestAutocastGPU": 0.1945, "TestTorchAutocast": 0.0105}, "test_autograd": {"TestAllowMutationOnSaved": 0.05, "TestAutograd": 32.90199999999994, "TestAutogradComplex": 0.009000000000000001, "TestAutogradDeviceTypeCUDA": 2.031999999999999, "TestAutogradForwardMode": 0.12150000000000007, "TestAutogradForwardModeBatchedGrad": 0.030500000000000003, "TestAutogradFunctional": 22.4765, "TestAutogradInferenceMode": 0.058000000000000024, "TestAutogradLogging": 0.0245, "TestAutogradMultipleDispatchCUDA": 0.036500000000000005, "TestMultithreadAutograd": 0.4295000000000001, "TestNestedCheckpoint": 0.8400000000000001, "TestSelectiveActivationCheckpoint": 0.075}, "test_autograd_fallback": {"TestAutogradFallback": 0.6910000000000002}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 240.79250000000263}, "test_bundled_inputs": {"TestBundledInputs": 1.9404999999999992}, "test_comparison_utils": {"TestComparisonUtils": 0.4285}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_complex": {"TestComplexTensorCUDA": 0.21650000000000003}, "test_content_store": {"TestContentStoreCUDA": 0.1825}, "test_cpp_api_parity": {"TestCppApiParity": 18.573499999999918}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.3335, "TestMAIATensor": 0.012, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.005, "TestTorchLibrary": 0.101}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.329, "TestMAIATensor": 0.012, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.1}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 129.18800000000002}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0075}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 13.178500000000007}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0015}, "test_cuda": {"TestBlockStateAbsorption": 9.3415, "TestCuda": 123.40750000000006, "TestCudaMallocAsync": 36.13450000000001, "TestCudaOptimsCUDA": 4.727499999999998}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 9.9115, "TestCuda": 121.85850000000005, "TestCudaMallocAsync": 52.41599999999999, "TestCudaOptimsCUDA": 4.923999999999998}, "test_cuda_multigpu": {"TestCudaComm": 0.05050000000000003, "TestCudaMultiGPU": 0.9895}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.2845, "TestVisibleDeviceParses": 0.036500000000000005}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0045000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.5495000000000001, "TestEventHandler": 0.039000000000000014, "TestMessages": 0.006}, "test_cuda_trace": {"TestCudaTrace": 1.6334999999999997}, "test_custom_backend": {"TestCustomBackend": 0.161}, "test_custom_ops": {"MiniOpTest": 1.0925000000000005, "MiniOpTestOther": 0.11150000000000004, "TestCustomOp": 4.27949999999999, "TestCustomOpAPI": 0.22250000000000006, "TestCustomOpTestingCUDA": 3.067, "TestCustomOperators": 0.6040000000000001, "TestGenerateOpcheckTests": 5.729}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.002, "TestConcatDataset": 0.019500000000000003, "TestConvAfterFork": 0.0415, "TestCustomPinFn": 0.1635, "TestDataLoader": 140.30250000000004, "TestDataLoaderDeviceTypeCUDA": 22.234, "TestDataLoaderPersistentWorkers": 157.9585, "TestDatasetRandomSplit": 0.0495, "TestDictDataLoader": 0.05600000000000001, "TestIndividualWorkerQueue": 0.003, "TestNamedTupleDataLoader": 0.0075, "TestSetAffinity": 0.053500000000000006, "TestStackDataset": 0.05650000000000001, "TestStringDataLoader": 0.07250000000000001, "TestTensorDataset": 0.039}, "test_datapipe": {"TestCaptureDataFrame": 0.0015, "TestCircularSerialization": 0.012, "TestDataChunk": 0.0105, "TestDataFramesPipes": 0.009000000000000001, "TestFunctionalIterDataPipe": 8.1465, "TestFunctionalMapDataPipe": 0.057499999999999996, "TestGraph": 0.022500000000000003, "TestIterDataPipeCountSampleYielded": 0.0165, "TestIterDataPipeGraphFastForward": 0.08, "TestIterDataPipeSingletonConstraint": 0.037000000000000005, "TestIterableDataPipeBasic": 0.04700000000000001, "TestSerialization": 10.503499999999999, "TestSharding": 0.25100000000000006, "TestStreamWrapper": 0.4415, "TestTyping": 0.015000000000000003}, "test_decomp": {"DecompOneOffTestsCUDA": 0.063, "HasDecompTest": 0.315, "TestDecompCUDA": 15401.48550000001}, "test_deploy": {"TestFreezer": 0.40950000000000003}, "test_dispatch": {"TestDispatch": 61.558500000000016, "TestPythonDispatcher": 0.053500000000000006}, "test_dlpack": {"TestTorchDlPackCUDA": 0.5765000000000003}, "test_dynamic_shapes": {"TestDimConstraints": 3.9, "TestFloorDiv": 0.015, "TestGuardsExpressions": 0.034, "TestPySymInt": 2.303499999999998, "TestSymNumberMagicMethods": 3.2719999999999927}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 4.900499999999999, "TestExpandedWeightHelperFunctionCUDA": 0.20700000000000002, "TestExpandedWeightModuleCUDA": 20.9255}, "test_fake_tensor": {"FakeTensorConstHandling": 0.10600000000000002, "FakeTensorConverterTest": 0.042, "FakeTensorDispatchCache": 0.15700000000000003, "FakeTensorOpInfoTestCUDA": 0.1745, "FakeTensorOperatorInvariants": 0.8610000000000001, "FakeTensorPropTest": 0.137, "FakeTensorSerialization": 0.009000000000000001, "FakeTensorTest": 14.94400000000001, "PropagateRealTensorsFakeTensorConstHandling": 0.16650000000000004, "PropagateRealTensorsFakeTensorConverterTest": 0.0395, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.3265, "PropagateRealTensorsFakeTensorPropTest": 0.09899999999999998, "PropagateRealTensorsFakeTensorTest": 28.21}, "test_flop_counter": {"TestFlopCounter": 0.7495}, "test_foreach": {"TestForeachCUDA": 311.49600000001755}, "test_function_schema": {"TestFunctionSchema": 1.0715000000000001}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 32.692}, "test_functional_optim": {"TestFunctionalOptimParity": 0.6325}, "test_functionalization": {"TestCrossRefFunctionalization": 3.854999999999998, "TestFunctionalization": 4.320999999999998}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 5.118}, "test_futures": {"TestFuture": 1.3715000000000002}, "test_fx": {"AnnotationsTest": 0.025, "TestCSEPass": 0.5075000000000001, "TestCommonPass": 0.36300000000000016, "TestConstFold": 0.30050000000000004, "TestConstParamShapeInControlFlow": 0.077, "TestDCE": 0.051500000000000004, "TestFX": 4.90049999999999, "TestFXAPIBackwardCompatibility": 0.048, "TestFunctionalTracing": 0.6300000000000004, "TestMatcher": 0.7235, "TestOperatorSignaturesCUDA": 1.9964999999999993, "TestPassManager": 0.047, "TestSourceMatcher": 2.2885, "TestSubgraphRewriter": 0.5185000000000003, "TestVisionTracing": 462.63449999999995, "TypeCheckerTest": 3.465499999999998}, "test_fx_experimental": {"TestFXExperimental": 24.739500000000003, "TestNormalizeOperatorsCUDA": 2.980499999999948, "TestTranslationValidation": 0.21000000000000002}, "test_fx_passes": {"TestFXGraphPasses": 1.0565000000000002, "TestFXMatcherUtils": 0.14700000000000005}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.805}, "test_import_stats": {"TestImportTime": 6.5840000000000005}, "test_indexing": {"NumpyTestsCUDA": 0.07700000000000001, "TestIndexingCUDA": 3.0499999999999976}, "test_itt": {"TestItt": 0.4}, "test_jit": {"TestAliasAnalysis": 0.531, "TestAsync": 0.5475000000000001, "TestAtenPow": 0.0125, "TestAutodiffJit": 0.0975, "TestAutodiffSubgraphSlicing": 0.4495000000000001, "TestAwait": 0.32500000000000007, "TestBackends": 1.1095000000000002, "TestBackendsWithCompiler": 0.22599999999999998, "TestBatchMM": 0.129, "TestBuiltins": 0.0895, "TestCUDA": 1.067, "TestClassType": 3.7389999999999994, "TestComplex": 1.3600000000000003, "TestCustomOperators": 0.06250000000000003, "TestDCE": 0.028499999999999998, "TestDataParallel": 0.0075, "TestDataclasses": 7.1484999999999985, "TestDeviceAnalysis": 6.617000000000001, "TestDict": 0.6335000000000003, "TestDtypeAnalysis": 0.24950000000000006, "TestEnum": 0.30600000000000005, "TestFreezing": 3.5865, "TestFrontend": 0.6405, "TestFrozenOptimizations": 16.5615, "TestFunctionalBlocks": 0.009000000000000001, "TestFunctionalToInplaceActivation": 3.4290000000000003, "TestGenerator": 0.099, "TestGetDefaultAttr": 0.025, "TestGraphRewritePasses": 0.063, "TestHash": 0.11499999999999999, "TestHooks": 1.0675000000000006, "TestIgnorableArgs": 0.015, "TestIgnoreContextManager": 0.063, "TestInplaceToFunctionalActivation": 3.37, "TestIsinstance": 0.31700000000000006, "TestJit": 8.774499999999993, "TestJitGeneratedModule": 18.234500000000015, "TestJitProfiler": 0.0015, "TestJitUtils": 0.027500000000000004, "TestList": 1.9725000000000006, "TestLogging": 0.07600000000000001, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.26100000000000007, "TestMixTracingScripting": 1.956, "TestModels": 7.83, "TestModuleAPIs": 0.1955, "TestModuleContainers": 1.8820000000000001, "TestModuleInterface": 0.75, "TestModules": 0.0205, "TestNamedTuple": 0.10299999999999998, "TestNnapiBackend": 11.330499999999997, "TestOpDecompositions": 0.025, "TestOptimizeForMobilePreserveDebugInfo": 0.25500000000000006, "TestParametrization": 0.162, "TestPeephole": 0.6705000000000003, "TestProducerVersion": 0.003, "TestProfiler": 0.8395000000000001, "TestPythonBindings": 0.04350000000000001, "TestPythonBuiltinOP": 0.5700000000000001, "TestPythonIr": 0.035, "TestRecursiveScript": 1.0565000000000002, "TestRemoveMutation": 0.18550000000000003, "TestSaveLoad": 0.7140000000000002, "TestSaveLoadFlatbuffer": 0.7965, "TestSaveLoadForOpVersion": 3.441, "TestScript": 65.55550000000008, "TestScriptDict": 0.037500000000000006, "TestScriptList": 1.2080000000000002, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2695, "TestScriptProfile": 0.611, "TestSlice": 0.22650000000000012, "TestSparse": 0.0685, "TestStringFormatting": 0.17000000000000004, "TestSymbolicShapeAnalysis": 1.8339999999999992, "TestTensorBuiltins": 0.14700000000000002, "TestTensorCreationOps": 0.07, "TestTensorMethods": 0.017, "TestTorchbind": 0.2330000000000001, "TestTracer": 6.682499999999992, "TestTypeSharing": 0.7415, "TestTypesAndAnnotation": 0.18350000000000002, "TestTyping": 0.5535000000000003, "TestUnion": 0.6750000000000003, "TestUnsupportedOps": 0.042, "TestUpgraders": 0.09800000000000002, "TestWarn": 0.078, "TestWith": 0.5085000000000001}, "test_jit_autocast": {"TestAutocast": 2.034499999999999, "TestJitTraceAutocast": 51.96650000000001}, "test_jit_disabled": {"TestJitDisabled": 0.6615}, "test_jit_fuser_te": {"TestFuserCommon": 0.2395, "TestNNCOpInfoCUDA": 29.253500000000706, "TestTEFuserDynamic": 459.12850000000003, "TestTEFuserStatic": 354.1905}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0015, "TestEnableDisableLlgaFuser": 0.11549999999999999, "TestFusionPatternCUDA": 0.0075, "TestModel": 0.008, "TestOpCUDA": 0.009000000000000001}, "test_jiterator": {"TestPythonJiteratorCUDA": 29.757999999999925}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.4415, "TestVmapBatchedGradientLegacyCUDA": 0.9315000000000003, "TestVmapOperatorsLegacy": 1.7074999999999998}, "test_license": {"TestLicense": 0.4195}, "test_linalg": {"TestLinalgCUDA": 510.7490000000016}, "test_logging": {"LoggingTest": 4.524}, "test_masked": {"TestMaskedCUDA": 49.517000000000095}, "test_maskedtensor": {"TestBasicsCUDA": 0.36500000000000005, "TestBinary": 0.5560000000000004, "TestOperatorsCUDA": 11.35249999999992, "TestReductions": 0.12500000000000003, "TestUnary": 0.4145000000000003}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.027500000000000014, "TestMatmulCudaCUDA": 71.42449999999998, "TestMixedDtypesLinearCudaCUDA": 0.0015}, "test_meta": {"TestMetaCUDA": 4002.7124999998796, "TestMetaConverter": 0.32399999999999995}, "test_mkl_verbose": {"TestMKLVerbose": 7.1165}, "test_mkldnn_fusion": {"TestMkldnnFusion": 61.941}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 6.4195}, "test_mobile_optimizer": {"TestOptimizer": 5.0455000000000005}, "test_model_dump": {"TestModelDump": 1.7895}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.4465}, "test_module_tracker": {"TestModuleTracker": 0.4035}, "test_modules": {"TestModuleCUDA": 910.3274999999974}, "test_monitor": {"TestMonitor": 0.41400000000000003, "TestMonitorTensorboard": 0.22949999999999998}, "test_multiprocessing": {"TestMultiprocessing": 167.036}, "test_multiprocessing_spawn": {"ErrorTest": 0.0045000000000000005, "ForkTest": 1.0965, "SpawnTest": 50.5595}, "test_namedtensor": {"TestNamedTensor": 1.4780000000000002}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 3.109}, "test_native_functions": {"TestNativeFunctions": 0.6940000000000002}, "test_native_mha": {"TestMHADeviceTypeCUDA": 1.2485000000000008}, "test_nestedtensor": {"TestNestedTensor": 0.2545000000000001, "TestNestedTensorAutogradCUDA": 1.8239999999999994, "TestNestedTensorDeviceTypeCUDA": 2.300999999999995, "TestNestedTensorSubclassCUDA": 2.426999999999998}, "test_nn": {"TestAddRelu": 0.006, "TestConstantPadNd": 0.006, "TestFunctionalPickle": 0.003, "TestFusionEval": 0.5800000000000001, "TestFusionUtils": 0.009000000000000001, "TestNN": 96.36350000000027, "TestNNDeviceTypeCUDA": 182.98549999999366, "TestUtils": 0.006}, "test_numba_integration": {"TestNumbaIntegration": 0.24250000000000005}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.32450000000000007}, "test_openmp": {"TestOpenMP_ParallelFor": 7.446}, "test_ops": {"TestCommonCUDA": 5536.687999999954, "TestCompositeComplianceCUDA": 1509.0264999999965, "TestFakeTensorCUDA": 1656.7339999999986, "TestMathBitsCUDA": 173.9115, "TestSelfKwarg": 0.034, "TestTagsCUDA": 4.586500000000004}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1832.9239999999893}, "test_ops_gradients": {"TestBwdGradientsCUDA": 2555.312499999983}, "test_ops_jit": {"TestJitCUDA": 1798.8129999999978}, "test_optim": {"TestDifferentiableOptimizer": 0.346, "TestLRScheduler": 1.818499999999998, "TestOptimRenewedCUDA": 389.69699999999995, "TestSWAUtils": 1.2985000000000002}, "test_out_dtype_op": {"TestOutDtypeOp": 0.7015}, "test_overrides": {"TestBroadcastAllOverride": 0.0045000000000000005, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.006, "TestGradCheckOverride": 0.0415, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.015, "TestIterator": 0.003, "TestNamedTuple": 0.0045000000000000005, "TestPickle": 0.0045000000000000005, "TestRNN": 0.0045000000000000005, "TestResolveName": 0.20950000000000002, "TestTorchFunctionMode": 0.07200000000000004, "TestTorchFunctionOverride": 4.8089999999998065, "TestTorchFunctionWarning": 0.021, "TestWrapTorchFunction": 0.003}, "test_package": {"DirectoryReaderTest": 0.0685, "ModelTest": 0.0045000000000000005, "TestAnalyze": 0.44899999999999995, "TestDependencyAPI": 0.07900000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.03600000000000001, "TestGlobGroup": 0.051500000000000004, "TestImporter": 0.019000000000000003, "TestLoadBCPackages": 0.1, "TestMangling": 0.033, "TestMisc": 0.052500000000000005, "TestPackageFX": 0.10650000000000001, "TestPackageScript": 3.1619999999999995, "TestRepackage": 0.0105, "TestResources": 0.017, "TestSaveLoad": 0.05499999999999999}, "test_per_overload_api": {"TestPerOverloadAPI": 0.48150000000000004}, "test_prims": {"TestDecompCUDA": 0.22950000000000004, "TestPrimsBasic": 0.052000000000000005, "TestPrimsCUDA": 0.5550000000000002, "TestRefsCUDA": 0.019}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.20650000000000002, "TestGenericProxyTensorFake": 3.6784999999999997, "TestGenericProxyTensorReal": 3.722, "TestGenericProxyTensorSymbolic": 30.481000000000005, "TestRealProxyTensor": 0.027999999999999997, "TestSymbolicTracing": 6.6754999999999995}, "test_pruning_op": {"PruningOpTest": 0.7435}, "test_public_bindings": {"TestPublicBindings": 9.8185}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.036, "TestPythonDispatch": 0.3820000000000002, "TestPythonDispatcher": 0.0105, "TestPythonRegistration": 1.934499999999999, "TestWrapperSubclassAliasingCUDA": 0.24400000000000005}, "test_pytree": {"TestCxxPytree": 0.02650000000000001, "TestGenericPytree": 0.6550000000000001, "TestPythonPytree": 0.11050000000000007}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.0335, "TestAOMigrationNNQuantized": 0.09650000000000002, "TestAOMigrationQuantization": 0.033, "TestAOMigrationQuantizationFx": 0.0625, "TestBackendConfig": 0.0705, "TestBiasCorrectionEager": 1.2440000000000002, "TestBitsCUDA": 0.0365, "TestComparatorOps": 1.9259999999999997, "TestDeprecatedJitQuantized": 5.5875, "TestDistributed": 0.042499999999999996, "TestDuplicateDQPass": 6.312, "TestDynamicQuantizedModule": 36.062, "TestDynamicQuantizedOps": 17.277499999999996, "TestEqualizeEager": 0.1575, "TestEqualizeFx": 7.015, "TestFXGraphMatcher": 3.319, "TestFXGraphMatcherModels": 16.098, "TestFXNumericSuiteCoreAPIs": 47.65, "TestFXNumericSuiteCoreAPIsModels": 67.96199999999999, "TestFXNumericSuiteNShadows": 58.50699999999999, "TestFakeQuantize": 0.45399999999999996, "TestFakeQuantizeOps": 40.5845, "TestFloat8DtypeCUDA": 0.8180000000000001, "TestFuseEager": 4.048, "TestFuseFx": 3.081, "TestFusedObsFakeQuant": 0.5065, "TestFusedObsFakeQuantModule": 0.4905, "TestFusionPasses": 0.034, "TestFxDetectInputWeightEqualization": 0.3145, "TestFxDetectOutliers": 0.43150000000000005, "TestFxModelReportClass": 0.8505, "TestFxModelReportDetectDynamicStatic": 0.10250000000000001, "TestFxModelReportDetector": 0.3295, "TestFxModelReportObserver": 0.3535, "TestFxModelReportVisualizer": 0.373, "TestGenerateNumericDebugHandle": 1.3579999999999999, "TestGraphUtils": 3.4560000000000004, "TestHistogramObserver": 65.389, "TestMetaDataPorting": 13.221, "TestModelNumericsEager": 0.994, "TestNumericSuiteEager": 11.804, "TestObserver": 6.054, "TestPT2ERepresentation": 49.64, "TestPadding": 16.4955, "TestQNNPackOps": 4.041, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 3.0620000000000003, "TestQuantizeDynamicJitPasses": 7.403, "TestQuantizeEagerOps": 2.785, "TestQuantizeEagerPTQDynamic": 12.084, "TestQuantizeEagerPTQStatic": 36.709500000000006, "TestQuantizeEagerQAT": 11.5995, "TestQuantizeEagerQATNumerics": 3.2885, "TestQuantizeFx": 45.461, "TestQuantizeFxModels": 18.1025, "TestQuantizeFxOps": 172.79250000000002, "TestQuantizeJit": 35.166, "TestQuantizeJitOps": 396.98400000000004, "TestQuantizeJitPasses": 10.254999999999999, "TestQuantizePT2E": 147.19650000000001, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 1319.3014999999998, "TestQuantizePT2EQAT_ConvBn2d": 1330.7855, "TestQuantizePT2EX86Inductor": 270.8955, "TestQuantizedConv": 51.424, "TestQuantizedEmbeddingOps": 1.1285, "TestQuantizedFunctionalOps": 1.7845, "TestQuantizedLinear": 21.7125, "TestQuantizedOps": 139.4245, "TestQuantizedTensor": 4.5495, "TestRecordHistogramObserver": 0.0505, "TestReferenceQuantizedModule": 0.06949999999999999, "TestSerialization": 2.181, "TestStaticQuantizedModule": 66.6115, "TestSubgraphRewriter": 1.0150000000000001, "TestUtils": 0.0295, "TestXNNPACKQuantizer": 77.941, "TestXNNPACKQuantizerModels": 5.728}, "test_reductions": {"TestReductionsCUDA": 200.887999999994}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 28.098000000000003}, "test_schema_check": {"TestSchemaCheck": 0.19950000000000012, "TestSchemaCheckModeOpInfoCUDA": 467.3419999999865}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 4.952999999999999}, "test_serialization": {"TestBothSerializationCUDA": 0.1875, "TestOldSerialization": 40.75, "TestSerialization": 17.51149999999999, "TestSubclassSerialization": 0.052000000000000005}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.483}, "test_shape_ops": {"TestShapeOpsCUDA": 2.3914999999999984}, "test_show_pickle": {"TestShowPickle": 0.47750000000000004}, "test_sort_and_select": {"TestSortAndSelectCUDA": 8.887499999999987}, "test_sparse": {"TestSparseAnyCUDA": 920.418999999997, "TestSparseCUDA": 68.54950000000002, "TestSparseLegacyAndDeprecation": 0.2985, "TestSparseMaskedReductionsCUDA": 3.3480000000000008, "TestSparseMeta": 7.255000000000001, "TestSparseOneOff": 0.302, "TestSparseUnaryUfuncsCUDA": 12.296999999999928}, "test_sparse_csr": {"TestSparseCSRCUDA": 304.9349999999997, "TestSparseCSRSampler": 1.1215, "TestSparseCompressedCUDA": 225.77749999999978, "TestSparseCompressedTritonKernelsCUDA": 0.015000000000000003}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005, "TestSparseSemiStructuredCUDA": 0.1475000000000001, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.04200000000000002, "TestSparseSemiStructuredCUTLASSCUDA": 0.02400000000000001, "TestSparseSemiStructuredTrainingCUDA": 0.030000000000000016}, "test_spectral_ops": {"TestFFTCUDA": 37.38099999999997}, "test_stateless": {"TestPythonOptimizeMode": 6.0649999999999995, "TestStatelessDeprecation": 2.9589999999999996, "TestStatelessFunctionalAPI": 0.37850000000000017}, "test_subclass": {"TestSubclass": 0.7590000000000002}, "test_sympy_utils": {"TestNumbers": 0.045000000000000005, "TestSingletonInt": 0.009000000000000001, "TestSympyInterp": 16.950999999999997, "TestSympySolve": 0.4895000000000001, "TestValueRanges": 12.006}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 1.0830000000000009, "TestLikeTensorCreationCUDA": 0.018000000000000002, "TestRandomTensorCreationCUDA": 0.5800000000000002, "TestTensorCreationCUDA": 144.65649999999943}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0345, "TestTensorBoardFigure": 0.003, "TestTensorBoardNumpy": 0.012, "TestTensorBoardPyTorchNumpy": 0.37050000000000005, "TestTensorBoardPytorchGraph": 46.542, "TestTensorBoardSummary": 0.057500000000000016, "TestTensorBoardSummaryWriter": 0.0125, "TestTensorBoardUtils": 0.2505, "TestTensorBoardWriter": 0.118, "TestTensorProtoSummary": 0.021}, "test_tensorexpr": {"TestTensorExprFuser": 181.6815}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.0165, "TestTensorExprPyBind": 1.3875000000000002}, "test_testing": {"TestAssertClose": 0.17350000000000007, "TestAssertCloseContainer": 0.011, "TestAssertCloseErrorMessage": 0.099, "TestAssertCloseMultiDeviceCUDA": 0.015, "TestAssertCloseQuantized": 0.0175, "TestAssertCloseSparseBSC": 0.029000000000000005, "TestAssertCloseSparseBSR": 0.029000000000000005, "TestAssertCloseSparseCOO": 0.035, "TestAssertCloseSparseCSC": 0.027500000000000004, "TestAssertCloseSparseCSR": 0.028500000000000004, "TestFrameworkUtils": 21.369500000000002, "TestImports": 20.599, "TestMakeTensorCUDA": 2.8440000000000016, "TestOpInfoSampleFunctionsCUDA": 6.89899999999991, "TestOpInfos": 0.006, "TestTestParametrization": 0.053000000000000026, "TestTestParametrizationDeviceTypeCUDA": 6.252499999999997, "TestTestingCUDA": 0.9420000000000002}, "test_torch": {"TestBasicVitalSigns": 0.042499999999999996, "TestDevicePrecisionCUDA": 0.14050000000000004, "TestTorch": 10.05949999999998, "TestTorchDeviceTypeCUDA": 216.30099999999948, "TestVitalSignsCudaCUDA": 0.003}, "test_transformers": {"TestAttnBiasCUDA": 4.283999999999999, "TestSDPACUDA": 3.9689999999999035, "TestSDPACudaOnlyCUDA": 224.9165000000085, "TestSDPAFailureModesCUDA": 0.10800000000000005, "TestTransformersCUDA": 8.407999999999998}, "test_type_hints": {"TestTypeHints": 0.40650000000000003}, "test_type_info": {"TestDTypeInfo": 0.4625}, "test_type_promotion": {"TestTypePromotionCUDA": 13.320499999999974}, "test_typing": {"TestTyping": 134.34449999999993}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 789.2939999998991}, "test_utils": {"TestAssert": 0.11349999999999999, "TestBottleneck": 19.6145, "TestCheckpoint": 0.371, "TestCollectEnv": 1.8355000000000001, "TestCppExtensionUtils": 0.0505, "TestDataLoaderUtils": 0.3185, "TestDeviceUtilsCUDA": 26.368000000000745, "TestExtensionUtils": 0.006, "TestHipify": 0.003, "TestHipifyTrie": 0.012, "TestONNXUtils": 0.006, "TestRenderUtils": 0.022, "TestStandaloneCPPJIT": 4.359, "TestTraceback": 0.015}, "test_view_ops": {"TestOldViewOpsCUDA": 30.409499999999984, "TestViewOpsCUDA": 2.2515}, "test_vulkan": {"TestVulkanRewritePass": 0.0015}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.027499999999999997, "WeakKeyDictionaryTestCase": 0.0345, "WeakTest": 6.792999999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 3.5009999999999994, "TestXNNPACKRewritePass": 1.491, "TestXNNPACKSerDes": 4.3165}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0075}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.48600000000000004, "TestClassGetItem": 0.003, "TestDtypeAttributeDeletion": 0.0005, "TestFromDTypeAttribute": 0.0045000000000000005, "TestMisc": 0.0075, "TestPickling": 0.22050000000000003, "TestPromotion": 0.007}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 30.418, "TestEinsumPath": 0.0015, "TestMisc": 0.012}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.003, "TestHalf": 0.0015, "TestIinfo": 0.485, "TestMisc": 0.0075, "TestPythonFloat": 0.0025, "TestRepr": 0.006, "TestSingle": 0.0015}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.005, "TestBooleanIndexing": 0.013000000000000001, "TestBroadcastedAssignments": 0.027000000000000003, "TestFancyIndexingCast": 0.006, "TestFloatNonIntegerArgument": 0.018000000000000002, "TestIndexing": 0.6935000000000002, "TestMultiIndexingAutomated": 0.015, "TestMultipleEllipsisError": 0.004, "TestNonIntegerArrayLike": 0.0015}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.04050000000000001, "TestArgmax": 2.0045, "TestArgmaxArgminCommon": 0.3035000000000002, "TestArgmin": 2.0414999999999996, "TestArrayAttributeDeletion": 0.012, "TestArrayConstruction": 0.08100000000000002, "TestArrayCreationCopyArgument": 0.006, "TestAssignment": 0.022500000000000006, "TestAttributes": 0.04150000000000001, "TestBinop": 0.035, "TestBool": 50.51700000000001, "TestCequenceMethods": 0.003, "TestChoose": 0.04200000000000001, "TestClip": 0.012, "TestCompress": 0.009000000000000001, "TestConversion": 0.07350000000000001, "TestCreation": 0.006500000000000001, "TestDelMisc": 0.003, "TestDot": 0.12650000000000006, "TestDtypedescr": 0.003, "TestFancyIndexing": 0.054000000000000006, "TestFlag": 0.021500000000000005, "TestFormat": 0.009000000000000001, "TestFromBuffer": 0.024500000000000004, "TestHash": 0.2895, "TestHashing": 0.006, "TestIO": 0.0075, "TestInner": 0.42600000000000005, "TestLexsort": 0.03600000000000001, "TestMatmul": 0.8445000000000003, "TestMatmulOperator": 0.5735, "TestMethods": 2.7509999999999994, "TestMinMax": 0.009000000000000001, "TestMinScalarType": 0.012, "TestNewaxis": 0.0075, "TestPEP3118Dtype": 0.0045000000000000005, "TestPutmask": 0.020000000000000004, "TestRepeat": 0.025500000000000002, "TestResize": 0.094, "TestRichcompareScalar": 0.0015, "TestScalarIndexing": 0.04050000000000001, "TestSortFloatMisc": 0.3415000000000001, "TestStats": 0.5385, "TestSubscripting": 0.003, "TestTake": 0.066, "TestVdot": 0.0885, "TestWarnings": 0.003, "TestWhere": 0.5805, "TestWritebackIfCopy": 0.04650000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.037500000000000006, "TestArgwhere": 0.05450000000000001, "TestArrayComparisons": 0.0225, "TestBaseRepr": 0.012, "TestBinaryRepr": 0.018000000000000002, "TestBoolArray": 3.3689999999999998, "TestBoolCmp": 0.351, "TestBoolScalar": 0.016, "TestBroadcast": 0.015000000000000003, "TestClip": 0.35250000000000026, "TestConvolve": 0.036000000000000004, "TestCorrelate": 0.059500000000000004, "TestCreationFuncs": 2.2234999999999996, "TestCross": 0.0975, "TestDtypePositional": 0.003, "TestFloatExceptions": 0.018000000000000002, "TestFromiter": 0.0035, "TestIndex": 0.011, "TestIndices": 0.07650000000000001, "TestIsclose": 0.1615, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0045000000000000005, "TestMoveaxis": 0.0155, "TestNonarrayArgs": 0.2135000000000001, "TestNonzeroAndCountNonzero": 0.48250000000000004, "TestOuterMisc": 0.0105, "TestRequire": 0.012, "TestResize": 0.48950000000000005, "TestRoll": 0.0625, "TestRollaxis": 0.0075, "TestSeterr": 0.012, "TestStdVar": 0.052500000000000005, "TestStdVarComplex": 0.024, "TestStringFunction": 0.003, "TestTensordot": 0.025500000000000002, "TestTypes": 0.027500000000000004}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.003, "TestCommonType": 0.4225, "TestDocStrings": 0.0005, "TestIsSubDType": 0.014500000000000002, "TestScalarTypeNames": 0.03650000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.18000000000000013, "TestFromInt": 0.013500000000000002, "TestFromString": 0.4305}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.004, "TestBitCount": 0.001, "TestClassGetItem": 0.0055, "TestClassGetitemMisc": 0.0045000000000000005, "TestIsInteger": 0.003}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0015}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.20450000000000002, "TestBaseMath": 19.206500000000002, "TestBitShifts": 0.18050000000000002, "TestComplexDivision": 0.121, "TestConversion": 0.11400000000000002, "TestHash": 0.003, "TestModulus": 2.0035, "TestMultiply": 0.0, "TestNegative": 0.037000000000000005, "TestPower": 0.26, "TestRepr": 0.003, "TestScalarOpsMisc": 0.10350000000000006, "TestScalarSubclassingMisc": 0.11750000000000008, "TestSubtract": 0.037000000000000005, "TestTypes": 30.5895}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.49950000000000006, "TestAtleast2d": 0.027000000000000003, "TestAtleast3d": 0.024, "TestBlock": 0.05500000000000003, "TestConcatenate": 0.2600000000000001, "TestHstack": 0.03150000000000001, "TestStackMisc": 0.032500000000000015, "TestVstack": 0.03600000000000001}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.021, "TestFFTShift": 12.7945, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.021}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 4.825, "TestFFTShift": 0.4355, "TestFFTThreadSafe": 0.9815}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.455}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0045000000000000005, "TestUnique": 0.7405}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.012, "TestAmax": 0.012, "TestAmin": 0.012, "TestAngle": 0.0175, "TestAny": 0.012, "TestAverage": 0.05650000000000001, "TestBincount": 0.077, "TestCheckFinite": 0.006, "TestCopy": 0.0145, "TestCorrCoef": 0.066, "TestCov": 0.11700000000000002, "TestCumprod": 0.0615, "TestCumsum": 0.087, "TestDelete": 0.0325, "TestDiff": 0.14900000000000002, "TestDigitize": 0.028500000000000004, "TestExtins": 0.0105, "TestFilterwindows": 1.066500000000001, "TestFlip": 0.06, "TestGradient": 0.271, "TestInsert": 0.019000000000000003, "TestInterp": 0.06800000000000003, "TestKaiser": 0.0205, "TestMedian": 0.20750000000000002, "TestMeshgrid": 0.10450000000000001, "TestMsort": 0.001, "TestPercentile": 0.2710000000000002, "TestPiecewise": 0.0195, "TestProd": 0.059, "TestPtp": 0.018000000000000002, "TestQuantile": 0.060500000000000026, "TestRot90": 0.516, "TestSelect": 0.018000000000000002, "TestSinc": 0.016, "TestSortComplex": 0.021, "TestTrapz": 0.011, "TestTrimZeros": 0.021, "TestUnique": 0.007, "Test_I0": 0.026500000000000003}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.7040000000000002, "TestHistogramOptimBinNums": 0.051000000000000024, "TestHistogramdd": 0.269}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.003, "TestConcatenator": 0.017, "TestDiagIndices": 0.009000000000000001, "TestDiagIndicesFrom": 0.015, "TestFillDiagonal": 0.0465, "TestGrid": 0.0205, "TestIndexExpression": 0.019500000000000003, "TestIx_": 0.015, "TestNdIndex": 0.003, "TestNdenumerate": 0.003, "TestRavelUnravelIndex": 0.46299999999999997}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.028500000000000004, "TestApplyOverAxes": 0.003, "TestArraySplit": 0.3425, "TestColumnStack": 0.018000000000000002, "TestDsplit": 0.021, "TestDstack": 0.030000000000000006, "TestExpandDims": 0.0125, "TestHsplit": 0.024, "TestKron": 0.03150000000000001, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.018500000000000003, "TestSplit": 0.012, "TestSqueeze": 0.05600000000000001, "TestTakeAlongAxis": 0.5345, "TestTile": 0.1645, "TestVsplit": 0.018000000000000002}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.05500000000000001, "TestEye": 0.52, "TestFliplr": 0.0105, "TestFlipud": 0.009000000000000001, "TestHistogram2d": 0.065, "TestTri": 0.169, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.0045000000000000005, "TestTriuIndicesFrom": 0.003, "TestVander": 0.0345}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.003, "TestCommonType": 0.481, "TestImag": 0.024, "TestIscomplex": 0.009000000000000001, "TestIscomplexobj": 0.009000000000000001, "TestIsfinite": 0.021, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.021, "TestIsneginf": 0.003, "TestIsposinf": 0.0035, "TestIsreal": 0.015, "TestIsrealobj": 0.003, "TestIsscalar": 0.003, "TestMintypecode": 0.009000000000000001, "TestNanToNum": 0.03150000000000001, "TestReal": 0.025, "TestRealIfClose": 0.008}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.2765, "TestCond": 0.43100000000000005, "TestDet": 0.30700000000000005, "TestEig": 0.06650000000000002, "TestEigh": 0.048500000000000015, "TestEighCases": 0.0, "TestEigvals": 0.11050000000000001, "TestEigvalsh": 0.04200000000000001, "TestEigvalshCases": 0.0, "TestInv": 0.095, "TestLstsq": 0.48650000000000004, "TestMatrixRank": 0.7405, "TestMisc": 0.036500000000000005, "TestMisc2": 0.006, "TestMultiDot": 0.096, "TestNormDouble": 1.604, "TestNormInt64": 1.6355000000000002, "TestNormSingle": 1.6420000000000001, "TestNorm_NonSystematic": 0.006, "TestPinv": 0.21450000000000002, "TestPinvHermitian": 0.0665, "TestQR": 0.9380000000000002, "TestSVD": 0.08200000000000002, "TestSVDHermitian": 0.186, "TestSolve": 0.5185, "TestTensorinv": 0.038500000000000006, "TestTensorsolve": 0.0105}, "torch_np/test_basic": {"TestArrayToSequence": 0.018000000000000002, "TestCopyTo": 0.0105, "TestCtorNested": 0.01, "TestDefaultDtype": 0.02, "TestDivmod": 0.043000000000000003, "TestExport": 0.001, "TestMisc": 0.362, "TestNormalizations": 0.009000000000000001, "TestOneArr": 0.7060000000000005, "TestOneArrAndAxesTuple": 0.027000000000000003, "TestOneArrAndAxis": 0.3975000000000003, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.027000000000000003, "TestPythonArgsToArray": 0.030000000000000006, "TestSequenceOfArrays": 0.04800000000000002, "TestSequenceOfArraysToSingle": 0.021, "TestShapeLikeToArray": 0.012, "TestSmokeNotImpl": 0.005}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.6260000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.5025000000000002}, "torch_np/test_function_base": {"TestAppend": 0.42700000000000005}, "torch_np/test_ndarray_methods": {"TestAmax": 0.015, "TestAmin": 0.015, "TestArgmax": 1.9290000000000003, "TestArgmaxArgminCommon": 0.3045000000000002, "TestArgmin": 2.2534999999999994, "TestContains": 0.003, "TestIndexing": 0.4245, "TestIter": 0.009000000000000001, "TestNoExtraMethods": 0.018000000000000002, "TestNonzero": 0.28800000000000003, "TestRavel": 0.012, "TestReshape": 0.0075, "TestTranspose": 0.0165}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.13800000000000007, "TestNEP50Table": 0.0085}, "torch_np/test_random": {"TestChoice": 0.019999999999999997, "TestNumpyGlobal": 0.006, "TestScalarReturn": 0.5230000000000001, "TestShuffle": 0.019500000000000003}, "torch_np/test_reductions": {"TestAll": 0.022, "TestAny": 0.0225, "TestFlatnonzero": 0.4345, "TestGenericCumSumProd": 0.036000000000000004, "TestGenericReductions": 3.785499999999959, "TestMean": 0.03900000000000001, "TestSum": 0.4465}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.47150000000000003, "TestIsScalar": 0.061500000000000034}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 1.0405000000000006, "TestNdarrayDunderVsUfunc": 0.3935000000000001, "TestUfuncDtypeKwd": 0.01, "TestUnaryUfuncs": 0.5095000000000001}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.6290000000000002}}, "jit_legacy": {"test_jit_fuser_legacy": {"TestFuser": 0.01}, "test_jit_legacy": {"TestAliasAnalysis": 0.504, "TestAsync": 0.509, "TestAtenPow": 0.012, "TestAutodiffJit": 0.07200000000000001, "TestAutodiffSubgraphSlicing": 0.3770000000000001, "TestAwait": 0.31400000000000006, "TestBackends": 1.085, "TestBackendsWithCompiler": 0.21499999999999997, "TestBatchMM": 0.12349999999999998, "TestBuiltins": 0.0865, "TestCUDA": 0.8979999999999999, "TestClassType": 3.388, "TestComplex": 1.2460000000000002, "TestCustomOperators": 0.06050000000000003, "TestDCE": 0.026000000000000002, "TestDataParallel": 0.0075, "TestDataclasses": 5.3815, "TestDeviceAnalysis": 0.2415, "TestDict": 0.5895000000000002, "TestDtypeAnalysis": 0.237, "TestEnum": 0.28600000000000003, "TestFreezing": 3.268, "TestFrontend": 0.578, "TestFrozenOptimizations": 12.596000000000002, "TestFunctionalBlocks": 0.009000000000000001, "TestFunctionalToInplaceActivation": 0.16199999999999998, "TestGenerator": 0.07250000000000001, "TestGetDefaultAttr": 0.0215, "TestGraphRewritePasses": 0.057999999999999996, "TestHash": 0.10200000000000001, "TestHooks": 0.9705000000000004, "TestIgnorableArgs": 0.015, "TestIgnoreContextManager": 0.059, "TestInplaceToFunctionalActivation": 0.081, "TestIsinstance": 0.28350000000000014, "TestJit": 8.29999999999999, "TestJitGeneratedModule": 16.525999999999954, "TestJitProfiler": 0.0015, "TestJitUtils": 0.0245, "TestList": 1.9430000000000005, "TestLogging": 0.07100000000000001, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.24400000000000005, "TestMixTracingScripting": 1.7945, "TestModels": 4.994999999999999, "TestModuleAPIs": 0.19, "TestModuleContainers": 1.7690000000000001, "TestModuleInterface": 0.7080000000000001, "TestModules": 0.0195, "TestNamedTuple": 0.09899999999999998, "TestNnapiBackend": 9.328, "TestOpDecompositions": 0.024, "TestOptimizeForMobilePreserveDebugInfo": 0.23950000000000005, "TestParametrization": 0.14250000000000002, "TestPeephole": 0.6355000000000003, "TestProducerVersion": 0.003, "TestProfiler": 0.8230000000000002, "TestPythonBindings": 0.04350000000000001, "TestPythonBuiltinOP": 0.529, "TestPythonIr": 0.033, "TestRecursiveScript": 1.0145000000000002, "TestRemoveMutation": 0.17700000000000002, "TestSaveLoad": 0.6805000000000001, "TestSaveLoadFlatbuffer": 0.7405, "TestSaveLoadForOpVersion": 3.4445, "TestScript": 60.80900000000003, "TestScriptDict": 0.037500000000000006, "TestScriptList": 1.189, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.22600000000000003, "TestScriptProfile": 0.58, "TestSlice": 0.2045000000000001, "TestSparse": 0.062, "TestStringFormatting": 0.15850000000000003, "TestSymbolicShapeAnalysis": 1.6034999999999997, "TestTensorBuiltins": 0.14250000000000002, "TestTensorCreationOps": 0.063, "TestTensorMethods": 0.015, "TestTorchbind": 0.22250000000000011, "TestTracer": 13.120999999999992, "TestTypeSharing": 0.7095000000000002, "TestTypesAndAnnotation": 0.16950000000000004, "TestTyping": 0.5090000000000002, "TestUnion": 0.5925000000000002, "TestUnsupportedOps": 0.039, "TestUpgraders": 0.09500000000000003, "TestWarn": 0.07200000000000001, "TestWith": 0.657}}, "nogpu_AVX512": {"backends/xeon/test_launch": {"TestTorchrun": 2.549}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.747}, "distributions/test_distributions": {"TestAgainstScipy": 1.5884999999999998, "TestConstraints": 0.20550000000000002, "TestDistributionShapes": 0.1785000000000001, "TestDistributions": 50.87350000000001, "TestFunctors": 0.0155, "TestJit": 28.03, "TestKL": 4.258999999999999, "TestLazyLogitsInitialization": 0.0165, "TestNumericalStability": 0.10149999999999999, "TestRsample": 0.9765, "TestValidation": 0.49750000000000005}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.772}, "dynamo/test_after_aot": {"TestAfterAot": 9.888}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 18.3355}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 1.9859999999999998, "AOTAutogradCacheTests": 14.512}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.034999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.051500000000000004, "TestCustomBackendAPI": 2.5164999999999997, "TestExplainWithBackend": 15.5545, "TestOptimizations": 2.8429999999999995}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 18.015500000000003}, "dynamo/test_base_output": {"TestBaseOutput": 0.003}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.288}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 8.6905, "BytecodeTests": 0.643}, "dynamo/test_compile": {"InPlaceCompilationTests": 10.331, "PublicTorchCompilerTests": 0.003}, "dynamo/test_comptime": {"ComptimeTests": 0.9055000000000002}, "dynamo/test_config": {"ConfigTests": 0.8525}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.8120000000000007}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.3785}, "dynamo/test_decorators": {"DecoratorTests": 9.8855}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.0215}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 47.933499999999995, "DynamicShapesCtxManagerTests": 6.772999999999999, "DynamicShapesExportTests": 40.36849999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 138.99849999999998, "DynamicShapesFunctionTests": 97.029, "DynamicShapesHigherOrderOpTests": 22.293499999999995, "DynamicShapesMiscTests": 114.85650000000008, "DynamicShapesNNModuleTests": 8.533, "DynamicShapesReproTests": 134.51000000000002, "DynamicShapesSubGraphTests": 12.021999999999998, "DynamicShapesTestSDPA": 0.487}, "dynamo/test_exc": {"ExcTests": 2.8115}, "dynamo/test_exceptions": {"ExceptionTests": 0.8075000000000001}, "dynamo/test_export": {"ExportTests": 21.053999999999995}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8230000000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.3245}, "dynamo/test_functions": {"DefaultsTests": 1.0205000000000002, "FunctionTests": 32.31700000000003}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.6675}, "dynamo/test_global": {"TestGlobals": 0.808}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.3785}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.099, "FuncTorchHigherOrderOpTests": 10.769499999999997, "HigherOrderOpTests": 10.651, "HigherOrderOpVmapGuardTests": 5.2685}, "dynamo/test_hooks": {"HooksTests": 36.43550000000002}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 6.460999999999999, "InlineInbuiltNNModulesExportTests": 28.789999999999992, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 10.851000000000003, "InlineInbuiltNNModulesFunctionTests": 6.161499999999991, "InlineInbuiltNNModulesHigherOrderOpTests": 10.007499999999995, "InlineInbuiltNNModulesMiscTests": 74.50400000000012, "InlineInbuiltNNModulesNNModuleTests": 5.688999999999998}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 12.0185}, "dynamo/test_interop": {"InteropTests": 0.8474999999999999}, "dynamo/test_logging": {"LoggingTests": 24.4985}, "dynamo/test_minifier": {"MinifierTests": 1.9245000000000003}, "dynamo/test_misc": {"MiscTests": 77.1815000000001, "TestTracer": 0.07300000000000001}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.0045000000000000005}, "dynamo/test_modules": {"NNModuleTests": 3.9434999999999976, "OptimizedModuleTest": 23.725499999999997}, "dynamo/test_nops": {"NopTests": 0.454}, "dynamo/test_optimizers": {"End2EndTests": 0.929}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.7300000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.8104999999999998}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.0015}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.2320000000000002}, "dynamo/test_recompiles": {"RecompileTests": 1.2530000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.7905}, "dynamo/test_repros": {"ReproTests": 49.61749999999997}, "dynamo/test_resume": {"ResumeFunctionTests": 0.664}, "dynamo/test_sdpa": {"TestSDPA": 0.7405}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.8240000000000001}, "dynamo/test_sources": {"SourceTests": 0.7444999999999999}, "dynamo/test_structured_trace": {"StructuredTraceTest": 16.769}, "dynamo/test_subclasses": {"SubclassTests": 4.200499999999997, "TestNestedTensor": 16.151}, "dynamo/test_subgraphs": {"SubGraphTests": 3.185999999999999}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.14150000000000001, "TraceRuleTests": 1.7294999999999998}, "dynamo/test_unspec": {"UnspecTests": 19.63}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.8825000000000001}, "dynamo/test_view": {"ViewTests": 0.9400000000000001}, "export/test_converter": {"TestConverter": 7.155}, "export/test_db": {"ExampleTests": 4.338000000000001}, "export/test_experimental": {"TestExperiment": 1.4035}, "export/test_export": {"TestDynamismExpression": 0.6465, "TestExport": 39.319500000000005, "TestExportCustomClass": 0.092, "TestOneOffModelExportResult": 1.4655}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.5735, "NonStrictExportTestExport": 35.04}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.33}, "export/test_hop": {"TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.1295}, "export/test_pass_infra": {"TestPassInfra": 1.2795000000000003}, "export/test_passes": {"TestPasses": 17.038}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.1414999999999997, "RetraceExportTestExport": 65.98150000000001}, "export/test_schema": {"TestSchema": 0.376}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.7805, "SerDesExportTestExport": 42.105499999999985}, "export/test_serialize": {"TestDeserialize": 10.7, "TestSaveLoad": 0.402, "TestSchemaVersioning": 0.0645, "TestSerialize": 1.5300000000000002, "TestSerializeCustomClass": 0.11599999999999999}, "export/test_sparse": {"TestSparseProp": 81.31199999999986}, "export/test_tools": {"TestExportTools": 0.8140000000000001}, "export/test_torchbind": {"TestCompileTorchbind": 1.4765000000000001, "TestExportTorchbind": 2.435999999999999, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.337}, "export/test_unflatten": {"TestUnflatten": 4.352499999999999}, "export/test_verifier": {"TestVerifier": 1.2985000000000002}, "functorch/test_aotdispatch": {"TestAOTAutograd": 16.693999999999996, "TestAOTAutogradWithDynamo": 18.316999999999986, "TestAOTDispatch": 0.685, "TestAOTExport": 3.033, "TestAOTModuleSimplified": 0.8540000000000001, "TestPartitioning": 1.4125}, "functorch/test_control_flow": {"TestControlFlow": 1.0165000000000002, "TestControlFlowTraced": 149.05299999999994}, "functorch/test_dims": {"TestMin": 20.148, "TestMinFunctorchOnly": 18.515499999999996}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.14950000000000005, "TestSliceArgnums": 0.019000000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.4}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.742, "RandomOpTestCase": 0.11049999999999999, "ReduceTestCase": 0.11149999999999999, "TestMemoryEfficientOpAuthoring": 0.001}, "functorch/test_minifier": {"TestMinifier": 0.597}, "functorch/test_parsing": {"TestAnonymousAxis": 0.337, "TestParsedExpression": 0.007, "TestParsingUtils": 0.006, "TestValidateRearrangeExpressions": 0.006}, "functorch/test_rearrange": {"TestRearrange": 0.40900000000000003}, "functorch/test_vmap": {"TestVmapAPI": 0.3460000000000002, "TestVmapOperators": 4.102499999999991}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.343499999999851}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.251}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 13.102500000000001}, "inductor/test_binary_folding": {"FreezingCpuTests": 51.640499999999996}, "inductor/test_codecache": {"TestFxGraphCache": 55.537499999999994, "TestFxGraphCacheHashing": 0.978, "TestUtils": 4.834, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.3315}, "inductor/test_compile_worker": {"TestCompileWorker": 11.1825}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 410.9390000000002, "TestCompiledAutograd": 252.06850000000009, "TestCustomOpWithCompiledAutograd": 0.7440000000000003}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 335.09600000000063}, "inductor/test_config": {"TestInductorConfig": 8.801}, "inductor/test_control_flow": {"CondTests": 0.11100000000000002, "WhileLoopTests": 0.0055}, "inductor/test_cpu_repro": {"CPUReproTests": 915.7955000000002}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 15.8225}, "inductor/test_debug_trace": {"TestDebugTrace": 4.869999999999999}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0015}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 52.20700000000001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 26.845499999999998}, "inductor/test_flex_attention": {"TestFlexAttention": 0.021000000000000008}, "inductor/test_foreach": {"ForeachTests": 24.485500000000037}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 107.5575, "SDPAPatternRewriterCpuTests": 103.62349999999998}, "inductor/test_fx_fusion": {"TestFxFusion": 0.2965}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.021}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.29400000000000004, "TestGroupBatchFusion": 0.001, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.06150000000000001, "TestIndexingSimplification": 0.827}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 75.5655}, "inductor/test_minifier": {"MinifierTests": 34.154}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 66.732}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 218.359, "TestPatternMatcher": 762.5590000000002}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 23.854999999999997}, "inductor/test_torchbind": {"TestTorchbind": 13.7685}, "inductor/test_torchinductor": {"CpuTests": 1931.4109999999991, "SweepInputsCpuTest": 165.32099999999997, "TestFull": 14.812999999999999}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2039.3904999999968}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2158.803}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.847}, "inductor/test_triton_kernels": {"KernelTests": 0.031000000000000017, "MutationTests": 0.005}, "inductor/test_utils": {"TestUtils": 0.319}, "lazy/test_debug_util": {"DebugUtilTest": 0.398}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.393}, "lazy/test_generator": {"LazyGeneratorTest": 0.395}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.733}, "lazy/test_step_closures": {"ClosuresTest": 3.3305}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.3305, "TestLazyTensor": 0.11499999999999999}, "nn/test_convolution": {"TestConvolutionNN": 19.932000000000002}, "nn/test_dropout": {"TestDropoutNN": 0.14500000000000002}, "nn/test_embedding": {"TestEmbeddingNN": 0.07100000000000004}, "nn/test_init": {"TestNNInit": 5.623499999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.49650000000000016}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.737, "TestLoadStateDictSwap": 0.0675}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.03, "TestModuleHookNN": 0.08850000000000002, "TestModuleHooks": 0.11850000000000002, "TestStateDictHooks": 0.04300000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.444999999999999}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5490000000000002}, "nn/test_parametrization": {"TestNNParametrization": 1.0895000000000001}, "nn/test_pooling": {"TestAvgPool": 0.33799999999999997, "TestPoolingNN": 0.4720000000000001}, "nn/test_pruning": {"TestPruningNN": 0.13300000000000006}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.15749999999999997}, "profiler/test_memory_profiler": {"TestDataFlow": 1.5709999999999997, "TestIdentifyGradients": 0.31000000000000005, "TestMemoryProfiler": 0.4085, "TestMemoryProfilerE2E": 3.766}, "profiler/test_profiler": {"TestExperimentalUtils": 5.64, "TestProfiler": 26.1875, "TestProfilerCUDA": 0.0, "TestProfilerITT": 0.006}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.43600000000000005}, "profiler/test_record_function": {"TestRecordFunction": 0.394}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.120999999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.10250000000000001, "TestBaseDataScheduler": 0.036500000000000005, "TestBaseDataSparsifier": 0.08449999999999999, "TestBaseSparsifier": 0.0315, "TestBaseStructuredSparsifier": 1.6484999999999999, "TestComposability": 2.1035000000000004, "TestCubicScheduler": 0.006, "TestFPGMPruner": 0.025, "TestFakeSparsity": 0.089, "TestFxComposability": 1.8935, "TestNearlyDiagonalSparsifier": 0.895, "TestNormDataSparsifiers": 1.0255, "TestQuantizationUtils": 0.023, "TestQuantizedSparseKernels": 0.3265, "TestQuantizedSparseLayers": 0.4275, "TestSaliencyPruner": 0.030999999999999996, "TestScheduler": 0.019, "TestSparsityUtilFunctions": 0.0465, "TestWeightNormSparsifier": 0.3275}, "test_autocast": {"TestAutocastCPU": 1.493, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.0075}, "test_autograd": {"TestAllowMutationOnSaved": 0.035, "TestAutograd": 23.44100000000006, "TestAutogradComplex": 0.0075, "TestAutogradForwardMode": 0.08550000000000005, "TestAutogradForwardModeBatchedGrad": 0.021500000000000002, "TestAutogradFunctional": 12.631499999999996, "TestAutogradInferenceMode": 0.04400000000000002, "TestAutogradLogging": 0.031, "TestMultithreadAutograd": 0.24450000000000005, "TestNestedCheckpoint": 0.4910000000000001, "TestSelectiveActivationCheckpoint": 0.018}, "test_autograd_fallback": {"TestAutogradFallback": 0.5015000000000001}, "test_bundled_inputs": {"TestBundledInputs": 1.573}, "test_comparison_utils": {"TestComparisonUtils": 0.322}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_cpp_api_parity": {"TestCppApiParity": 4.868499999999981}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.031000000000000007, "TestMAIATensor": 0.0105, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03200000000000001, "TestMAIATensor": 0.0145, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 60.18899999999999}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.063}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 11.951000000000002}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.072}, "test_custom_backend": {"TestCustomBackend": 0.10949999999999999}, "test_custom_ops": {"MiniOpTest": 0.7940000000000003, "MiniOpTestOther": 0.07650000000000003, "TestCustomOp": 3.3534999999999924, "TestCustomOpAPI": 0.14650000000000005, "TestCustomOperators": 0.41450000000000004, "TestGenerateOpcheckTests": 4.157}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.06, "TestCustomPinFn": 0.002, "TestDataLoader": 109.45000000000005, "TestDataLoaderPersistentWorkers": 143.2495, "TestDatasetRandomSplit": 0.036500000000000005, "TestDictDataLoader": 0.05449999999999999, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.006500000000000001, "TestSetAffinity": 0.084, "TestStackDataset": 0.03450000000000001, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.024}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.0025, "TestFunctionalIterDataPipe": 7.115499999999998, "TestFunctionalMapDataPipe": 0.044, "TestGraph": 0.018000000000000002, "TestIterDataPipeCountSampleYielded": 0.011, "TestIterDataPipeGraphFastForward": 0.05600000000000001, "TestIterDataPipeSingletonConstraint": 0.028500000000000004, "TestIterableDataPipeBasic": 0.034, "TestSerialization": 7.746499999999999, "TestSharding": 0.24200000000000005, "TestStreamWrapper": 0.342, "TestTyping": 0.005}, "test_decomp": {"HasDecompTest": 0.22199999999999998}, "test_deploy": {"TestFreezer": 0.325}, "test_dispatch": {"TestDispatch": 41.653499999999994, "TestPythonDispatcher": 0.0495}, "test_dynamic_shapes": {"TestDimConstraints": 2.59, "TestFloorDiv": 0.013500000000000002, "TestGuardsExpressions": 0.018000000000000002, "TestPySymInt": 1.5875000000000001, "TestSymNumberMagicMethods": 1.9924999999999926}, "test_fake_tensor": {"FakeTensorConstHandling": 0.09100000000000001, "FakeTensorConverterTest": 0.030000000000000006, "FakeTensorDispatchCache": 0.091, "FakeTensorOperatorInvariants": 0.5665, "FakeTensorPropTest": 0.0935, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 1.1810000000000003, "PropagateRealTensorsFakeTensorConstHandling": 0.12000000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.029000000000000005, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.22699999999999998, "PropagateRealTensorsFakeTensorPropTest": 0.0655, "PropagateRealTensorsFakeTensorTest": 0.31600000000000006}, "test_flop_counter": {"TestFlopCounter": 0.5565000000000001}, "test_function_schema": {"TestFunctionSchema": 0.7124999999999999}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 41.488}, "test_functional_optim": {"TestFunctionalOptimParity": 0.4605000000000001}, "test_functionalization": {"TestCrossRefFunctionalization": 3.0024999999999995, "TestFunctionalization": 3.4319999999999995}, "test_futures": {"TestFuture": 1.28}, "test_fx": {"AnnotationsTest": 0.017500000000000005, "TestCSEPass": 0.3415000000000001, "TestCommonPass": 0.07999999999999999, "TestConstFold": 0.19800000000000006, "TestConstParamShapeInControlFlow": 0.05449999999999999, "TestDCE": 0.0385, "TestFX": 4.0554999999999986, "TestFXAPIBackwardCompatibility": 0.0355, "TestFunctionalTracing": 0.45650000000000035, "TestMatcher": 0.5065000000000001, "TestPassManager": 0.030000000000000006, "TestSourceMatcher": 1.541, "TestSubgraphRewriter": 0.3705000000000001, "TestVisionTracing": 336.57050000000004, "TypeCheckerTest": 2.3879999999999972}, "test_fx_experimental": {"TestFXExperimental": 20.648, "TestTranslationValidation": 0.1525}, "test_fx_passes": {"TestFXGraphPasses": 0.8010000000000002, "TestFXMatcherUtils": 0.10850000000000004}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5615000000000001}, "test_import_stats": {"TestImportTime": 4.798}, "test_itt": {"TestItt": 0.33899999999999997}, "test_jit": {"TestAliasAnalysis": 0.42350000000000004, "TestAsync": 0.4630000000000001, "TestAtenPow": 0.009000000000000001, "TestAutodiffJit": 0.0805, "TestAutodiffSubgraphSlicing": 0.3390000000000001, "TestAwait": 0.24150000000000005, "TestBackends": 0.783, "TestBackendsWithCompiler": 0.1655, "TestBatchMM": 0.093, "TestBuiltins": 0.0695, "TestClassType": 3.296999999999999, "TestComplex": 0.9455000000000002, "TestCustomOperators": 0.047500000000000014, "TestDCE": 0.022, "TestDataParallel": 0.0025, "TestDataclasses": 6.195, "TestDeviceAnalysis": 4.4795, "TestDict": 0.4620000000000002, "TestDtypeAnalysis": 0.1735, "TestEnum": 0.2755, "TestFreezing": 2.821, "TestFrontend": 0.6205, "TestFrozenOptimizations": 13.174999999999997, "TestFunctionalBlocks": 0.0095, "TestFunctionalToInplaceActivation": 2.801, "TestGenerator": 0.0765, "TestGetDefaultAttr": 0.017, "TestGraphRewritePasses": 0.0495, "TestHash": 0.08399999999999999, "TestHooks": 0.8880000000000003, "TestIgnorableArgs": 0.013500000000000002, "TestIgnoreContextManager": 0.059, "TestInplaceToFunctionalActivation": 2.687, "TestIsinstance": 0.27950000000000014, "TestJit": 7.035499999999995, "TestJitGeneratedModule": 12.529999999999974, "TestJitProfiler": 0.0015, "TestJitUtils": 0.018000000000000006, "TestList": 1.4240000000000006, "TestLogging": 0.05299999999999999, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.2245000000000001, "TestMixTracingScripting": 1.5, "TestModels": 2.0684999999999993, "TestModuleAPIs": 0.1535, "TestModuleContainers": 1.2950000000000004, "TestModuleInterface": 0.5910000000000001, "TestModules": 0.015, "TestNamedTuple": 0.07200000000000002, "TestNnapiBackend": 11.0895, "TestOpDecompositions": 0.018500000000000003, "TestOptimizeForMobilePreserveDebugInfo": 0.1775, "TestPDT": 0.4415000000000001, "TestParametrization": 0.0995, "TestPeephole": 0.5620000000000003, "TestProducerVersion": 0.0015, "TestProfiler": 0.7835000000000001, "TestPythonBindings": 0.039, "TestPythonBuiltinOP": 0.4455, "TestPythonIr": 0.028, "TestRecursiveScript": 0.7655000000000002, "TestRemoveMutation": 0.1405, "TestSaveLoad": 0.7410000000000001, "TestSaveLoadFlatbuffer": 0.5745, "TestSaveLoadForOpVersion": 2.808, "TestScript": 44.29249999999999, "TestScriptDict": 0.03300000000000001, "TestScriptList": 0.8735000000000002, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2295000000000001, "TestScriptProfile": 0.3685, "TestSlice": 0.20450000000000004, "TestSparse": 0.055, "TestStringFormatting": 0.14550000000000007, "TestSymbolicShapeAnalysis": 1.9169999999999985, "TestTensorBuiltins": 0.0915, "TestTensorCreationOps": 0.0635, "TestTensorMethods": 0.014, "TestTorchbind": 0.13500000000000004, "TestTracer": 3.1149999999999958, "TestTypeSharing": 0.5425000000000001, "TestTypesAndAnnotation": 0.16500000000000004, "TestTyping": 0.40950000000000014, "TestUnion": 0.47600000000000026, "TestUnsupportedOps": 0.0305, "TestUpgraders": 0.098, "TestWarn": 0.067, "TestWith": 0.7095}, "test_jit_autocast": {"TestAutocast": 0.126, "TestJitTraceAutocast": 20.4505}, "test_jit_disabled": {"TestJitDisabled": 0.4575000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.17400000000000002, "TestTEFuserDynamic": 130.18600000000004, "TestTEFuserStatic": 51.90800000000001}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.092, "TestModel": 3.005}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2380000000000002, "TestVmapOperatorsLegacy": 1.1515000000000002}, "test_license": {"TestLicense": 0.3265}, "test_logging": {"LoggingTest": 3.4269999999999996}, "test_maskedtensor": {"TestBinary": 0.41300000000000026, "TestReductions": 0.09400000000000003, "TestUnary": 0.3775000000000003}, "test_meta": {"TestMetaConverter": 0.06900000000000003}, "test_mkl_verbose": {"TestMKLVerbose": 5.2355}, "test_mkldnn_fusion": {"TestMkldnnFusion": 78.22250000000001}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.948}, "test_mobile_optimizer": {"TestOptimizer": 3.7855}, "test_model_dump": {"TestModelDump": 1.2489999999999999}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.27149999999999996}, "test_module_tracker": {"TestModuleTracker": 0.3325}, "test_monitor": {"TestMonitor": 0.3345, "TestMonitorTensorboard": 0.1845}, "test_multiprocessing": {"TestMultiprocessing": 66.33999999999999}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.9065, "SpawnTest": 36.9525}, "test_namedtensor": {"TestNamedTensor": 0.4175000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.263}, "test_native_functions": {"TestNativeFunctions": 0.4790000000000001}, "test_nestedtensor": {"TestNestedTensor": 0.15650000000000008}, "test_nn": {"TestAddRelu": 0.005, "TestConstantPadNd": 0.0045000000000000005, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.4235, "TestFusionUtils": 0.006, "TestNN": 54.92949999999992, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.0015}, "test_openmp": {"TestOpenMP_ParallelFor": 6.6205}, "test_ops": {"TestSelfKwarg": 0.0045000000000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.24100000000000005, "TestLRScheduler": 1.2450000000000006, "TestSWAUtils": 0.20399999999999996}, "test_out_dtype_op": {"TestOutDtypeOp": 0.3935}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.0015, "TestDisabledUserWarnings": 0.0015, "TestEinsumOverride": 0.0295, "TestGradCheckOverride": 0.025500000000000002, "TestGradNewOnesOverride": 0.0015, "TestIndexing": 0.0125, "TestIterator": 0.0015, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.003, "TestResolveName": 0.127, "TestTorchFunctionMode": 0.03800000000000002, "TestTorchFunctionOverride": 2.5094999999998935, "TestTorchFunctionWarning": 0.018000000000000002, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.0495, "ModelTest": 0.0, "TestAnalyze": 0.3125, "TestDependencyAPI": 0.06200000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.018000000000000006, "TestGlobGroup": 0.025000000000000012, "TestImporter": 0.014000000000000002, "TestLoadBCPackages": 0.08399999999999999, "TestMangling": 0.018500000000000003, "TestMisc": 0.052500000000000005, "TestPackageFX": 0.07749999999999999, "TestPackageScript": 2.339499999999999, "TestRepackage": 0.0115, "TestResources": 0.013500000000000002, "TestSaveLoad": 0.043000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.337}, "test_prims": {"TestPrimsBasic": 0.018000000000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.12400000000000003, "TestGenericProxyTensorFake": 2.71, "TestGenericProxyTensorReal": 2.8264999999999993, "TestGenericProxyTensorSymbolic": 20.9705, "TestRealProxyTensor": 0.0195, "TestSymbolicTracing": 4.311499999999999}, "test_pruning_op": {"PruningOpTest": 0.5545}, "test_public_bindings": {"TestPublicBindings": 7.614999999999999}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.31650000000000017, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.263}, "test_pytree": {"TestCxxPytree": 0.022000000000000006, "TestGenericPytree": 0.5105000000000002, "TestPythonPytree": 0.07850000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.016500000000000004, "TestAOMigrationNNQuantized": 0.06850000000000002, "TestAOMigrationQuantization": 0.022500000000000006, "TestAOMigrationQuantizationFx": 0.022500000000000003, "TestBackendConfig": 0.058000000000000024, "TestBiasCorrectionEager": 2.127, "TestComparatorOps": 1.9554999999999998, "TestDeprecatedJitQuantized": 5.397, "TestDistributed": 0.031, "TestDuplicateDQPass": 3.5555000000000003, "TestDynamicQuantizedModule": 48.66, "TestDynamicQuantizedOps": 30.07550000000001, "TestEqualizeEager": 0.117, "TestEqualizeFx": 6.940500000000001, "TestFXGraphMatcher": 2.1075, "TestFXGraphMatcherModels": 11.716, "TestFXNumericSuiteCoreAPIs": 32.9325, "TestFXNumericSuiteCoreAPIsModels": 47.575500000000005, "TestFXNumericSuiteNShadows": 44.403999999999996, "TestFakeQuantize": 0.4135, "TestFakeQuantizeOps": 2.172, "TestFuseEager": 3.3289999999999997, "TestFuseFx": 2.513499999999999, "TestFusedObsFakeQuant": 0.097, "TestFusedObsFakeQuantModule": 0.21450000000000002, "TestFusionPasses": 0.024, "TestFxDetectInputWeightEqualization": 0.21250000000000002, "TestFxDetectOutliers": 0.3025, "TestFxModelReportClass": 0.567, "TestFxModelReportDetectDynamicStatic": 0.074, "TestFxModelReportDetector": 0.21650000000000003, "TestFxModelReportObserver": 0.23850000000000005, "TestFxModelReportVisualizer": 0.23149999999999998, "TestGenerateNumericDebugHandle": 0.8845000000000001, "TestGraphUtils": 2.5075000000000003, "TestHistogramObserver": 44.083, "TestMetaDataPorting": 7.897000000000002, "TestModelNumericsEager": 1.539, "TestNumericSuiteEager": 9.869, "TestObserver": 4.269499999999999, "TestPT2ERepresentation": 33.052, "TestPadding": 27.348, "TestQNNPackOps": 6.724499999999997, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.2475, "TestQuantizeDynamicJitPasses": 5.589, "TestQuantizeEagerOps": 1.9049999999999998, "TestQuantizeEagerPTQDynamic": 9.0695, "TestQuantizeEagerPTQStatic": 33.744, "TestQuantizeEagerQAT": 12.518500000000003, "TestQuantizeEagerQATNumerics": 2.2569999999999997, "TestQuantizeFx": 45.885, "TestQuantizeFxModels": 6.739000000000001, "TestQuantizeFxOps": 133.90300000000002, "TestQuantizeJit": 24.574999999999996, "TestQuantizeJitOps": 287.8645, "TestQuantizeJitPasses": 6.049499999999999, "TestQuantizePT2E": 58.30199999999998, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 365.13700000000006, "TestQuantizePT2EQAT_ConvBn2d": 371.244, "TestQuantizePT2EX86Inductor": 96.36099999999999, "TestQuantizedConv": 61.066500000000005, "TestQuantizedEmbeddingOps": 1.4035000000000002, "TestQuantizedFunctionalOps": 3.2395, "TestQuantizedLinear": 26.508500000000005, "TestQuantizedOps": 122.20450000000002, "TestQuantizedTensor": 2.1915, "TestRecordHistogramObserver": 0.039, "TestReferenceQuantizedModule": 0.052500000000000005, "TestSerialization": 1.9865000000000002, "TestStaticQuantizedModule": 85.324, "TestSubgraphRewriter": 1.038, "TestUtils": 0.022000000000000002, "TestXNNPACKQuantizer": 50.0055, "TestXNNPACKQuantizerModels": 3.9844999999999997}, "test_schema_check": {"TestSchemaCheck": 0.13550000000000006}, "test_serialization": {"TestOldSerialization": 39.248999999999995, "TestSerialization": 13.137000000000022, "TestSubclassSerialization": 0.03150000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.3245}, "test_show_pickle": {"TestShowPickle": 0.378}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.0345, "TestSparseMeta": 4.7604999999999995, "TestSparseOneOff": 0.0025}, "test_sparse_csr": {"TestSparseCSRSampler": 0.629}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0015}, "test_stateless": {"TestPythonOptimizeMode": 4.871, "TestStatelessDeprecation": 2.2935, "TestStatelessFunctionalAPI": 0.2745000000000001}, "test_subclass": {"TestSubclass": 0.5500000000000002}, "test_sympy_utils": {"TestNumbers": 0.035, "TestSingletonInt": 0.0075, "TestSympyInterp": 11.6725, "TestSympySolve": 0.379, "TestValueRanges": 7.821499999999997}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.025500000000000002, "TestTensorBoardFigure": 0.0025, "TestTensorBoardNumpy": 0.0045000000000000005, "TestTensorBoardPyTorchNumpy": 0.24350000000000002, "TestTensorBoardPytorchGraph": 36.685, "TestTensorBoardSummary": 0.05400000000000002, "TestTensorBoardSummaryWriter": 0.009000000000000001, "TestTensorBoardUtils": 0.21300000000000002, "TestTensorBoardWriter": 0.1235, "TestTensorProtoSummary": 0.012}, "test_tensorexpr": {"TestTensorExprFuser": 67.64250000000001}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.012, "TestTensorExprPyBind": 1.0980000000000003}, "test_testing": {"TestAssertClose": 0.15550000000000008, "TestAssertCloseContainer": 0.0075, "TestAssertCloseErrorMessage": 0.06900000000000002, "TestAssertCloseQuantized": 0.014500000000000002, "TestAssertCloseSparseBSC": 0.019500000000000003, "TestAssertCloseSparseBSR": 0.019500000000000003, "TestAssertCloseSparseCOO": 0.0235, "TestAssertCloseSparseCSC": 0.0205, "TestAssertCloseSparseCSR": 0.019500000000000003, "TestFrameworkUtils": 15.860499999999998, "TestImports": 15.8555, "TestOpInfos": 0.005, "TestTestParametrization": 0.03750000000000001}, "test_torch": {"TestBasicVitalSigns": 0.017, "TestTorch": 7.866999999999991}, "test_type_hints": {"TestTypeHints": 0.319}, "test_type_info": {"TestDTypeInfo": 0.34600000000000003}, "test_typing": {"TestTyping": 101.67950000000006}, "test_utils": {"TestAssert": 0.079, "TestBottleneck": 11.620000000000001, "TestCheckpoint": 0.101, "TestCollectEnv": 1.2375, "TestCppExtensionUtils": 0.0445, "TestDataLoaderUtils": 0.28, "TestExtensionUtils": 0.006, "TestHipify": 0.0015, "TestHipifyTrie": 0.009000000000000001, "TestONNXUtils": 0.005, "TestRenderUtils": 0.0195, "TestStandaloneCPPJIT": 3.1769999999999996, "TestTraceback": 0.0125}, "test_vulkan": {"TestVulkanRewritePass": 0.003}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.025500000000000002, "WeakKeyDictionaryTestCase": 0.024, "WeakTest": 5.306499999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 4.7225, "TestXNNPACKRewritePass": 1.709, "TestXNNPACKSerDes": 5.292}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0025}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.35500000000000004, "TestClassGetItem": 0.0005, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0015, "TestMisc": 0.004, "TestPickling": 0.1365, "TestPromotion": 0.0015}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 18.578500000000002, "TestEinsumPath": 0.001, "TestMisc": 0.006}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0015, "TestHalf": 0.0, "TestIinfo": 0.36000000000000004, "TestMisc": 0.0025, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.0075, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.009000000000000001, "TestIndexing": 0.5060000000000001, "TestMultiIndexingAutomated": 0.009000000000000001, "TestMultipleEllipsisError": 0.003, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.021500000000000005, "TestArgmax": 1.2965000000000009, "TestArgmaxArgminCommon": 0.07250000000000004, "TestArgmin": 1.348500000000001, "TestArrayAttributeDeletion": 0.0075, "TestArrayConstruction": 0.047500000000000014, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.0105, "TestAttributes": 0.028500000000000004, "TestBinop": 0.021, "TestBool": 28.713000000000008, "TestCequenceMethods": 0.003, "TestChoose": 0.021500000000000005, "TestClip": 0.0075, "TestCompress": 0.0045000000000000005, "TestConversion": 0.041, "TestCreation": 0.0015, "TestDelMisc": 0.0015, "TestDot": 0.08550000000000003, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.019500000000000003, "TestFormat": 0.006, "TestFromBuffer": 0.013500000000000002, "TestHash": 0.211, "TestHashing": 0.0035, "TestIO": 0.0015, "TestInner": 0.2455, "TestLexsort": 0.022500000000000003, "TestMatmul": 0.49350000000000016, "TestMatmulOperator": 0.357, "TestMethods": 1.6565000000000007, "TestMinMax": 0.006500000000000001, "TestMinScalarType": 0.006500000000000001, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.014000000000000002, "TestRepeat": 0.0155, "TestResize": 0.05550000000000001, "TestRichcompareScalar": 0.0005, "TestScalarIndexing": 0.025500000000000002, "TestSortFloatMisc": 0.18850000000000008, "TestStats": 0.272, "TestSubscripting": 0.0025, "TestTake": 0.04250000000000001, "TestVdot": 0.04350000000000001, "TestWarnings": 0.0015, "TestWhere": 0.399, "TestWritebackIfCopy": 0.033}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.024, "TestArgwhere": 0.033, "TestArrayComparisons": 0.015, "TestBaseRepr": 0.006, "TestBinaryRepr": 0.009000000000000001, "TestBoolArray": 2.625, "TestBoolCmp": 0.202, "TestBoolScalar": 0.0105, "TestBroadcast": 0.0075, "TestClip": 0.22300000000000011, "TestConvolve": 0.023, "TestCorrelate": 0.065, "TestCreationFuncs": 1.2445000000000002, "TestCross": 0.059, "TestDtypePositional": 0.003, "TestFloatExceptions": 0.0105, "TestFromiter": 0.0, "TestIndex": 0.007, "TestIndices": 0.046000000000000006, "TestIsclose": 0.0995, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.0105, "TestNonarrayArgs": 0.13700000000000007, "TestNonzeroAndCountNonzero": 0.28750000000000003, "TestOuterMisc": 0.006, "TestRequire": 0.006, "TestResize": 0.35800000000000004, "TestRoll": 0.0385, "TestRollaxis": 0.006, "TestSeterr": 0.008, "TestStdVar": 0.033, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0015, "TestTensordot": 0.018000000000000002, "TestTypes": 0.0165}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.325, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.09300000000000007, "TestFromInt": 0.008, "TestFromString": 0.33199999999999996}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0005, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.0, "TestIsInteger": 0.0015}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.12000000000000002, "TestBaseMath": 10.997499999999999, "TestBitShifts": 0.11499999999999999, "TestComplexDivision": 0.07300000000000001, "TestConversion": 0.06100000000000001, "TestHash": 0.0025, "TestModulus": 1.226, "TestMultiply": 0.0, "TestNegative": 0.0225, "TestPower": 0.15950000000000003, "TestRepr": 0.0015, "TestScalarOpsMisc": 0.06250000000000003, "TestScalarSubclassingMisc": 0.015000000000000003, "TestSubtract": 0.0225, "TestTypes": 17.945}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.341, "TestAtleast2d": 0.019500000000000003, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.030000000000000016, "TestConcatenate": 0.1865000000000001, "TestHstack": 0.021000000000000005, "TestStackMisc": 0.0045000000000000005, "TestVstack": 0.022500000000000006}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.012, "TestFFTShift": 7.297000000000001, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.012}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.4365000000000014, "TestFFTShift": 0.326, "TestFFTThreadSafe": 0.885}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.354}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.010500000000000006, "TestUnique": 0.5800000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0075, "TestAmin": 0.0075, "TestAngle": 0.012, "TestAny": 0.009000000000000001, "TestAverage": 0.029999999999999995, "TestBincount": 0.05549999999999999, "TestCheckFinite": 0.003, "TestCopy": 0.009000000000000001, "TestCorrCoef": 0.051000000000000004, "TestCov": 0.07500000000000001, "TestCumprod": 0.0385, "TestCumsum": 0.0495, "TestDelete": 0.0225, "TestDiff": 0.093, "TestDigitize": 0.020000000000000004, "TestExtins": 0.008, "TestFilterwindows": 0.7145000000000006, "TestFlip": 0.038500000000000006, "TestGradient": 0.17400000000000002, "TestInsert": 0.0115, "TestInterp": 0.05300000000000003, "TestKaiser": 0.012, "TestMedian": 0.13050000000000003, "TestMeshgrid": 0.06800000000000002, "TestMsort": 0.0, "TestPercentile": 0.08150000000000004, "TestPiecewise": 0.012, "TestProd": 0.037000000000000005, "TestPtp": 0.012, "TestQuantile": 0.022500000000000006, "TestRot90": 0.387, "TestSelect": 0.0095, "TestSinc": 0.0105, "TestSortComplex": 0.0125, "TestTrapz": 0.0075, "TestTrimZeros": 0.0125, "TestUnique": 0.006, "Test_I0": 0.0205}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4760000000000001, "TestHistogramOptimBinNums": 0.03650000000000001, "TestHistogramdd": 0.1815}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0015, "TestConcatenator": 0.0095, "TestDiagIndices": 0.006, "TestDiagIndicesFrom": 0.009000000000000001, "TestFillDiagonal": 0.0315, "TestGrid": 0.011, "TestIndexExpression": 0.013500000000000002, "TestIx_": 0.009000000000000001, "TestNdIndex": 0.0015, "TestNdenumerate": 0.002, "TestRavelUnravelIndex": 0.36250000000000004}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.020000000000000004, "TestApplyOverAxes": 0.0015, "TestArraySplit": 0.20450000000000002, "TestColumnStack": 0.013000000000000001, "TestDsplit": 0.012, "TestDstack": 0.023, "TestExpandDims": 0.009000000000000001, "TestHsplit": 0.016, "TestKron": 0.013999999999999999, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.012, "TestSplit": 0.0075, "TestSqueeze": 0.0345, "TestTakeAlongAxis": 0.395, "TestTile": 0.10300000000000001, "TestVsplit": 0.0125}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.3965, "TestFliplr": 0.006, "TestFlipud": 0.006, "TestHistogram2d": 0.04050000000000001, "TestTri": 0.10200000000000001, "TestTrilIndicesFrom": 0.0015, "TestTriuIndices": 0.004, "TestTriuIndicesFrom": 0.0015, "TestVander": 0.021}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0015, "TestCommonType": 0.354, "TestImag": 0.015, "TestIscomplex": 0.006, "TestIscomplexobj": 0.0045000000000000005, "TestIsfinite": 0.021, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.02, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.0105, "TestIsrealobj": 0.002, "TestIsscalar": 0.0025, "TestMintypecode": 0.007, "TestNanToNum": 0.016, "TestReal": 0.0165, "TestRealIfClose": 0.0045000000000000005}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.19400000000000003, "TestCond": 0.26049999999999995, "TestDet": 0.1845, "TestEig": 0.046500000000000014, "TestEigh": 0.031000000000000007, "TestEighCases": 0.0, "TestEigvals": 0.0955, "TestEigvalsh": 0.026000000000000002, "TestEigvalshCases": 0.0, "TestInv": 0.06050000000000001, "TestLstsq": 0.254, "TestMatrixRank": 0.4720000000000001, "TestMisc": 0.026500000000000003, "TestMisc2": 0.003, "TestMultiDot": 0.0685, "TestNormDouble": 0.9445, "TestNormInt64": 0.95, "TestNormSingle": 0.9570000000000001, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.135, "TestPinvHermitian": 0.05, "TestQR": 0.49450000000000005, "TestSVD": 0.06000000000000001, "TestSVDHermitian": 0.11600000000000002, "TestSolve": 0.40700000000000003, "TestTensorinv": 0.022, "TestTensorsolve": 0.0035}, "torch_np/test_basic": {"TestArrayToSequence": 0.009000000000000001, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.0045000000000000005, "TestDefaultDtype": 0.0085, "TestDivmod": 0.019500000000000003, "TestExport": 0.0, "TestMisc": 0.0015, "TestNormalizations": 0.006, "TestOneArr": 0.36900000000000027, "TestOneArrAndAxesTuple": 0.013500000000000002, "TestOneArrAndAxis": 0.20800000000000013, "TestOneArrAndShape": 0.02200000000000001, "TestOneArrToScalar": 0.013500000000000002, "TestPythonArgsToArray": 0.0165, "TestSequenceOfArrays": 0.02400000000000001, "TestSequenceOfArraysToSingle": 0.011, "TestShapeLikeToArray": 0.006, "TestSmokeNotImpl": 0.0015}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.4760000000000001}, "torch_np/test_dtype": {"TestConvertDType": 0.397}, "torch_np/test_function_base": {"TestAppend": 0.334}, "torch_np/test_ndarray_methods": {"TestAmax": 0.009000000000000001, "TestAmin": 0.009000000000000001, "TestArgmax": 1.2160000000000009, "TestArgmaxArgminCommon": 0.07100000000000004, "TestArgmin": 1.386000000000001, "TestContains": 0.003, "TestIndexing": 0.3615, "TestIter": 0.006, "TestNoExtraMethods": 0.009000000000000001, "TestNonzero": 0.1715, "TestRavel": 0.009000000000000001, "TestReshape": 0.007, "TestTranspose": 0.0115}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.0165, "TestNEP50Table": 0.0025}, "torch_np/test_random": {"TestChoice": 0.015, "TestNumpyGlobal": 0.0045000000000000005, "TestScalarReturn": 0.378, "TestShuffle": 0.016000000000000004}, "torch_np/test_reductions": {"TestAll": 0.013500000000000002, "TestAny": 0.015, "TestFlatnonzero": 0.312, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.5414999999999384, "TestMean": 0.024, "TestSum": 0.25449999999999995}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.3935, "TestIsScalar": 0.055000000000000035}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.7355000000000005, "TestNdarrayDunderVsUfunc": 0.2405000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.3785}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.4885000000000001}}, "nogpu_NO_AVX2": {"backends/xeon/test_launch": {"TestTorchrun": 2.731}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.795}, "distributions/test_distributions": {"TestAgainstScipy": 1.7274999999999998, "TestConstraints": 0.22000000000000003, "TestDistributionShapes": 0.18950000000000009, "TestDistributions": 55.45700000000001, "TestFunctors": 0.0165, "TestJit": 29.397999999999996, "TestKL": 4.529999999999999, "TestLazyLogitsInitialization": 0.0205, "TestNumericalStability": 0.11200000000000002, "TestRsample": 1.0305, "TestValidation": 0.5175000000000001}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.8630000000000001}, "dynamo/test_after_aot": {"TestAfterAot": 10.4275}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 20.061500000000002}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 2.0, "AOTAutogradCacheTests": 14.835}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.276499999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.0545, "TestCustomBackendAPI": 2.618, "TestExplainWithBackend": 17.2365, "TestOptimizations": 3.012999999999999}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 19.087}, "dynamo/test_base_output": {"TestBaseOutput": 0.004}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.616333333333333}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 9.309, "BytecodeTests": 0.7115}, "dynamo/test_compile": {"InPlaceCompilationTests": 11.18, "PublicTorchCompilerTests": 0.004}, "dynamo/test_comptime": {"ComptimeTests": 0.9655000000000002}, "dynamo/test_config": {"ConfigTests": 0.9199999999999999}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.9385000000000008}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.3885}, "dynamo/test_decorators": {"DecoratorTests": 10.703499999999998}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.0225}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 50.234, "DynamicShapesCtxManagerTests": 7.683, "DynamicShapesExportTests": 43.980999999999995, "DynamicShapesFuncTorchHigherOrderOpTests": 141.01699999999997, "DynamicShapesFunctionTests": 101.90199999999999, "DynamicShapesHigherOrderOpTests": 24.07349999999999, "DynamicShapesMiscTests": 124.05250000000008, "DynamicShapesNNModuleTests": 9.3555, "DynamicShapesReproTests": 145.22249999999997, "DynamicShapesSubGraphTests": 12.7285, "DynamicShapesTestSDPA": 0.53}, "dynamo/test_exc": {"ExcTests": 2.9869999999999997}, "dynamo/test_exceptions": {"ExceptionTests": 0.8710000000000001}, "dynamo/test_export": {"ExportTests": 23.330500000000004}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8925000000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.369}, "dynamo/test_functions": {"DefaultsTests": 1.1870000000000003, "FunctionTests": 34.63100000000013}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.7399999999999998}, "dynamo/test_global": {"TestGlobals": 0.9190000000000002}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.41550000000000004}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.11200000000000002, "FuncTorchHigherOrderOpTests": 11.661499999999998, "HigherOrderOpTests": 11.774499999999998, "HigherOrderOpVmapGuardTests": 5.6795}, "dynamo/test_hooks": {"HooksTests": 38.863}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 7.022499999999999, "InlineInbuiltNNModulesExportTests": 31.571999999999992, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 11.380999999999998, "InlineInbuiltNNModulesFunctionTests": 7.021499999999992, "InlineInbuiltNNModulesHigherOrderOpTests": 10.785999999999996, "InlineInbuiltNNModulesMiscTests": 77.9025000000001, "InlineInbuiltNNModulesNNModuleTests": 6.240999999999997}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 12.733}, "dynamo/test_interop": {"InteropTests": 0.9285}, "dynamo/test_logging": {"LoggingTests": 26.946000000000005}, "dynamo/test_minifier": {"MinifierTests": 2.1109999999999993}, "dynamo/test_misc": {"MiscTests": 87.96550000000015, "TestTracer": 0.0905}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.0045000000000000005}, "dynamo/test_modules": {"NNModuleTests": 4.241999999999998, "OptimizedModuleTest": 24.523000000000003}, "dynamo/test_nops": {"NopTests": 0.48949999999999994}, "dynamo/test_optimizers": {"End2EndTests": 1.0255}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.793}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.9649999999999999}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.066}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.3270000000000002}, "dynamo/test_recompiles": {"RecompileTests": 1.4340000000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.8640000000000001}, "dynamo/test_repros": {"ReproTests": 56.286000000000016}, "dynamo/test_resume": {"ResumeFunctionTests": 0.727}, "dynamo/test_sdpa": {"TestSDPA": 0.779}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.896}, "dynamo/test_sources": {"SourceTests": 0.7945}, "dynamo/test_structured_trace": {"StructuredTraceTest": 17.5765}, "dynamo/test_subclasses": {"SubclassTests": 4.572999999999998, "TestNestedTensor": 17.434}, "dynamo/test_subgraphs": {"SubGraphTests": 3.4914999999999985}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.14400000000000002, "TraceRuleTests": 1.7699999999999996}, "dynamo/test_unspec": {"UnspecTests": 20.399999999999995}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.9505}, "dynamo/test_view": {"ViewTests": 1.0419999999999998}, "export/test_converter": {"TestConverter": 7.475000000000001}, "export/test_db": {"ExampleTests": 4.6555}, "export/test_experimental": {"TestExperiment": 1.4775}, "export/test_export": {"TestDynamismExpression": 0.6910000000000001, "TestExport": 42.96999999999999, "TestExportCustomClass": 0.10800000000000001, "TestOneOffModelExportResult": 1.6435}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.597, "NonStrictExportTestExport": 38.003999999999984}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.3595}, "export/test_hop": {"TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.14500000000000002}, "export/test_pass_infra": {"TestPassInfra": 1.3465000000000003}, "export/test_passes": {"TestPasses": 18.533499999999997}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.2075, "RetraceExportTestExport": 67.13050000000001}, "export/test_schema": {"TestSchema": 0.42800000000000005}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.7935000000000001, "SerDesExportTestExport": 46.11399999999999}, "export/test_serialize": {"TestDeserialize": 11.550500000000003, "TestSaveLoad": 0.463, "TestSchemaVersioning": 0.047, "TestSerialize": 1.6035000000000004, "TestSerializeCustomClass": 0.135}, "export/test_sparse": {"TestSparseProp": 90.63399999999994}, "export/test_tools": {"TestExportTools": 0.856}, "export/test_torchbind": {"TestCompileTorchbind": 1.5645000000000002, "TestExportTorchbind": 2.6794999999999995, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.365}, "export/test_unflatten": {"TestUnflatten": 4.664000000000001}, "export/test_verifier": {"TestVerifier": 1.4180000000000001}, "functorch/test_aotdispatch": {"TestAOTAutograd": 17.891499999999994, "TestAOTAutogradWithDynamo": 19.793499999999995, "TestAOTDispatch": 0.7204999999999999, "TestAOTExport": 3.6414999999999997, "TestAOTModuleSimplified": 0.9555, "TestPartitioning": 1.4405000000000001}, "functorch/test_control_flow": {"TestControlFlow": 1.1110000000000002, "TestControlFlowTraced": 164.30050000000003}, "functorch/test_dims": {"TestMin": 23.535, "TestMinFunctorchOnly": 22.3915}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.14650000000000005, "TestSliceArgnums": 0.019500000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.4235}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.796, "RandomOpTestCase": 0.11499999999999999, "ReduceTestCase": 0.1245, "TestMemoryEfficientOpAuthoring": 0.003}, "functorch/test_minifier": {"TestMinifier": 0.6545}, "functorch/test_parsing": {"TestAnonymousAxis": 0.361, "TestParsedExpression": 0.0085, "TestParsingUtils": 0.007, "TestValidateRearrangeExpressions": 0.008}, "functorch/test_rearrange": {"TestRearrange": 0.44250000000000006}, "functorch/test_vmap": {"TestVmapAPI": 0.37000000000000016, "TestVmapOperators": 4.311499999999991}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.493499999999839}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.8705}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 14.393}, "inductor/test_binary_folding": {"FreezingCpuTests": 54.825500000000005}, "inductor/test_codecache": {"TestFxGraphCache": 58.73449999999998, "TestFxGraphCacheHashing": 1.0114999999999998, "TestUtils": 5.069, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.3535}, "inductor/test_compile_worker": {"TestCompileWorker": 11.909500000000001}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 429.95450000000073, "TestCompiledAutograd": 264.312, "TestCustomOpWithCompiledAutograd": 0.7505000000000004}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 349.13150000000064}, "inductor/test_config": {"TestInductorConfig": 9.4065}, "inductor/test_control_flow": {"CondTests": 0.1255, "WhileLoopTests": 0.006}, "inductor/test_cpu_repro": {"CPUReproTests": 978.9800000000004}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.004}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 16.3225}, "inductor/test_debug_trace": {"TestDebugTrace": 4.9559999999999995}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 54.4195}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 28.536499999999997}, "inductor/test_flex_attention": {"TestFlexAttention": 0.02150000000000001}, "inductor/test_foreach": {"ForeachTests": 25.852500000000028}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 115.3955, "SDPAPatternRewriterCpuTests": 109.61800000000001}, "inductor/test_fx_fusion": {"TestFxFusion": 0.29600000000000004}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.0215}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.3115, "TestGroupBatchFusion": 0.0015, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.06800000000000002, "TestIndexingSimplification": 0.8875}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 79.955}, "inductor/test_minifier": {"MinifierTests": 36.910500000000006}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 71.8015}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 231.247, "TestPatternMatcher": 806.2749999999999}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 25.289}, "inductor/test_torchbind": {"TestTorchbind": 14.588}, "inductor/test_torchinductor": {"CpuTests": 2034.5214999999985, "SweepInputsCpuTest": 173.53449999999998, "TestFull": 15.4805}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2140.1199999999976}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2271.431499999999}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.911}, "inductor/test_triton_kernels": {"KernelTests": 0.04200000000000002, "MutationTests": 0.0055}, "inductor/test_utils": {"TestUtils": 0.373}, "lazy/test_debug_util": {"DebugUtilTest": 0.4275}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.44999999999999996}, "lazy/test_generator": {"LazyGeneratorTest": 0.446}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.882}, "lazy/test_step_closures": {"ClosuresTest": 3.3635}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.281, "TestLazyTensor": 0.11149999999999999}, "nn/test_convolution": {"TestConvolutionNN": 21.540499999999998}, "nn/test_dropout": {"TestDropoutNN": 0.21050000000000002}, "nn/test_embedding": {"TestEmbeddingNN": 0.07450000000000004}, "nn/test_init": {"TestNNInit": 5.783499999999998}, "nn/test_lazy_modules": {"TestLazyModules": 0.5450000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.8220000000000001, "TestLoadStateDictSwap": 0.0685}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.0305, "TestModuleHookNN": 0.09500000000000001, "TestModuleHooks": 0.126, "TestStateDictHooks": 0.042000000000000016}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 7.0755}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5915000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.2755000000000003}, "nn/test_pooling": {"TestAvgPool": 0.3485, "TestPoolingNN": 0.5125}, "nn/test_pruning": {"TestPruningNN": 0.13950000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.16549999999999998}, "profiler/test_memory_profiler": {"TestDataFlow": 1.8459999999999992, "TestIdentifyGradients": 0.3115, "TestMemoryProfiler": 0.3665, "TestMemoryProfilerE2E": 4.7135}, "profiler/test_profiler": {"TestExperimentalUtils": 6.374499999999998, "TestProfiler": 26.349, "TestProfilerCUDA": 0.001, "TestProfilerITT": 0.006}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.4765000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.42500000000000004}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.167999999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.1215, "TestBaseDataScheduler": 0.0395, "TestBaseDataSparsifier": 0.0915, "TestBaseSparsifier": 0.034, "TestBaseStructuredSparsifier": 1.9055, "TestComposability": 2.0985, "TestCubicScheduler": 0.006, "TestFPGMPruner": 0.0305, "TestFakeSparsity": 0.11800000000000001, "TestFxComposability": 1.932, "TestNearlyDiagonalSparsifier": 0.907, "TestNormDataSparsifiers": 1.083, "TestQuantizationUtils": 0.0255, "TestQuantizedSparseKernels": 0.349, "TestQuantizedSparseLayers": 0.4325, "TestSaliencyPruner": 0.034, "TestScheduler": 0.020999999999999998, "TestSparsityUtilFunctions": 0.0495, "TestWeightNormSparsifier": 0.3795}, "test_autocast": {"TestAutocastCPU": 3.1895000000000002, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.0085}, "test_autograd": {"TestAllowMutationOnSaved": 0.04400000000000001, "TestAutograd": 25.968500000000063, "TestAutogradComplex": 0.0075, "TestAutogradForwardMode": 0.11400000000000006, "TestAutogradForwardModeBatchedGrad": 0.025, "TestAutogradFunctional": 13.304999999999996, "TestAutogradInferenceMode": 0.04500000000000002, "TestAutogradLogging": 0.02, "TestMultithreadAutograd": 0.26300000000000007, "TestNestedCheckpoint": 0.5385000000000002, "TestSelectiveActivationCheckpoint": 0.02}, "test_autograd_fallback": {"TestAutogradFallback": 0.5475000000000001}, "test_bundled_inputs": {"TestBundledInputs": 2.404999999999999}, "test_comparison_utils": {"TestComparisonUtils": 0.37}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_cpp_api_parity": {"TestCppApiParity": 5.466499999999981}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03500000000000001, "TestMAIATensor": 0.0115, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03400000000000001, "TestMAIATensor": 0.0175, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 65.11500000000001}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.1395}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 12.671000000000003}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.1895}, "test_custom_backend": {"TestCustomBackend": 0.11399999999999999}, "test_custom_ops": {"MiniOpTest": 0.8560000000000003, "MiniOpTestOther": 0.08050000000000002, "TestCustomOp": 3.7454999999999905, "TestCustomOpAPI": 0.16550000000000004, "TestCustomOperators": 0.43000000000000005, "TestGenerateOpcheckTests": 4.4515}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.07, "TestCustomPinFn": 0.0025, "TestDataLoader": 114.77600000000001, "TestDataLoaderPersistentWorkers": 130.22850000000005, "TestDatasetRandomSplit": 0.039, "TestDictDataLoader": 0.05600000000000001, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.0075, "TestSetAffinity": 0.091, "TestStackDataset": 0.0425, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.028500000000000004}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.0015, "TestFunctionalIterDataPipe": 7.351499999999998, "TestFunctionalMapDataPipe": 0.045, "TestGraph": 0.0205, "TestIterDataPipeCountSampleYielded": 0.0145, "TestIterDataPipeGraphFastForward": 0.05700000000000001, "TestIterDataPipeSingletonConstraint": 0.028500000000000004, "TestIterableDataPipeBasic": 0.037500000000000006, "TestSerialization": 8.489, "TestSharding": 0.25750000000000006, "TestStreamWrapper": 0.3665, "TestTyping": 0.0055}, "test_decomp": {"HasDecompTest": 0.23149999999999998}, "test_deploy": {"TestFreezer": 0.365}, "test_dispatch": {"TestDispatch": 41.992, "TestPythonDispatcher": 0.053000000000000005}, "test_dynamic_shapes": {"TestDimConstraints": 2.6125, "TestFloorDiv": 0.013500000000000002, "TestGuardsExpressions": 0.019999999999999997, "TestPySymInt": 1.6829999999999992, "TestSymNumberMagicMethods": 2.1379999999999937}, "test_fake_tensor": {"FakeTensorConstHandling": 0.11200000000000002, "FakeTensorConverterTest": 0.034499999999999996, "FakeTensorDispatchCache": 0.095, "FakeTensorOperatorInvariants": 0.6265000000000001, "FakeTensorPropTest": 0.0975, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 3.142499999999999, "PropagateRealTensorsFakeTensorConstHandling": 0.1865, "PropagateRealTensorsFakeTensorConverterTest": 0.0325, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.249, "PropagateRealTensorsFakeTensorPropTest": 0.06849999999999999, "PropagateRealTensorsFakeTensorTest": 0.35350000000000004}, "test_flop_counter": {"TestFlopCounter": 0.775}, "test_function_schema": {"TestFunctionSchema": 0.8025}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 45.672000000000004}, "test_functional_optim": {"TestFunctionalOptimParity": 0.5205}, "test_functionalization": {"TestCrossRefFunctionalization": 3.682999999999998, "TestFunctionalization": 3.9259999999999984}, "test_futures": {"TestFuture": 1.3355000000000001}, "test_fx": {"AnnotationsTest": 0.019000000000000006, "TestCSEPass": 0.3610000000000001, "TestCommonPass": 0.0895, "TestConstFold": 0.21900000000000008, "TestConstParamShapeInControlFlow": 0.0615, "TestDCE": 0.043500000000000004, "TestFX": 4.945999999999993, "TestFXAPIBackwardCompatibility": 0.039999999999999994, "TestFunctionalTracing": 0.46350000000000036, "TestMatcher": 0.5375000000000001, "TestPassManager": 0.032, "TestSourceMatcher": 1.558, "TestSubgraphRewriter": 0.40100000000000013, "TestVisionTracing": 412.3444999999999, "TypeCheckerTest": 3.2854999999999985}, "test_fx_experimental": {"TestFXExperimental": 25.28150000000001, "TestTranslationValidation": 0.1575}, "test_fx_passes": {"TestFXGraphPasses": 0.9050000000000002, "TestFXMatcherUtils": 0.11250000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.6250000000000002}, "test_import_stats": {"TestImportTime": 5.281}, "test_itt": {"TestItt": 0.3565}, "test_jit": {"TestAliasAnalysis": 0.459, "TestAsync": 0.4285000000000001, "TestAtenPow": 0.01, "TestAutodiffJit": 0.089, "TestAutodiffSubgraphSlicing": 0.3825000000000002, "TestAwait": 0.2695000000000001, "TestBackends": 0.8140000000000001, "TestBackendsWithCompiler": 0.1785, "TestBatchMM": 0.13, "TestBuiltins": 0.079, "TestClassType": 3.563999999999999, "TestComplex": 1.1380000000000003, "TestCustomOperators": 0.05200000000000002, "TestDCE": 0.025, "TestDataParallel": 0.002, "TestDataclasses": 5.461499999999999, "TestDeviceAnalysis": 5.450999999999999, "TestDict": 0.5135000000000002, "TestDtypeAnalysis": 0.20700000000000002, "TestEnum": 0.318, "TestFreezing": 3.0905, "TestFrontend": 0.5575, "TestFrozenOptimizations": 15.255999999999997, "TestFunctionalBlocks": 0.0095, "TestFunctionalToInplaceActivation": 3.0940000000000003, "TestGenerator": 0.0865, "TestGetDefaultAttr": 0.019000000000000003, "TestGraphRewritePasses": 0.0505, "TestHash": 0.106, "TestHooks": 0.8120000000000003, "TestIgnorableArgs": 0.016, "TestIgnoreContextManager": 0.052500000000000005, "TestInplaceToFunctionalActivation": 3.2355, "TestIsinstance": 0.3035000000000001, "TestJit": 6.951999999999991, "TestJitGeneratedModule": 13.677999999999983, "TestJitProfiler": 0.0015, "TestJitUtils": 0.022000000000000006, "TestList": 1.5160000000000007, "TestLogging": 0.06, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.2245000000000001, "TestMixTracingScripting": 1.5719999999999998, "TestModels": 2.3199999999999985, "TestModuleAPIs": 0.14850000000000002, "TestModuleContainers": 1.7550000000000001, "TestModuleInterface": 0.7520000000000001, "TestModules": 0.0175, "TestNamedTuple": 0.07850000000000001, "TestNnapiBackend": 11.154999999999998, "TestOpDecompositions": 0.019000000000000003, "TestOptimizeForMobilePreserveDebugInfo": 0.25350000000000006, "TestPDT": 0.4140000000000001, "TestParametrization": 0.12050000000000001, "TestPeephole": 0.6290000000000003, "TestProducerVersion": 0.0015, "TestProfiler": 0.823, "TestPythonBindings": 0.047, "TestPythonBuiltinOP": 0.4655, "TestPythonIr": 0.035, "TestRecursiveScript": 0.8145000000000002, "TestRemoveMutation": 0.17650000000000002, "TestSaveLoad": 0.7740000000000001, "TestSaveLoadFlatbuffer": 0.7000000000000002, "TestSaveLoadForOpVersion": 3.1235, "TestScript": 47.25450000000004, "TestScriptDict": 0.03300000000000001, "TestScriptList": 0.8790000000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2720000000000001, "TestScriptProfile": 0.4185, "TestSlice": 0.21500000000000005, "TestSparse": 0.07300000000000001, "TestStringFormatting": 0.15800000000000003, "TestSymbolicShapeAnalysis": 1.9804999999999988, "TestTensorBuiltins": 0.0955, "TestTensorCreationOps": 0.056499999999999995, "TestTensorMethods": 0.0155, "TestTorchbind": 0.18000000000000005, "TestTracer": 3.3344999999999967, "TestTypeSharing": 0.5805000000000001, "TestTypesAndAnnotation": 0.15250000000000002, "TestTyping": 0.4360000000000002, "TestUnion": 0.6460000000000004, "TestUnsupportedOps": 0.0325, "TestUpgraders": 0.12150000000000002, "TestWarn": 0.0665, "TestWith": 0.7465}, "test_jit_autocast": {"TestAutocast": 0.135, "TestJitTraceAutocast": 22.745000000000005}, "test_jit_disabled": {"TestJitDisabled": 0.5015000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.221, "TestTEFuserDynamic": 132.64800000000005, "TestTEFuserStatic": 54.042500000000025}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.10550000000000001, "TestModel": 4.3705}, "test_legacy_vmap": {"TestVmapAPILegacy": 1.2435, "TestVmapOperatorsLegacy": 1.1660000000000001}, "test_license": {"TestLicense": 0.369}, "test_logging": {"LoggingTest": 3.6855}, "test_maskedtensor": {"TestBinary": 0.4320000000000003, "TestReductions": 0.10450000000000004, "TestUnary": 0.3840000000000003}, "test_meta": {"TestMetaConverter": 0.08800000000000005}, "test_mkl_verbose": {"TestMKLVerbose": 5.765000000000001}, "test_mkldnn_fusion": {"TestMkldnnFusion": 92.921}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.429}, "test_mobile_optimizer": {"TestOptimizer": 4.0905000000000005}, "test_model_dump": {"TestModelDump": 1.304}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.3055}, "test_module_tracker": {"TestModuleTracker": 0.381}, "test_monitor": {"TestMonitor": 0.375, "TestMonitorTensorboard": 0.1945}, "test_multiprocessing": {"TestMultiprocessing": 70.17399999999999}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.9935, "SpawnTest": 40.6225}, "test_namedtensor": {"TestNamedTensor": 0.4860000000000002}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.3855000000000004}, "test_native_functions": {"TestNativeFunctions": 0.5150000000000001}, "test_nestedtensor": {"TestNestedTensor": 0.1835000000000001}, "test_nn": {"TestAddRelu": 0.007, "TestConstantPadNd": 0.0055, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.44899999999999995, "TestFusionUtils": 0.006, "TestNN": 64.49850000000009, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.007}, "test_openmp": {"TestOpenMP_ParallelFor": 6.0535}, "test_ops": {"TestSelfKwarg": 0.0045000000000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.26250000000000007, "TestLRScheduler": 1.3505000000000007, "TestSWAUtils": 0.2425}, "test_out_dtype_op": {"TestOutDtypeOp": 0.41950000000000004}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.0325, "TestGradCheckOverride": 0.0265, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.0075, "TestIterator": 0.0015, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.003, "TestResolveName": 0.129, "TestTorchFunctionMode": 0.04600000000000002, "TestTorchFunctionOverride": 2.5414999999998895, "TestTorchFunctionWarning": 0.0195, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.07300000000000001, "ModelTest": 0.0, "TestAnalyze": 0.353, "TestDependencyAPI": 0.06900000000000002, "TestDependencyHooks": 0.015, "TestDiGraph": 0.018000000000000006, "TestGlobGroup": 0.028000000000000014, "TestImporter": 0.015000000000000003, "TestLoadBCPackages": 0.091, "TestMangling": 0.022000000000000006, "TestMisc": 0.05950000000000001, "TestPackageFX": 0.087, "TestPackageScript": 2.8349999999999995, "TestRepackage": 0.0115, "TestResources": 0.0155, "TestSaveLoad": 0.0465}, "test_per_overload_api": {"TestPerOverloadAPI": 0.3645}, "test_prims": {"TestPrimsBasic": 0.03}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.187, "TestGenericProxyTensorFake": 3.1494999999999997, "TestGenericProxyTensorReal": 3.338999999999999, "TestGenericProxyTensorSymbolic": 22.4495, "TestRealProxyTensor": 0.031, "TestSymbolicTracing": 4.911999999999998}, "test_pruning_op": {"PruningOpTest": 0.6060000000000001}, "test_public_bindings": {"TestPublicBindings": 7.9864999999999995}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.33200000000000013, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.2795}, "test_pytree": {"TestCxxPytree": 0.024000000000000007, "TestGenericPytree": 0.5050000000000001, "TestPythonPytree": 0.08200000000000005}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.016500000000000004, "TestAOMigrationNNQuantized": 0.07350000000000001, "TestAOMigrationQuantization": 0.027000000000000003, "TestAOMigrationQuantizationFx": 0.026500000000000003, "TestBackendConfig": 0.06600000000000002, "TestBiasCorrectionEager": 1.9324999999999999, "TestComparatorOps": 1.5194999999999999, "TestDeprecatedJitQuantized": 5.7524999999999995, "TestDistributed": 0.0325, "TestDuplicateDQPass": 3.9705, "TestDynamicQuantizedModule": 53.257999999999996, "TestDynamicQuantizedOps": 28.673499999999997, "TestEqualizeEager": 0.11300000000000002, "TestEqualizeFx": 7.42, "TestFXGraphMatcher": 2.1029999999999998, "TestFXGraphMatcherModels": 13.014, "TestFXNumericSuiteCoreAPIs": 34.801, "TestFXNumericSuiteCoreAPIsModels": 51.55300000000001, "TestFXNumericSuiteNShadows": 47.848499999999994, "TestFakeQuantize": 0.363, "TestFakeQuantizeOps": 2.3889999999999985, "TestFuseEager": 3.2669999999999995, "TestFuseFx": 2.958999999999999, "TestFusedObsFakeQuant": 0.09849999999999999, "TestFusedObsFakeQuantModule": 0.2765, "TestFusionPasses": 0.0275, "TestFxDetectInputWeightEqualization": 0.508, "TestFxDetectOutliers": 0.347, "TestFxModelReportClass": 0.616, "TestFxModelReportDetectDynamicStatic": 0.0765, "TestFxModelReportDetector": 0.2365, "TestFxModelReportObserver": 0.25, "TestFxModelReportVisualizer": 0.2515, "TestGenerateNumericDebugHandle": 0.9335, "TestGraphUtils": 2.841, "TestHistogramObserver": 45.141, "TestMetaDataPorting": 8.463, "TestModelNumericsEager": 1.3010000000000002, "TestNumericSuiteEager": 10.622499999999999, "TestObserver": 4.669499999999999, "TestPT2ERepresentation": 35.513000000000005, "TestPadding": 27.6185, "TestQNNPackOps": 5.872000000000001, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.3770000000000002, "TestQuantizeDynamicJitPasses": 5.939, "TestQuantizeEagerOps": 1.9589999999999996, "TestQuantizeEagerPTQDynamic": 9.0945, "TestQuantizeEagerPTQStatic": 31.310999999999996, "TestQuantizeEagerQAT": 12.052999999999999, "TestQuantizeEagerQATNumerics": 2.4044999999999996, "TestQuantizeFx": 52.537000000000006, "TestQuantizeFxModels": 7.212999999999999, "TestQuantizeFxOps": 138.88950000000003, "TestQuantizeJit": 25.3385, "TestQuantizeJitOps": 293.43350000000004, "TestQuantizeJitPasses": 6.533000000000001, "TestQuantizePT2E": 63.387000000000015, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 402.0435, "TestQuantizePT2EQAT_ConvBn2d": 407.18499999999995, "TestQuantizePT2EX86Inductor": 103.718, "TestQuantizedConv": 62.0745, "TestQuantizedEmbeddingOps": 1.7165, "TestQuantizedFunctionalOps": 3.1189999999999998, "TestQuantizedLinear": 26.149500000000003, "TestQuantizedOps": 129.11100000000002, "TestQuantizedTensor": 2.3415, "TestRecordHistogramObserver": 0.04000000000000001, "TestReferenceQuantizedModule": 0.0625, "TestSerialization": 2.28, "TestStaticQuantizedModule": 87.212, "TestSubgraphRewriter": 1.1630000000000003, "TestUtils": 0.026000000000000002, "TestXNNPACKQuantizer": 51.5525, "TestXNNPACKQuantizerModels": 4.6419999999999995}, "test_schema_check": {"TestSchemaCheck": 0.15350000000000008}, "test_serialization": {"TestOldSerialization": 58.80400000000003, "TestSerialization": 13.878000000000018, "TestSubclassSerialization": 0.0425}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.366}, "test_show_pickle": {"TestShowPickle": 0.45999999999999996}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.039, "TestSparseMeta": 4.995, "TestSparseOneOff": 0.0025}, "test_sparse_csr": {"TestSparseCSRSampler": 0.647}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_stateless": {"TestPythonOptimizeMode": 5.5649999999999995, "TestStatelessDeprecation": 2.5425, "TestStatelessFunctionalAPI": 0.2935000000000001}, "test_subclass": {"TestSubclass": 0.5990000000000002}, "test_sympy_utils": {"TestNumbers": 0.036000000000000004, "TestSingletonInt": 0.0075, "TestSympyInterp": 11.854499999999998, "TestSympySolve": 0.42500000000000004, "TestValueRanges": 7.890499999999997}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.025500000000000002, "TestTensorBoardFigure": 0.0025, "TestTensorBoardNumpy": 0.0055, "TestTensorBoardPyTorchNumpy": 0.234, "TestTensorBoardPytorchGraph": 46.7735, "TestTensorBoardSummary": 0.07800000000000001, "TestTensorBoardSummaryWriter": 0.0105, "TestTensorBoardUtils": 0.2335, "TestTensorBoardWriter": 0.13, "TestTensorProtoSummary": 0.014000000000000002}, "test_tensorexpr": {"TestTensorExprFuser": 69.7875}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.013, "TestTensorExprPyBind": 1.1985000000000003}, "test_testing": {"TestAssertClose": 0.1695000000000001, "TestAssertCloseContainer": 0.009000000000000001, "TestAssertCloseErrorMessage": 0.07100000000000002, "TestAssertCloseQuantized": 0.033999999999999996, "TestAssertCloseSparseBSC": 0.021, "TestAssertCloseSparseBSR": 0.021, "TestAssertCloseSparseCOO": 0.029, "TestAssertCloseSparseCSC": 0.021, "TestAssertCloseSparseCSR": 0.022, "TestFrameworkUtils": 17.525, "TestImports": 17.176000000000002, "TestOpInfos": 0.007, "TestTestParametrization": 0.040500000000000015}, "test_torch": {"TestBasicVitalSigns": 0.05500000000000001, "TestTorch": 9.218499999999986}, "test_type_hints": {"TestTypeHints": 0.355}, "test_type_info": {"TestDTypeInfo": 0.3745}, "test_typing": {"TestTyping": 106.66200000000003}, "test_utils": {"TestAssert": 0.083, "TestBottleneck": 13.363, "TestCheckpoint": 0.13700000000000004, "TestCollectEnv": 1.3165, "TestCppExtensionUtils": 0.044, "TestDataLoaderUtils": 0.3405, "TestExtensionUtils": 0.006, "TestHipify": 0.0015, "TestHipifyTrie": 0.0105, "TestONNXUtils": 0.006, "TestRenderUtils": 0.0195, "TestStandaloneCPPJIT": 3.552, "TestTraceback": 0.014}, "test_vulkan": {"TestVulkanRewritePass": 0.004}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.025500000000000002, "WeakKeyDictionaryTestCase": 0.024, "WeakTest": 6.021}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 5.0009999999999994, "TestXNNPACKRewritePass": 1.7345, "TestXNNPACKSerDes": 5.403}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0025}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.3785, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0015, "TestMisc": 0.0045000000000000005, "TestPickling": 0.14100000000000001, "TestPromotion": 0.0015}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 19.236500000000007, "TestEinsumPath": 0.0015, "TestMisc": 0.007}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0025, "TestHalf": 0.001, "TestIinfo": 0.389, "TestMisc": 0.0035, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.0085, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.009000000000000001, "TestIndexing": 0.5325000000000002, "TestMultiIndexingAutomated": 0.009000000000000001, "TestMultipleEllipsisError": 0.0045000000000000005, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.0335, "TestArgmax": 1.324500000000001, "TestArgmaxArgminCommon": 0.07800000000000004, "TestArgmin": 1.4195000000000009, "TestArrayAttributeDeletion": 0.0095, "TestArrayConstruction": 0.05050000000000002, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.014500000000000002, "TestAttributes": 0.029500000000000005, "TestBinop": 0.021, "TestBool": 29.04, "TestCequenceMethods": 0.003, "TestChoose": 0.024, "TestClip": 0.0075, "TestCompress": 0.005, "TestConversion": 0.0415, "TestCreation": 0.0015, "TestDelMisc": 0.0015, "TestDot": 0.08850000000000004, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.020500000000000004, "TestFormat": 0.007, "TestFromBuffer": 0.017000000000000005, "TestHash": 0.22199999999999998, "TestHashing": 0.0045000000000000005, "TestIO": 0.0015, "TestInner": 0.2585, "TestLexsort": 0.022500000000000003, "TestMatmul": 0.5130000000000001, "TestMatmulOperator": 0.35750000000000004, "TestMethods": 1.7110000000000007, "TestMinMax": 0.0075, "TestMinScalarType": 0.0075, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.015, "TestRepeat": 0.016, "TestResize": 0.05650000000000001, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.027500000000000004, "TestSortFloatMisc": 0.20550000000000002, "TestStats": 0.3125, "TestSubscripting": 0.0025, "TestTake": 0.047500000000000014, "TestVdot": 0.0465, "TestWarnings": 0.003, "TestWhere": 0.4045, "TestWritebackIfCopy": 0.036}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.025, "TestArgwhere": 0.033, "TestArrayComparisons": 0.016, "TestBaseRepr": 0.0075, "TestBinaryRepr": 0.01, "TestBoolArray": 2.6115, "TestBoolCmp": 0.2025, "TestBoolScalar": 0.0115, "TestBroadcast": 0.0075, "TestClip": 0.23400000000000012, "TestConvolve": 0.0215, "TestCorrelate": 0.06249999999999999, "TestCreationFuncs": 1.2615, "TestCross": 0.09350000000000001, "TestDtypePositional": 0.0025, "TestFloatExceptions": 0.0105, "TestFromiter": 0.0, "TestIndex": 0.009000000000000001, "TestIndices": 0.0495, "TestIsclose": 0.1015, "TestIsscalar": 0.003, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.017499999999999998, "TestNonarrayArgs": 0.14700000000000008, "TestNonzeroAndCountNonzero": 0.30350000000000005, "TestOuterMisc": 0.007, "TestRequire": 0.007, "TestResize": 0.388, "TestRoll": 0.039, "TestRollaxis": 0.006, "TestSeterr": 0.009000000000000001, "TestStdVar": 0.035500000000000004, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0025, "TestTensordot": 0.018000000000000002, "TestTypes": 0.0175}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.3695, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.20100000000000015, "TestFromInt": 0.01, "TestFromString": 0.424}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0025, "TestBitCount": 0.0, "TestClassGetItem": 0.001, "TestClassGetitemMisc": 0.0015, "TestIsInteger": 0.001}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.128, "TestBaseMath": 11.177, "TestBitShifts": 0.11699999999999999, "TestComplexDivision": 0.07850000000000001, "TestConversion": 0.0995, "TestHash": 0.0015, "TestModulus": 1.217, "TestMultiply": 0.0005, "TestNegative": 0.024, "TestPower": 0.169, "TestRepr": 0.0025, "TestScalarOpsMisc": 0.06950000000000003, "TestScalarSubclassingMisc": 0.015000000000000003, "TestSubtract": 0.0235, "TestTypes": 17.984499999999997}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.389, "TestAtleast2d": 0.0205, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.031500000000000014, "TestConcatenate": 0.20350000000000013, "TestHstack": 0.021500000000000005, "TestStackMisc": 0.0055, "TestVstack": 0.024}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.013499999999999998, "TestFFTShift": 7.4110000000000005, "TestIRFFTN": 0.0045000000000000005, "TestRFFTFreq": 0.013}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.6285, "TestFFTShift": 0.3715, "TestFFTThreadSafe": 0.958}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.40750000000000003}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.013000000000000006, "TestUnique": 0.6425000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0085, "TestAmin": 0.0075, "TestAngle": 0.013, "TestAny": 0.009000000000000001, "TestAverage": 0.035, "TestBincount": 0.072, "TestCheckFinite": 0.003, "TestCopy": 0.0105, "TestCorrCoef": 0.077, "TestCov": 0.08300000000000002, "TestCumprod": 0.037500000000000006, "TestCumsum": 0.051000000000000004, "TestDelete": 0.0235, "TestDiff": 0.095, "TestDigitize": 0.022000000000000006, "TestExtins": 0.008, "TestFilterwindows": 0.7425000000000005, "TestFlip": 0.04100000000000001, "TestGradient": 0.17600000000000002, "TestInsert": 0.0115, "TestInterp": 0.08900000000000005, "TestKaiser": 0.014, "TestMedian": 0.13250000000000003, "TestMeshgrid": 0.07200000000000002, "TestMsort": 0.0, "TestPercentile": 0.08350000000000005, "TestPiecewise": 0.017, "TestProd": 0.038, "TestPtp": 0.012, "TestQuantile": 0.022500000000000006, "TestRot90": 0.457, "TestSelect": 0.0125, "TestSinc": 0.0105, "TestSortComplex": 0.014, "TestTrapz": 0.008, "TestTrimZeros": 0.014500000000000002, "TestUnique": 0.006, "Test_I0": 0.024}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.5155000000000001, "TestHistogramOptimBinNums": 0.03800000000000001, "TestHistogramdd": 0.1575}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0015, "TestConcatenator": 0.01, "TestDiagIndices": 0.006, "TestDiagIndicesFrom": 0.009000000000000001, "TestFillDiagonal": 0.0335, "TestGrid": 0.012, "TestIndexExpression": 0.013500000000000002, "TestIx_": 0.009000000000000001, "TestNdIndex": 0.0015, "TestNdenumerate": 0.0015, "TestRavelUnravelIndex": 0.3865}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.020500000000000004, "TestApplyOverAxes": 0.0025, "TestArraySplit": 0.20950000000000002, "TestColumnStack": 0.013000000000000001, "TestDsplit": 0.012, "TestDstack": 0.023, "TestExpandDims": 0.011, "TestHsplit": 0.016, "TestKron": 0.018500000000000003, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.014, "TestSplit": 0.0095, "TestSqueeze": 0.03950000000000001, "TestTakeAlongAxis": 0.426, "TestTile": 0.10400000000000001, "TestVsplit": 0.0115}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.41550000000000004, "TestFliplr": 0.007, "TestFlipud": 0.006, "TestHistogram2d": 0.0435, "TestTri": 0.11950000000000001, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.005, "TestTriuIndicesFrom": 0.003, "TestVander": 0.026000000000000002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0025, "TestCommonType": 0.3665, "TestImag": 0.015, "TestIscomplex": 0.0085, "TestIscomplexobj": 0.006500000000000001, "TestIsfinite": 0.021, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.021, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.013000000000000001, "TestIsrealobj": 0.0025, "TestIsscalar": 0.003, "TestMintypecode": 0.0085, "TestNanToNum": 0.021500000000000005, "TestReal": 0.0165, "TestRealIfClose": 0.007}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.2745, "TestCond": 0.269, "TestDet": 0.1905, "TestEig": 0.049, "TestEigh": 0.03650000000000001, "TestEighCases": 0.0, "TestEigvals": 0.11350000000000002, "TestEigvalsh": 0.03350000000000001, "TestEigvalshCases": 0.0, "TestInv": 0.065, "TestLstsq": 0.259, "TestMatrixRank": 0.4655, "TestMisc": 0.0295, "TestMisc2": 0.0045000000000000005, "TestMultiDot": 0.0665, "TestNormDouble": 0.9745, "TestNormInt64": 0.9685, "TestNormSingle": 0.9995, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.138, "TestPinvHermitian": 0.057999999999999996, "TestQR": 0.513, "TestSVD": 0.06250000000000001, "TestSVDHermitian": 0.12150000000000002, "TestSolve": 0.4355, "TestTensorinv": 0.025499999999999995, "TestTensorsolve": 0.0045000000000000005}, "torch_np/test_basic": {"TestArrayToSequence": 0.009000000000000001, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.0045000000000000005, "TestDefaultDtype": 0.0095, "TestDivmod": 0.019500000000000003, "TestExport": 0.0, "TestMisc": 0.0015, "TestNormalizations": 0.007, "TestOneArr": 0.3810000000000002, "TestOneArrAndAxesTuple": 0.013500000000000002, "TestOneArrAndAxis": 0.22850000000000015, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.014500000000000002, "TestPythonArgsToArray": 0.0165, "TestSequenceOfArrays": 0.02400000000000001, "TestSequenceOfArraysToSingle": 0.012, "TestShapeLikeToArray": 0.006, "TestSmokeNotImpl": 0.0015}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5285000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.47600000000000003}, "torch_np/test_function_base": {"TestAppend": 0.3705}, "torch_np/test_ndarray_methods": {"TestAmax": 0.01, "TestAmin": 0.009000000000000001, "TestArgmax": 1.257500000000001, "TestArgmaxArgminCommon": 0.07700000000000004, "TestArgmin": 1.540000000000001, "TestContains": 0.003, "TestIndexing": 0.3625, "TestIter": 0.006, "TestNoExtraMethods": 0.01, "TestNonzero": 0.17400000000000002, "TestRavel": 0.009000000000000001, "TestReshape": 0.006, "TestTranspose": 0.012}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.0175, "TestNEP50Table": 0.0025}, "torch_np/test_random": {"TestChoice": 0.016, "TestNumpyGlobal": 0.0055, "TestScalarReturn": 0.41300000000000003, "TestShuffle": 0.016500000000000004}, "torch_np/test_reductions": {"TestAll": 0.016, "TestAny": 0.0165, "TestFlatnonzero": 0.3775, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.6399999999999375, "TestMean": 0.027000000000000003, "TestSum": 0.264}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.3955, "TestIsScalar": 0.03600000000000002}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.7740000000000005, "TestNdarrayDunderVsUfunc": 0.2435000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.41950000000000004}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5845000000000002}}}, "linux-focal-cuda12.4-py3.10-gcc9-sm86": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 1.7133333333333336}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.8816666666666666}, "distributions/test_distributions": {"TestAgainstScipy": 1.0266666666666666, "TestConstraints": 0.135, "TestDistributionShapes": 0.1113333333333334, "TestDistributions": 42.60433333333334, "TestFunctors": 0.007666666666666666, "TestJit": 19.471, "TestKL": 2.6086666666666667, "TestLazyLogitsInitialization": 0.011333333333333334, "TestNumericalStability": 0.06466666666666669, "TestRsample": 0.6176666666666667, "TestValidation": 0.33266666666666667}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 13.244333333333335}, "dynamo/test_after_aot": {"TestAfterAot": 4.709666666666667}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 8.834333333333332}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.20933333333333334, "AOTAutogradCacheTests": 14.290000000000001}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.238333333333332}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.030666666666666665, "TestCustomBackendAPI": 1.649, "TestExplainWithBackend": 8.408666666666667, "TestOptimizations": 1.6889999999999998}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.447666666666667}, "dynamo/test_base_output": {"TestBaseOutput": 0.0013333333333333333}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 4.626}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.285333333333333, "BytecodeTests": 0.3333333333333333}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.3260000000000005, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.48766666666666675}, "dynamo/test_config": {"ConfigTests": 0.46666666666666673}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.936999999999999}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.1779999999999995}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.3583333333333334}, "dynamo/test_decorators": {"DecoratorTests": 4.976}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.013999999999999999}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 28.535666666666668, "DynamicShapesCtxManagerTests": 7.489999999999999, "DynamicShapesExportTests": 25.192666666666668, "DynamicShapesFuncTorchHigherOrderOpTests": 94.44099999999999, "DynamicShapesFunctionTests": 64.45199999999993, "DynamicShapesHigherOrderOpTests": 14.85666666666667, "DynamicShapesMiscTests": 85.90066666666674, "DynamicShapesNNModuleTests": 5.841999999999999, "DynamicShapesReproTests": 91.22500000000002, "DynamicShapesSubGraphTests": 9.706333333333335, "DynamicShapesTestSDPA": 0.318}, "dynamo/test_exc": {"ExcTests": 1.6979999999999997}, "dynamo/test_exceptions": {"ExceptionTests": 0.4323333333333334}, "dynamo/test_export": {"ExportTests": 13.943666666666664}, "dynamo/test_export_mutations": {"MutationExportTests": 0.46000000000000013}, "dynamo/test_frame_init": {"FrameInitTests": 0.20433333333333334}, "dynamo/test_functions": {"DefaultsTests": 0.6480000000000001, "FunctionTests": 20.13766666666668}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.2443333333333333}, "dynamo/test_global": {"TestGlobals": 0.4370000000000001}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.26366666666666666}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 5.714000000000001, "FuncTorchHigherOrderOpTests": 9.498333333333333, "HigherOrderOpTests": 6.633, "HigherOrderOpVmapGuardTests": 3.4486666666666665}, "dynamo/test_hooks": {"HooksTests": 23.327333333333343}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 9.149666666666667, "InlineInbuiltNNModulesExportTests": 13.552666666666665, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 9.653, "InlineInbuiltNNModulesFunctionTests": 28.800666666666682, "InlineInbuiltNNModulesHigherOrderOpTests": 6.601999999999999, "InlineInbuiltNNModulesMiscTests": 50.900666666666716, "InlineInbuiltNNModulesNNModuleTests": 3.828666666666665}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.458666666666667}, "dynamo/test_interop": {"InteropTests": 0.474}, "dynamo/test_logging": {"LoggingTests": 16.680999999999997}, "dynamo/test_minifier": {"MinifierTests": 2.0976666666666666}, "dynamo/test_misc": {"MiscTests": 49.73500000000005, "TestTracer": 0.057666666666666665}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.002}, "dynamo/test_modules": {"NNModuleTests": 2.416666666666665, "OptimizedModuleTest": 14.813666666666668}, "dynamo/test_nops": {"NopTests": 0.27566666666666667}, "dynamo/test_optimizers": {"End2EndTests": 0.5256666666666666}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.39399999999999996}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.0953333333333335}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.5333333333333333}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.7270000000000002}, "dynamo/test_recompiles": {"RecompileTests": 0.722}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.4236666666666667}, "dynamo/test_repros": {"ReproTests": 42.77966666666666}, "dynamo/test_resume": {"ResumeFunctionTests": 0.336}, "dynamo/test_sdpa": {"TestSDPA": 0.387}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.4456666666666667}, "dynamo/test_sources": {"SourceTests": 0.39199999999999996}, "dynamo/test_structured_trace": {"StructuredTraceTest": 13.931333333333333}, "dynamo/test_subclasses": {"SubclassTests": 3.9923333333333333, "TestNestedTensor": 12.634333333333332}, "dynamo/test_subgraphs": {"SubGraphTests": 1.966666666666666}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.09100000000000001, "TraceRuleTests": 1.0593333333333332}, "dynamo/test_unspec": {"UnspecTests": 10.443666666666667}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.484}, "dynamo/test_view": {"ViewTests": 0.5283333333333333}, "export/test_converter": {"TestConverter": 6.241333333333333}, "export/test_db": {"ExampleTests": 2.6793333333333336}, "export/test_experimental": {"TestExperiment": 0.797}, "export/test_export": {"TestDynamismExpression": 0.428, "TestExport": 22.595, "TestExportCustomClass": 0.062, "TestOneOffModelExportResult": 1.0416666666666667}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.38400000000000006, "NonStrictExportTestExport": 21.157666666666668}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.20866666666666667}, "export/test_hop": {"TestHOPCUDA": 2.432, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.084}, "export/test_pass_infra": {"TestPassInfra": 0.7236666666666669}, "export/test_passes": {"TestPasses": 10.96566666666667}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.7746666666666666, "RetraceExportTestExport": 34.75299999999999}, "export/test_schema": {"TestSchema": 0.24}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.49433333333333335, "SerDesExportTestExport": 25.031333333333336}, "export/test_serialize": {"TestDeserialize": 7.126, "TestSaveLoad": 0.269, "TestSchemaVersioning": 0.02766666666666667, "TestSerialize": 0.9550000000000001, "TestSerializeCustomClass": 0.08033333333333333}, "export/test_sparse": {"TestSparseProp": 52.99733333333322}, "export/test_tools": {"TestExportTools": 0.4426666666666666}, "export/test_torchbind": {"TestCompileTorchbind": 1.0646666666666669, "TestExportTorchbind": 1.7039999999999995, "TestRegisterFakeClass": 0.0033333333333333335}, "export/test_tree_utils": {"TestTreeUtils": 0.20933333333333334}, "export/test_unflatten": {"TestUnflatten": 2.7453333333333334}, "export/test_verifier": {"TestVerifier": 0.7526666666666665}, "functorch/test_ac": {"MemoryBudgetTest": 12.021666666666668}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.201999999999998, "TestAOTAutogradWithDynamo": 12.649333333333326, "TestAOTDispatch": 0.4373333333333334, "TestAOTExport": 2.0376666666666665, "TestAOTModuleSimplified": 0.547, "TestPartitioning": 2.9146666666666667}, "functorch/test_control_flow": {"TestControlFlow": 0.7126666666666668, "TestControlFlowTraced": 94.12866666666669}, "functorch/test_dims": {"TestMin": 13.578000000000001, "TestMinFunctorchOnly": 13.025333333333334}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.08500000000000003, "TestAutogradFunctionVmapAPICUDA": 0.016666666666666666, "TestCompileTransformsCUDA": 4.167333333333334, "TestComposabilityCUDA": 0.1446666666666667, "TestExamplesCorrectnessCUDA": 2.2653333333333325, "TestFunctionalizeCUDA": 0.09733333333333337, "TestGradTransformCUDA": 0.981, "TestHelpersCUDA": 0.010666666666666666, "TestHessianCUDA": 0.062, "TestHigherOrderOperatorInteractionCUDA": 0.02266666666666667, "TestJacCUDA": 0.6520000000000002, "TestJvpCUDA": 0.05100000000000002, "TestLinearizeCUDA": 0.21533333333333335, "TestMakeFunctional": 0.06333333333333335, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.016, "TestVmapOfGradCUDA": 0.6816666666666666}, "functorch/test_logging": {"TestAOTLogging": 0.24133333333333332}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.17500000000000002, "RandomOpTestCase": 0.07066666666666667, "ReduceTestCase": 0.065, "TestMemoryEfficientOpAuthoring": 4.977}, "functorch/test_minifier": {"TestMinifier": 0.3840000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 3948.7606666666366}, "functorch/test_parsing": {"TestAnonymousAxis": 0.19933333333333336, "TestParsedExpression": 0.0036666666666666666, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.24100000000000002}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.8516666666666673, "TestTransformFailureCUDA": 0.24833333333333332, "TestVmapAPI": 0.42233333333333345, "TestVmapBatchedGradientCUDA": 0.20300000000000007, "TestVmapDeviceTypeCUDA": 0.01966666666666667, "TestVmapNestedTensorCUDA": 0.038000000000000006, "TestVmapOperators": 2.5043333333333297, "TestVmapOperatorsOpInfoCUDA": 261.0789999999995}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 1.9829999999998966}, "higher_order_ops/test_with_effects": {"TestWithEffects": 6.350666666666666}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 676.6093333333332, "AOTInductorTestABICompatibleCpuWithStackAllocation": 467.383, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 204.87766666666667, "AOTInductorTestABICompatibleCuda": 1287.9796666666666, "AOTInductorTestNonABICompatibleCpu": 1406.7059999999994, "AOTInductorTestNonABICompatibleCuda": 2138.1156666666666}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.685, "BenchmarkFusionCudaTest": 75.89800000000001, "BenchmarkMultiTemplateFusionCudaTest": 13.405999999999999}, "inductor/test_binary_folding": {"FreezingCpuTests": 34.349, "FreezingCudaTests": 2.2406666666666664, "FreezingGpuTests": 2.2743333333333333}, "inductor/test_codecache": {"TestFxGraphCache": 120.582, "TestFxGraphCacheHashing": 0.755, "TestUtils": 3.3230000000000004, "test_codecache": 2.5460000000000003}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.19533333333333336}, "inductor/test_compile_worker": {"TestCompileWorker": 8.811333333333332}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 287.11866666666714, "TestCompiledAutograd": 142.34266666666667, "TestCustomOpWithCompiledAutograd": 1.9026666666666623}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 657.6883333333334, "CompiledOptimizerTests": 1323.8746666666664}, "inductor/test_config": {"TestInductorConfig": 5.2076666666666656}, "inductor/test_control_flow": {"CondTests": 86.68200000000002, "WhileLoopTests": 36.165}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.0853333333333333}, "inductor/test_cpu_repro": {"CPUReproTests": 593.6649999999998}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 1012.5469999999999, "TestCudaWrapper": 973.2433333333335}, "inductor/test_cuda_repro": {"CudaReproTests": 91.77900000000001}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 70.73099999999998}, "inductor/test_custom_lowering": {"TestCustomLowering": 2.725}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.093666666666666}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 82.69433333333335}, "inductor/test_debug_trace": {"TestDebugTrace": 12.617666666666667}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 30.544}, "inductor/test_dependencies": {"TestDependencies": 0.18633333333333332}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.010666666666665}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 59.37200000000001, "EfficientConvBNEvalCudaTests": 38.442}, "inductor/test_extension_backend": {"ExtensionBackendTests": 16.487333333333336}, "inductor/test_flex_attention": {"TestFlexAttention": 625.9829999999998}, "inductor/test_foreach": {"ForeachTests": 284.6766666666669}, "inductor/test_fp8": {"TestFP8Types": 0.013333333333333338}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 73.948, "SDPAPatternRewriterCpuTests": 69.286, "SDPAPatternRewriterCudaDynamicTests": 40.494, "SDPAPatternRewriterCudaTests": 29.34733333333334}, "inductor/test_fx_fusion": {"TestFxFusion": 0.18833333333333332}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.012000000000000002}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.023000000000000003, "TestGroupBatchFusion": 99.68366666666668, "TestPostGradBatchLinearFusion": 1.9396666666666667}, "inductor/test_indexing": {"ExprPrinterTests": 0.04366666666666668, "TestIndexingSimplification": 2.255333333333333}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 47.391333333333336, "FreezingCudaTests": 30.849}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 5.451333333333333}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 152.20933333333335}, "inductor/test_layout_optim": {"TestLayoutOptim": 10.903999999999998}, "inductor/test_loop_ordering": {"LoopOrderingTest": 3.5976666666666666}, "inductor/test_max_autotune": {"TestMaxAutotune": 288.1826666666666, "TestTuningProcess": 10.402333333333333}, "inductor/test_memory_planning": {"TestMemoryPlanning": 27.886666666666667}, "inductor/test_metrics": {"TestMetrics": 3.5876666666666672}, "inductor/test_minifier": {"MinifierTests": 27.242333333333335}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 95.48899999999999}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 86.14933333333333, "TestPatternMatcher": 410.0336666666665}, "inductor/test_mmdecomp": {"TestDecompCUDA": 6.434}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 14.190666666666667}, "inductor/test_multi_kernel": {"MultiKernelTest": 69.41066666666667}, "inductor/test_pad_mm": {"PadMMTest": 122.63966666666666}, "inductor/test_padding": {"PaddingTest": 9.261333333333333, "PerfTestBetweenGoodAndBadShape": 0.0016666666666666668, "PerfTestWithAndWithoutPadding": 3.8363333333333327}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 95.22466666666668}, "inductor/test_perf": {"FusionTests": 13.296666666666667, "InplacingTests": 5.387333333333333, "MinCutPartitioningTests": 10.568666666666667, "NoopTests": 0.8860000000000001, "NumBytesMetricTests": 20.425, "SchedulerFusionTests": 8.631, "TilingTests": 1.9383333333333332}, "inductor/test_profiler": {"DynamoProfilerTests": 6.1129999999999995}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 109.42533333333334}, "inductor/test_smoke": {"SmokeTest": 5.418666666666667}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 2.9, "MemoryBoundedTests": 2.010666666666667, "TestCommAnalysis": 3.580666666666666, "UnsupportedTests": 0.22333333333333336}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 95.69233333333334}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 18.621333333333336}, "inductor/test_torchbind": {"TestTorchbind": 6.133}, "inductor/test_torchinductor": {"CpuTests": 1422.8526666666664, "GPUTests": 869.8816666666665, "NanCheckerTest": 0.864, "RNNTest": 0.026333333333333337, "SweepInputsCpuTest": 111.629, "SweepInputsGPUTest": 24.179333333333336, "TestFull": 9.963333333333333, "TritonCodeGenTests": 78.901}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1493.4593333333332, "DynamicShapesCodegenGPUTests": 946.1533333333332}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1595.7926666666663, "DynamicShapesGPUTests": 1325.2079999999996, "TestInductorDynamicCUDA": 45.23}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 8802.64833333333}, "inductor/test_torchinductor_strided_blocks": {"TritonBlockPointerTest": 17.596}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.8173333333333334}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 20.036}, "inductor/test_triton_kernels": {"KernelTests": 87.11000000000003, "MutationTests": 0.5833333333333335}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 8.636666666666665}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 18.116333333333337}, "inductor/test_utils": {"TestUtils": 0.20833333333333334}, "lazy/test_debug_util": {"DebugUtilTest": 0.25166666666666665}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.257}, "lazy/test_generator": {"LazyGeneratorTest": 0.267}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.39566666666666667}, "lazy/test_step_closures": {"ClosuresTest": 2.219}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.18533333333333335, "TestLazyTensor": 0.05066666666666667}, "nn/test_convolution": {"TestConvolutionNN": 20.682333333333336, "TestConvolutionNNDeviceTypeCUDA": 50.365333333332806}, "nn/test_dropout": {"TestDropoutNN": 0.09200000000000001, "TestDropoutNNDeviceTypeCUDA": 0.5726666666666668}, "nn/test_embedding": {"TestEmbeddingNN": 0.10300000000000002, "TestEmbeddingNNDeviceTypeCUDA": 14.310000000000002}, "nn/test_init": {"TestNNInit": 3.446333333333332}, "nn/test_lazy_modules": {"TestLazyModules": 0.2710000000000001}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.649, "TestLoadStateDictSwap": 0.04566666666666667}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.018333333333333337, "TestModuleHookNN": 0.058, "TestModuleHooks": 0.07333333333333335, "TestStateDictHooks": 0.025666666666666674}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 4.581, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.3606666666666667}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.3803333333333334}, "nn/test_parametrization": {"TestNNParametrization": 0.6813333333333335, "TestNNParametrizationDeviceCUDA": 0.224}, "nn/test_pooling": {"TestAvgPool": 0.249, "TestPoolingNN": 0.6946666666666667, "TestPoolingNNDeviceTypeCUDA": 4.618666666666665}, "nn/test_pruning": {"TestPruningNN": 0.0776666666666667}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.077666666666667}, "profiler/test_memory_profiler": {"TestDataFlow": 1.0823333333333334, "TestIdentifyGradients": 0.23200000000000007, "TestMemoryProfiler": 0.227, "TestMemoryProfilerE2E": 2.4293333333333336}, "profiler/test_profiler": {"TestExperimentalUtils": 3.9083333333333328, "TestProfiler": 18.35066666666667, "TestProfilerCUDA": 5.336333333333333, "TestProfilerITT": 0.002}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.2763333333333334}, "profiler/test_record_function": {"TestRecordFunction": 0.259}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.601333333333333}, "test_ao_sparsity": {"TestActivationSparsifier": 0.056333333333333326, "TestBaseDataScheduler": 0.028, "TestBaseDataSparsifier": 0.06666666666666667, "TestBaseSparsifier": 0.020333333333333335, "TestBaseStructuredSparsifier": 2.6059999999999994, "TestComposability": 1.9593333333333334, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.05533333333333334, "TestFakeSparsity": 0.057, "TestFxComposability": 1.6496666666666666, "TestNearlyDiagonalSparsifier": 0.7386666666666666, "TestNormDataSparsifiers": 0.7153333333333333, "TestQuantizationUtils": 0.015666666666666666, "TestQuantizedSparseKernels": 0.255, "TestQuantizedSparseLayers": 0.3313333333333333, "TestSaliencyPruner": 0.021666666666666667, "TestScheduler": 0.010666666666666666, "TestSparsityUtilFunctions": 0.032, "TestWeightNormSparsifier": 0.26433333333333336}, "test_autocast": {"TestAutocastCPU": 1.2120000000000002, "TestAutocastGPU": 0.27033333333333337, "TestTorchAutocast": 0.0030000000000000005}, "test_autograd": {"TestAllowMutationOnSaved": 0.022333333333333334, "TestAutograd": 16.564666666666664, "TestAutogradComplex": 0.004, "TestAutogradDeviceTypeCUDA": 0.939666666666667, "TestAutogradForwardMode": 0.051666666666666694, "TestAutogradForwardModeBatchedGrad": 0.013000000000000003, "TestAutogradFunctional": 9.114333333333335, "TestAutogradInferenceMode": 0.024666666666666674, "TestAutogradLogging": 0.012333333333333333, "TestAutogradMultipleDispatchCUDA": 0.017666666666666667, "TestMultithreadAutograd": 0.1973333333333334, "TestNestedCheckpoint": 0.37566666666666676, "TestSelectiveActivationCheckpoint": 0.05866666666666668}, "test_autograd_fallback": {"TestAutogradFallback": 0.32300000000000006}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 121.23300000000148}, "test_bundled_inputs": {"TestBundledInputs": 0.8736666666666668}, "test_comparison_utils": {"TestComparisonUtils": 0.21566666666666667}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.08533333333333336}, "test_content_store": {"TestContentStoreCUDA": 2.7793333333333323}, "test_cpp_api_parity": {"TestCppApiParity": 8.69033333333332}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.25500000000000006, "TestMAIATensor": 0.005666666666666667, "TestPybindTypeCasters": 0.0013333333333333333, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.044000000000000004}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.225, "TestMAIATensor": 0.006333333333333333, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.045000000000000005}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 92.81566666666667}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.001}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 6.274333333333335}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.001}, "test_cuda": {"TestBlockStateAbsorption": 5.346666666666667, "TestCuda": 59.16866666666667, "TestCudaMallocAsync": 10.298000000000002, "TestCudaOptimsCUDA": 2.361333333333334}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 5.525666666666666, "TestCuda": 61.82233333333335, "TestCudaMallocAsync": 12.976, "TestCudaOptimsCUDA": 2.3833333333333324}, "test_cuda_multigpu": {"TestCudaComm": 0.016000000000000004, "TestCudaMultiGPU": 0.47900000000000004}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.26433333333333336, "TestVisibleDeviceParses": 0.017666666666666667}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0030000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.254, "TestEventHandler": 0.021000000000000008, "TestMessages": 0.0030000000000000005}, "test_cuda_trace": {"TestCudaTrace": 1.7686666666666664}, "test_custom_backend": {"TestCustomBackend": 0.07366666666666666}, "test_custom_ops": {"MiniOpTest": 0.5046666666666667, "MiniOpTestOther": 0.049666666666666685, "TestCustomOp": 2.1376666666666613, "TestCustomOpAPI": 0.12033333333333339, "TestCustomOpTestingCUDA": 1.4313333333333336, "TestCustomOperators": 0.3496666666666666, "TestGenerateOpcheckTests": 2.9323333333333337}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 33.17366666666667, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.027, "TestCustomPinFn": 0.10066666666666668, "TestDataLoader": 80.82733333333333, "TestDataLoaderDeviceTypeCUDA": 14.284, "TestDataLoaderPersistentWorkers": 108.99166666666667, "TestDatasetRandomSplit": 0.023000000000000003, "TestDictDataLoader": 0.035, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.0033333333333333335, "TestSetAffinity": 0.037333333333333336, "TestStackDataset": 0.024000000000000004, "TestStringDataLoader": 0.048666666666666664, "TestTensorDataset": 0.018000000000000002}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006666666666666667, "TestDataChunk": 0.006000000000000001, "TestDataFramesPipes": 0.001, "TestFunctionalIterDataPipe": 2.935666666666666, "TestFunctionalMapDataPipe": 0.02733333333333333, "TestGraph": 0.010333333333333335, "TestIterDataPipeCountSampleYielded": 0.006000000000000001, "TestIterDataPipeGraphFastForward": 0.035, "TestIterDataPipeSingletonConstraint": 0.016, "TestIterableDataPipeBasic": 0.022000000000000002, "TestSerialization": 6.169333333333333, "TestSharding": 0.18366666666666667, "TestStreamWrapper": 0.21433333333333335, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.02266666666666667, "HasDecompTest": 0.13633333333333333, "TestDecompCUDA": 10414.56633333333}, "test_deploy": {"TestFreezer": 0.20533333333333334}, "test_dispatch": {"TestDispatch": 32.52166666666668, "TestPythonDispatcher": 0.029333333333333333}, "test_dlpack": {"TestTorchDlPackCUDA": 0.2583333333333335}, "test_dynamic_shapes": {"TestDimConstraints": 1.639, "TestFloorDiv": 0.011000000000000001, "TestGuardsExpressions": 0.022333333333333334, "TestPySymInt": 1.0340000000000005, "TestSymNumberMagicMethods": 1.4586666666666612}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 2.7716666666666634, "TestExpandedWeightHelperFunctionCUDA": 0.12066666666666666, "TestExpandedWeightModuleCUDA": 10.051333333333334}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04566666666666668, "FakeTensorConverterTest": 0.017333333333333336, "FakeTensorDispatchCache": 0.06433333333333334, "FakeTensorOpInfoTestCUDA": 0.08533333333333336, "FakeTensorOperatorInvariants": 0.43533333333333335, "FakeTensorPropTest": 0.055999999999999994, "FakeTensorSerialization": 0.004666666666666667, "FakeTensorTest": 6.415666666666669, "PropagateRealTensorsFakeTensorConstHandling": 0.06866666666666667, "PropagateRealTensorsFakeTensorConverterTest": 0.016666666666666666, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.15466666666666665, "PropagateRealTensorsFakeTensorPropTest": 0.04, "PropagateRealTensorsFakeTensorTest": 10.259000000000013}, "test_flop_counter": {"TestFlopCounter": 0.66}, "test_foreach": {"TestForeachCUDA": 378.3100000000068}, "test_function_schema": {"TestFunctionSchema": 0.49766666666666665}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 17.002}, "test_functional_optim": {"TestFunctionalOptimParity": 0.29500000000000004}, "test_functionalization": {"TestCrossRefFunctionalization": 1.6469999999999994, "TestFunctionalization": 1.9336666666666655}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 2.0283333333333333}, "test_futures": {"TestFuture": 0.835}, "test_fx": {"AnnotationsTest": 0.011333333333333336, "TestCSEPass": 0.20633333333333337, "TestCommonPass": 0.1433333333333334, "TestConstFold": 0.1266666666666667, "TestConstParamShapeInControlFlow": 0.031000000000000003, "TestDCE": 0.022333333333333334, "TestFX": 2.2456666666666645, "TestFXAPIBackwardCompatibility": 0.021, "TestFunctionalTracing": 0.26133333333333353, "TestMatcher": 0.2793333333333334, "TestOperatorSignaturesCUDA": 0.7030000000000004, "TestPassManager": 0.018333333333333337, "TestSourceMatcher": 1.1976666666666667, "TestSubgraphRewriter": 0.2250000000000001, "TestVisionTracing": 211.293, "TypeCheckerTest": 1.4286666666666648}, "test_fx_experimental": {"TestFXExperimental": 11.549999999999999, "TestNormalizeOperatorsCUDA": 1.3289999999999997, "TestTranslationValidation": 0.10133333333333333}, "test_fx_passes": {"TestFXGraphPasses": 0.44933333333333353, "TestFXMatcherUtils": 0.06833333333333336}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.35466666666666674}, "test_import_stats": {"TestImportTime": 3.317}, "test_indexing": {"NumpyTestsCUDA": 0.04400000000000002, "TestIndexingCUDA": 1.6536666666666633}, "test_itt": {"TestItt": 0.20666666666666667}, "test_jit": {"TestAliasAnalysis": 0.27266666666666667, "TestAsync": 0.24833333333333338, "TestAtenPow": 0.006000000000000001, "TestAutodiffJit": 0.04466666666666667, "TestAutodiffSubgraphSlicing": 0.20166666666666674, "TestAwait": 0.14833333333333334, "TestBackends": 0.5116666666666667, "TestBackendsWithCompiler": 0.109, "TestBatchMM": 0.05933333333333334, "TestBuiltins": 0.043000000000000003, "TestCUDA": 0.5826666666666668, "TestClassType": 1.836666666666666, "TestComplex": 0.5833333333333335, "TestCustomOperators": 0.02333333333333334, "TestDCE": 0.013999999999999999, "TestDataParallel": 0.0003333333333333333, "TestDataclasses": 3.3626666666666662, "TestDeviceAnalysis": 3.0269999999999997, "TestDict": 0.29166666666666674, "TestDtypeAnalysis": 0.11066666666666668, "TestEnum": 0.14400000000000002, "TestFreezing": 1.6490000000000002, "TestFrontend": 0.3173333333333333, "TestFrozenOptimizations": 8.232, "TestFunctionalBlocks": 0.005333333333333333, "TestFunctionalToInplaceActivation": 1.6500000000000001, "TestGenerator": 0.04766666666666667, "TestGetDefaultAttr": 0.011333333333333334, "TestGraphRewritePasses": 0.029333333333333333, "TestHash": 0.050666666666666665, "TestHooks": 0.47233333333333355, "TestIgnorableArgs": 0.007, "TestIgnoreContextManager": 0.030666666666666665, "TestInplaceToFunctionalActivation": 1.5306666666666668, "TestIsinstance": 0.1413333333333334, "TestJit": 4.102333333333329, "TestJitGeneratedModule": 8.321999999999987, "TestJitProfiler": 0.001, "TestJitUtils": 0.01066666666666667, "TestList": 0.8793333333333337, "TestLogging": 0.035666666666666666, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.2826666666666667, "TestMixTracingScripting": 0.8023333333333333, "TestModels": 3.7239999999999998, "TestModuleAPIs": 0.09500000000000001, "TestModuleContainers": 0.8583333333333335, "TestModuleInterface": 0.5040000000000001, "TestModules": 0.009666666666666665, "TestNamedTuple": 0.04666666666666668, "TestNnapiBackend": 8.816333333333334, "TestOpDecompositions": 0.011333333333333334, "TestOptimizeForMobilePreserveDebugInfo": 0.121, "TestParametrization": 0.064, "TestPeephole": 0.3246666666666668, "TestProducerVersion": 0.001, "TestProfiler": 0.4386666666666667, "TestPythonBindings": 0.021333333333333333, "TestPythonBuiltinOP": 0.25800000000000006, "TestPythonIr": 0.017, "TestRecursiveScript": 0.5043333333333334, "TestRemoveMutation": 0.08700000000000001, "TestSaveLoad": 0.47600000000000015, "TestSaveLoadFlatbuffer": 0.25100000000000006, "TestSaveLoadForOpVersion": 1.7886666666666666, "TestScript": 31.4886666666667, "TestScriptDict": 0.015333333333333332, "TestScriptList": 0.534, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.1343333333333334, "TestScriptProfile": 0.27466666666666667, "TestSlice": 0.10566666666666669, "TestSparse": 0.032, "TestStringFormatting": 0.07833333333333338, "TestSymbolicShapeAnalysis": 0.9480000000000001, "TestTensorBuiltins": 0.06766666666666667, "TestTensorCreationOps": 0.032, "TestTensorMethods": 0.008, "TestTorchbind": 0.12000000000000005, "TestTracer": 3.3716666666666604, "TestTypeSharing": 0.3423333333333334, "TestTypesAndAnnotation": 0.08700000000000001, "TestTyping": 0.25800000000000006, "TestUnion": 0.2966666666666668, "TestUnsupportedOps": 0.01933333333333333, "TestUpgraders": 0.05000000000000001, "TestWarn": 0.036000000000000004, "TestWith": 0.24366666666666667}, "test_jit_autocast": {"TestAutocast": 1.2189999999999996, "TestJitTraceAutocast": 25.49}, "test_jit_disabled": {"TestJitDisabled": 0.3006666666666667}, "test_jit_fuser_te": {"TestFuserCommon": 0.115, "TestNNCOpInfoCUDA": 12.736666666667551, "TestTEFuserDynamic": 269.6703333333334, "TestTEFuserStatic": 226.51933333333338}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.061, "TestFusionPatternCUDA": 0.0003333333333333333, "TestModel": 0.001, "TestOpCUDA": 0.0013333333333333333}, "test_jiterator": {"TestPythonJiteratorCUDA": 13.616333333333365}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.9623333333333334, "TestVmapBatchedGradientLegacyCUDA": 0.3840000000000001, "TestVmapOperatorsLegacy": 0.7793333333333333}, "test_license": {"TestLicense": 0.21033333333333334}, "test_linalg": {"TestLinalgCUDA": 796.7983333333315}, "test_logging": {"LoggingTest": 2.3216666666666668}, "test_masked": {"TestMaskedCUDA": 25.264999999999997}, "test_maskedtensor": {"TestBasicsCUDA": 0.16966666666666666, "TestBinary": 0.2810000000000002, "TestOperatorsCUDA": 5.251333333333257, "TestReductions": 0.05800000000000002, "TestUnary": 0.2533333333333335}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.005666666666666667, "TestMatmulCudaCUDA": 87.86133333333333, "TestMixedDtypesLinearCudaCUDA": 0.8433333333333334}, "test_meta": {"TestMetaCUDA": 1697.326666666634, "TestMetaConverter": 0.10566666666666669}, "test_mkl_verbose": {"TestMKLVerbose": 3.5406666666666666}, "test_mkldnn_fusion": {"TestMkldnnFusion": 39.56033333333333}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.3853333333333335}, "test_mobile_optimizer": {"TestOptimizer": 2.6}, "test_model_dump": {"TestModelDump": 0.915}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.12266666666666666}, "test_module_tracker": {"TestModuleTracker": 0.22766666666666666}, "test_modules": {"TestModuleCUDA": 666.0156666666497}, "test_monitor": {"TestMonitor": 0.22366666666666665, "TestMonitorTensorboard": 0.10333333333333333}, "test_multiprocessing": {"TestMultiprocessing": 97.39533333333333}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.604, "SpawnTest": 25.334999999999997}, "test_namedtensor": {"TestNamedTensor": 0.673}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.6740000000000002}, "test_native_functions": {"TestNativeFunctions": 0.31600000000000006}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.6470000000000002}, "test_nestedtensor": {"TestNestedTensor": 0.1123333333333334, "TestNestedTensorAutogradCUDA": 1.0466666666666666, "TestNestedTensorDeviceTypeCUDA": 1.2733333333333314, "TestNestedTensorSubclassCUDA": 5.904999999999995}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.25733333333333336, "TestFusionUtils": 0.004, "TestNN": 47.031666666666744, "TestNNDeviceTypeCUDA": 114.91533333333756, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.09366666666666668}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.1373333333333334}, "test_openmp": {"TestOpenMP_ParallelFor": 3.517666666666667}, "test_ops": {"TestCommonCUDA": 2531.844666666641, "TestCompositeComplianceCUDA": 787.3459999999985, "TestFakeTensorCUDA": 657.2489999999993, "TestMathBitsCUDA": 71.95066666666669, "TestSelfKwarg": 0.022333333333333334, "TestTagsCUDA": 2.060000000000001}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 968.2469999999997}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1697.7003333332843}, "test_ops_jit": {"TestJitCUDA": 926.656}, "test_optim": {"TestDifferentiableOptimizer": 0.168, "TestLRScheduler": 0.8190000000000004, "TestOptimRenewedCUDA": 218.87899999999968, "TestSWAUtils": 0.8303333333333334}, "test_out_dtype_op": {"TestOutDtypeOp": 0.2803333333333334}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.01833333333333333, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.002, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.005, "TestResolveName": 0.09333333333333334, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 1.695666666666593, "TestTorchFunctionWarning": 0.01, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.029333333333333333, "ModelTest": 0.0, "TestAnalyze": 0.13799999999999998, "TestDependencyAPI": 0.036000000000000004, "TestDependencyHooks": 0.006000000000000001, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014333333333333339, "TestImporter": 0.008333333333333333, "TestLoadBCPackages": 0.04633333333333334, "TestMangling": 0.012000000000000002, "TestMisc": 0.02333333333333334, "TestPackageFX": 0.05199999999999999, "TestPackageScript": 1.466666666666666, "TestRepackage": 0.004666666666666667, "TestResources": 0.009333333333333334, "TestSaveLoad": 0.027666666666666673}, "test_per_overload_api": {"TestPerOverloadAPI": 0.21}, "test_prims": {"TestDecompCUDA": 0.06866666666666667, "TestPrimsBasic": 0.011333333333333334, "TestPrimsCUDA": 0.24766666666666667, "TestRefsCUDA": 0.009333333333333334}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.09066666666666667, "TestGenericProxyTensorFake": 1.6383333333333334, "TestGenericProxyTensorReal": 1.8246666666666664, "TestGenericProxyTensorSymbolic": 16.078333333333333, "TestRealProxyTensor": 0.012333333333333333, "TestSymbolicTracing": 3.072666666666666}, "test_pruning_op": {"PruningOpTest": 0.393}, "test_public_bindings": {"TestPublicBindings": 4.592}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.02266666666666667, "TestPythonDispatch": 0.3140000000000001, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 0.8610000000000001, "TestWrapperSubclassAliasingCUDA": 0.10333333333333337}, "test_pytree": {"TestCxxPytree": 0.013000000000000005, "TestGenericPytree": 0.3073333333333334, "TestPythonPytree": 0.04366666666666669}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000001, "TestAOMigrationNNQuantized": 0.027, "TestAOMigrationQuantization": 0.014, "TestAOMigrationQuantizationFx": 0.024000000000000004, "TestBackendConfig": 0.03333333333333333, "TestBiasCorrectionEager": 0.596, "TestBitsCUDA": 0.016333333333333335, "TestComparatorOps": 1.6933333333333334, "TestDeprecatedJitQuantized": 1.9813333333333334, "TestDistributed": 0.023000000000000003, "TestDuplicateDQPass": 3.2390000000000003, "TestDynamicQuantizedModule": 39.314, "TestDynamicQuantizedOps": 21.86766666666667, "TestEqualizeEager": 0.08033333333333334, "TestEqualizeFx": 3.342, "TestFXGraphMatcher": 1.9610000000000003, "TestFXGraphMatcherModels": 7.998, "TestFXNumericSuiteCoreAPIs": 24.162000000000003, "TestFXNumericSuiteCoreAPIsModels": 34.437666666666665, "TestFXNumericSuiteNShadows": 35.02733333333333, "TestFakeQuantize": 0.305, "TestFakeQuantizeOps": 21.708, "TestFloat8DtypeCUDA": 0.19266666666666668, "TestFuseEager": 3.4133333333333336, "TestFuseFx": 1.6396666666666662, "TestFusedObsFakeQuant": 0.16433333333333336, "TestFusedObsFakeQuantModule": 0.25233333333333335, "TestFusionPasses": 0.016666666666666666, "TestFxDetectInputWeightEqualization": 0.159, "TestFxDetectOutliers": 0.20133333333333336, "TestFxModelReportClass": 0.40399999999999997, "TestFxModelReportDetectDynamicStatic": 0.055, "TestFxModelReportDetector": 0.16000000000000003, "TestFxModelReportObserver": 0.155, "TestFxModelReportVisualizer": 0.16966666666666666, "TestGenerateNumericDebugHandle": 0.9196666666666667, "TestGraphUtils": 1.0753333333333333, "TestHistogramObserver": 35.419333333333334, "TestMetaDataPorting": 7.209999999999998, "TestModelNumericsEager": 0.7543333333333333, "TestNumericSuiteEager": 6.305333333333333, "TestObserver": 3.1453333333333333, "TestPT2ERepresentation": 24.767, "TestPadding": 9.633666666666668, "TestQNNPackOps": 5.5183333333333335, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 1.5673333333333332, "TestQuantizeDynamicJitPasses": 3.9073333333333333, "TestQuantizeEagerOps": 1.4406666666666668, "TestQuantizeEagerPTQDynamic": 7.557666666666666, "TestQuantizeEagerPTQStatic": 24.856666666666666, "TestQuantizeEagerQAT": 8.358333333333334, "TestQuantizeEagerQATNumerics": 1.522, "TestQuantizeFx": 25.75133333333333, "TestQuantizeFxModels": 8.746, "TestQuantizeFxOps": 100.22733333333333, "TestQuantizeJit": 18.768666666666668, "TestQuantizeJitOps": 211.65133333333333, "TestQuantizeJitPasses": 4.841333333333334, "TestQuantizePT2E": 70.79233333333333, "TestQuantizePT2EQATModels": 40.340333333333334, "TestQuantizePT2EQAT_ConvBn1d": 597.0246666666667, "TestQuantizePT2EQAT_ConvBn2d": 600.7763333333334, "TestQuantizePT2EX86Inductor": 190.31033333333335, "TestQuantizedConv": 231.1846666666667, "TestQuantizedEmbeddingOps": 0.9663333333333334, "TestQuantizedFunctionalOps": 2.459, "TestQuantizedLinear": 17.019000000000002, "TestQuantizedOps": 114.49266666666665, "TestQuantizedTensor": 1.9583333333333333, "TestRecordHistogramObserver": 0.02366666666666667, "TestReferenceQuantizedModule": 0.03566666666666667, "TestSerialization": 1.5826666666666667, "TestStaticQuantizedModule": 88.86566666666668, "TestSubgraphRewriter": 0.7930000000000001, "TestUtils": 0.013666666666666667, "TestXNNPACKQuantizer": 45.90533333333334, "TestXNNPACKQuantizerModels": 2.594}, "test_reductions": {"TestReductionsCUDA": 129.9406666666671}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 28.136}, "test_schema_check": {"TestSchemaCheck": 0.1586666666666667, "TestSchemaCheckModeOpInfoCUDA": 234.84199999999313}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 2.346666666666666}, "test_serialization": {"TestBothSerializationCUDA": 0.11566666666666665, "TestOldSerialization": 15.291333333333334, "TestSerialization": 6.477333333333324, "TestSubclassSerialization": 0.022666666666666672}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.20333333333333337}, "test_shape_ops": {"TestShapeOpsCUDA": 1.3353333333333322}, "test_show_pickle": {"TestShowPickle": 0.221}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.6166666666666636}, "test_sparse": {"TestSparseAnyCUDA": 659.9603333333334, "TestSparseCUDA": 60.29066666666665, "TestSparseLegacyAndDeprecation": 0.035333333333333335, "TestSparseMaskedReductionsCUDA": 2.3673333333333337, "TestSparseMeta": 2.9736666666666665, "TestSparseOneOff": 0.061, "TestSparseUnaryUfuncsCUDA": 5.729999999999973}, "test_sparse_csr": {"TestSparseCSRCUDA": 250.90099999999998, "TestSparseCSRSampler": 0.49466666666666664, "TestSparseCompressedCUDA": 139.34233333333353, "TestSparseCompressedTritonKernelsCUDA": 1240.6503333333333}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 9.815666666666667, "TestSparseSemiStructuredCUDA": 2.3223333333333263, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.18600000000000008, "TestSparseSemiStructuredCUTLASSCUDA": 13.313666666666668, "TestSparseSemiStructuredTrainingCUDA": 5.9573333333333345}, "test_spectral_ops": {"TestFFTCUDA": 18.445999999999966}, "test_stateless": {"TestPythonOptimizeMode": 3.1310000000000002, "TestStatelessDeprecation": 1.5603333333333331, "TestStatelessFunctionalAPI": 0.18366666666666673}, "test_subclass": {"TestSubclass": 0.3503333333333334}, "test_sympy_utils": {"TestNumbers": 0.033, "TestSingletonInt": 0.004, "TestSympyInterp": 7.224, "TestSympySolve": 0.13733333333333336, "TestValueRanges": 5.246999999999998}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4310000000000003, "TestLikeTensorCreationCUDA": 0.007, "TestRandomTensorCreationCUDA": 0.13100000000000003, "TestTensorCreationCUDA": 84.68866666666686}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.019, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.1416666666666667, "TestTensorBoardPytorchGraph": 22.010333333333335, "TestTensorBoardSummary": 0.025333333333333343, "TestTensorBoardSummaryWriter": 0.006666666666666667, "TestTensorBoardUtils": 0.10366666666666668, "TestTensorBoardWriter": 0.057999999999999996, "TestTensorProtoSummary": 0.008333333333333333}, "test_tensorexpr": {"TestTensorExprFuser": 97.68599999999999}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.007333333333333333, "TestTensorExprPyBind": 0.759}, "test_testing": {"TestAssertClose": 0.07800000000000004, "TestAssertCloseContainer": 0.004666666666666667, "TestAssertCloseErrorMessage": 0.04666666666666668, "TestAssertCloseMultiDeviceCUDA": 0.009666666666666665, "TestAssertCloseQuantized": 0.009000000000000001, "TestAssertCloseSparseBSC": 0.013000000000000003, "TestAssertCloseSparseBSR": 0.013333333333333336, "TestAssertCloseSparseCOO": 0.016, "TestAssertCloseSparseCSC": 0.013000000000000003, "TestAssertCloseSparseCSR": 0.014666666666666666, "TestFrameworkUtils": 12.150666666666666, "TestImports": 10.487666666666668, "TestMakeTensorCUDA": 0.9220000000000007, "TestOpInfoSampleFunctionsCUDA": 3.4813333333333483, "TestOpInfos": 0.002, "TestTestParametrization": 0.021333333333333343, "TestTestParametrizationDeviceTypeCUDA": 3.156333333333331, "TestTestingCUDA": 0.3190000000000001}, "test_torch": {"TestBasicVitalSigns": 0.023333333333333334, "TestDevicePrecisionCUDA": 0.05666666666666668, "TestTorch": 4.892333333333323, "TestTorchDeviceTypeCUDA": 69.64600000000006, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 1.357, "TestSDPACUDA": 1.402333333333334, "TestSDPACudaOnlyCUDA": 1366.4009999993593, "TestSDPAFailureModesCUDA": 0.225, "TestTransformersCUDA": 4.467333333333333}, "test_type_hints": {"TestTypeHints": 0.20099999999999998}, "test_type_info": {"TestDTypeInfo": 0.21766666666666667}, "test_type_promotion": {"TestTypePromotionCUDA": 7.0793333333333015}, "test_typing": {"TestTyping": 59.24699999999998}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 332.5299999999432}, "test_utils": {"TestAssert": 0.051333333333333335, "TestBottleneck": 10.363999999999999, "TestCheckpoint": 0.156, "TestCollectEnv": 0.9586666666666667, "TestCppExtensionUtils": 0.02666666666666667, "TestDataLoaderUtils": 0.26466666666666666, "TestDeviceUtilsCUDA": 11.767666666667258, "TestExtensionUtils": 0.0036666666666666666, "TestHipify": 0.001, "TestHipifyTrie": 0.005333333333333333, "TestONNXUtils": 0.0030000000000000005, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 2.2123333333333335, "TestTraceback": 0.006333333333333333}, "test_view_ops": {"TestOldViewOpsCUDA": 14.528333333333334, "TestViewOpsCUDA": 0.9963333333333333}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.016666666666666666, "WeakKeyDictionaryTestCase": 0.016, "WeakTest": 3.5126666666666657}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 30.787000000000003, "TestXNNPACKOps": 3.0916666666666663, "TestXNNPACKRewritePass": 1.3659999999999997, "TestXNNPACKSerDes": 3.7193333333333336}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0033333333333333335}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.21966666666666668, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.09700000000000002, "TestPromotion": 0.0}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 12.087666666666665, "TestEinsumPath": 0.0, "TestMisc": 0.004666666666666667}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.217, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0016666666666666668, "TestBooleanIndexing": 0.0036666666666666666, "TestBroadcastedAssignments": 0.012333333333333333, "TestFancyIndexingCast": 0.0026666666666666666, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.3103333333333334, "TestMultiIndexingAutomated": 0.006000000000000001, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.015333333333333338, "TestArgmax": 0.9416666666666674, "TestArgmaxArgminCommon": 0.04900000000000002, "TestArgmin": 1.1120000000000003, "TestArrayAttributeDeletion": 0.004333333333333334, "TestArrayConstruction": 0.03033333333333334, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.008, "TestAttributes": 0.019000000000000003, "TestBinop": 0.015, "TestBool": 21.251333333333335, "TestCequenceMethods": 0.0016666666666666668, "TestChoose": 0.013333333333333336, "TestClip": 0.004666666666666667, "TestCompress": 0.0030000000000000005, "TestConversion": 0.030333333333333334, "TestCreation": 0.001, "TestDelMisc": 0.001, "TestDot": 0.059000000000000025, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.025333333333333333, "TestFlag": 0.009000000000000001, "TestFormat": 0.004, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.12633333333333333, "TestHashing": 0.002, "TestIO": 0.001, "TestInner": 0.17500000000000002, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.35100000000000015, "TestMatmulOperator": 0.23733333333333337, "TestMethods": 1.1683333333333337, "TestMinMax": 0.0036666666666666666, "TestMinScalarType": 0.004, "TestNewaxis": 0.0030000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.011000000000000001, "TestResize": 0.03833333333333334, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.018666666666666668, "TestSortFloatMisc": 0.12566666666666673, "TestStats": 0.19699999999999998, "TestSubscripting": 0.001, "TestTake": 0.026333333333333337, "TestVdot": 0.03166666666666667, "TestWarnings": 0.001, "TestWhere": 0.2786666666666667, "TestWritebackIfCopy": 0.023000000000000003}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.016333333333333335, "TestArgwhere": 0.02366666666666667, "TestArrayComparisons": 0.010333333333333333, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006000000000000001, "TestBoolArray": 1.6506666666666667, "TestBoolCmp": 0.14433333333333334, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.1440000000000001, "TestConvolve": 0.013333333333333334, "TestCorrelate": 0.02366666666666667, "TestCreationFuncs": 0.9013333333333334, "TestCross": 0.04033333333333333, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.007666666666666666, "TestFromiter": 0.0, "TestIndex": 0.004333333333333334, "TestIndices": 0.02966666666666667, "TestIsclose": 0.06933333333333334, "TestIsscalar": 0.0016666666666666668, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.005666666666666667, "TestNonarrayArgs": 0.08633333333333337, "TestNonzeroAndCountNonzero": 0.211, "TestOuterMisc": 0.004, "TestRequire": 0.004, "TestResize": 0.22166666666666668, "TestRoll": 0.025999999999999995, "TestRollaxis": 0.0030000000000000005, "TestSeterr": 0.004, "TestStdVar": 0.02266666666666667, "TestStdVarComplex": 0.009666666666666669, "TestStringFunction": 0.001, "TestTensordot": 0.011333333333333334, "TestTypes": 0.010333333333333335}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.212, "TestDocStrings": 0.0, "TestIsSubDType": 0.006000000000000001, "TestScalarTypeNames": 0.021000000000000008}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06066666666666671, "TestFromInt": 0.005666666666666667, "TestFromString": 0.20533333333333334}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.0, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.08533333333333333, "TestBaseMath": 7.912, "TestBitShifts": 0.07733333333333332, "TestComplexDivision": 0.05133333333333334, "TestConversion": 0.045000000000000005, "TestHash": 0.0, "TestModulus": 0.862, "TestMultiply": 0.0, "TestNegative": 0.015666666666666666, "TestPower": 0.10900000000000003, "TestRepr": 0.001, "TestScalarOpsMisc": 0.02933333333333335, "TestScalarSubclassingMisc": 0.009666666666666669, "TestSubtract": 0.015333333333333332, "TestTypes": 13.431}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.21733333333333335, "TestAtleast2d": 0.013000000000000003, "TestAtleast3d": 0.012000000000000002, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.12400000000000007, "TestHstack": 0.012666666666666668, "TestStackMisc": 0.0030000000000000005, "TestVstack": 0.018000000000000002}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.008666666666666668, "TestFFTShift": 5.258333333333333, "TestIRFFTN": 0.0030000000000000005, "TestRFFTFreq": 0.008666666666666668}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.1310000000000007, "TestFFTShift": 0.20866666666666667, "TestFFTThreadSafe": 0.5293333333333333}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.22}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0030000000000000005, "TestUnique": 0.3406666666666667}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.005666666666666667, "TestAmax": 0.005666666666666667, "TestAmin": 0.005, "TestAngle": 0.007666666666666666, "TestAny": 0.005333333333333333, "TestAverage": 0.022000000000000002, "TestBincount": 0.030333333333333334, "TestCheckFinite": 0.002, "TestCopy": 0.006000000000000001, "TestCorrCoef": 0.026, "TestCov": 0.047666666666666684, "TestCumprod": 0.026333333333333334, "TestCumsum": 0.035, "TestDelete": 0.015666666666666666, "TestDiff": 0.06133333333333333, "TestDigitize": 0.011333333333333336, "TestExtins": 0.004, "TestFilterwindows": 0.4803333333333337, "TestFlip": 0.02466666666666667, "TestGradient": 0.12466666666666666, "TestInsert": 0.008333333333333333, "TestInterp": 0.03433333333333335, "TestKaiser": 0.008666666666666668, "TestMedian": 0.08466666666666668, "TestMeshgrid": 0.04366666666666668, "TestMsort": 0.0, "TestPercentile": 0.052333333333333364, "TestPiecewise": 0.008, "TestProd": 0.025333333333333336, "TestPtp": 0.008, "TestQuantile": 0.013333333333333336, "TestRot90": 0.17366666666666666, "TestSelect": 0.007, "TestSinc": 0.007, "TestSortComplex": 0.007666666666666666, "TestTrapz": 0.004666666666666667, "TestTrimZeros": 0.008, "TestUnique": 0.0030000000000000005, "Test_I0": 0.011000000000000001}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.3066666666666667, "TestHistogramOptimBinNums": 0.02233333333333334, "TestHistogramdd": 0.10866666666666668}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006666666666666667, "TestDiagIndices": 0.004, "TestDiagIndicesFrom": 0.006000000000000001, "TestFillDiagonal": 0.021, "TestGrid": 0.007, "TestIndexExpression": 0.008666666666666668, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.22033333333333335}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.010000000000000002, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.1376666666666667, "TestColumnStack": 0.007666666666666666, "TestDsplit": 0.008, "TestDstack": 0.012666666666666668, "TestExpandDims": 0.005, "TestHsplit": 0.010000000000000002, "TestKron": 0.010666666666666666, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.008, "TestSplit": 0.005, "TestSqueeze": 0.02366666666666667, "TestTakeAlongAxis": 0.23333333333333336, "TestTile": 0.07100000000000001, "TestVsplit": 0.007}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.025333333333333336, "TestEye": 0.24633333333333332, "TestFliplr": 0.004666666666666667, "TestFlipud": 0.004333333333333334, "TestHistogram2d": 0.028999999999999998, "TestTri": 0.08, "TestTrilIndicesFrom": 0.0013333333333333333, "TestTriuIndices": 0.0030000000000000005, "TestTriuIndicesFrom": 0.001, "TestVander": 0.016}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.20533333333333334, "TestImag": 0.011666666666666667, "TestIscomplex": 0.004333333333333334, "TestIscomplexobj": 0.0030000000000000005, "TestIsfinite": 0.008333333333333333, "TestIsinf": 0.006666666666666667, "TestIsnan": 0.007333333333333333, "TestIsneginf": 0.0016666666666666668, "TestIsposinf": 0.0016666666666666668, "TestIsreal": 0.006333333333333333, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.0036666666666666666, "TestNanToNum": 0.010333333333333333, "TestReal": 0.011000000000000001, "TestRealIfClose": 0.0036666666666666666}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.1366666666666667, "TestCond": 0.19266666666666665, "TestDet": 0.12933333333333333, "TestEig": 0.030000000000000002, "TestEigh": 0.019333333333333338, "TestEighCases": 0.0, "TestEigvals": 0.04966666666666667, "TestEigvalsh": 0.016333333333333335, "TestEigvalshCases": 0.0, "TestInv": 0.04466666666666667, "TestLstsq": 0.17699999999999996, "TestMatrixRank": 0.309, "TestMisc": 0.019666666666666666, "TestMisc2": 0.0016666666666666668, "TestMultiDot": 0.04566666666666667, "TestNormDouble": 0.7056666666666667, "TestNormInt64": 0.6853333333333333, "TestNormSingle": 0.7203333333333332, "TestNorm_NonSystematic": 0.0030000000000000005, "TestPinv": 0.09999999999999999, "TestPinvHermitian": 0.027, "TestQR": 0.4153333333333334, "TestSVD": 0.03966666666666667, "TestSVDHermitian": 0.08566666666666667, "TestSolve": 0.256, "TestTensorinv": 0.014333333333333332, "TestTensorsolve": 0.0026666666666666666}, "torch_np/test_basic": {"TestArrayToSequence": 0.006000000000000001, "TestCopyTo": 0.004, "TestCtorNested": 0.0030000000000000005, "TestDefaultDtype": 0.004, "TestDivmod": 0.011000000000000003, "TestExport": 0.0, "TestMisc": 0.236, "TestNormalizations": 0.0030000000000000005, "TestOneArr": 0.2403333333333335, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.0023333333333333335, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.016, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.2986666666666667}, "torch_np/test_dtype": {"TestConvertDType": 0.2436666666666667}, "torch_np/test_function_base": {"TestAppend": 0.209}, "torch_np/test_ndarray_methods": {"TestAmax": 0.006666666666666667, "TestAmin": 0.006333333333333334, "TestArgmax": 0.938333333333334, "TestArgmaxArgminCommon": 0.04333333333333334, "TestArgmin": 1.0206666666666673, "TestContains": 0.0013333333333333333, "TestIndexing": 0.209, "TestIter": 0.004, "TestNoExtraMethods": 0.006000000000000001, "TestNonzero": 0.124, "TestRavel": 0.005333333333333333, "TestReshape": 0.0036666666666666666, "TestTranspose": 0.007333333333333333}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.011666666666666667, "TestNEP50Table": 0.0}, "torch_np/test_random": {"TestChoice": 0.008333333333333333, "TestNumpyGlobal": 0.0030000000000000005, "TestScalarReturn": 0.23633333333333337, "TestShuffle": 0.009000000000000001}, "torch_np/test_reductions": {"TestAll": 0.01, "TestAny": 0.01, "TestFlatnonzero": 0.156, "TestGenericCumSumProd": 0.015333333333333332, "TestGenericReductions": 1.7419999999999611, "TestMean": 0.017, "TestSum": 0.18299999999999997}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.2326666666666667, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.42033333333333367, "TestNdarrayDunderVsUfunc": 0.16633333333333342, "TestUfuncDtypeKwd": 0.004666666666666667, "TestUnaryUfuncs": 0.2476666666666667}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.3040000000000001}}}, "linux-focal-py3.11-clang10": {"crossref": {"backends/xeon/test_launch": {"TestTorchrun": 1.8153333333333332}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.5139999999999996}, "distributions/test_constraints": {"test_constraints": 0.09766666666666672}, "distributions/test_distributions": {"TestAgainstScipy": 0.9893333333333333, "TestConstraints": 0.152, "TestDistributionShapes": 0.14866666666666675, "TestDistributions": 17.924000000000003, "TestFunctors": 0.013, "TestJit": 21.936666666666667, "TestKL": 2.972333333333333, "TestLazyLogitsInitialization": 0.015666666666666666, "TestNumericalStability": 0.07933333333333335, "TestRsample": 0.6593333333333333, "TestValidation": 0.38966666666666677}, "export/test_converter": {"TestConverter": 7.726}, "export/test_db": {"ExampleTests": 3.0063333333333326}, "export/test_export": {"TestDynamismExpression": 0.8026666666666668, "TestExport": 33.065000000000005, "TestExportCustomClass": 0.08700000000000001, "TestOneOffModelExportResult": 1.2236666666666667}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.018666666666666668}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.5196666666666666}, "export/test_hop": {"TestHOPCPU": 2.882, "TestHOPGeneric": 0.0030000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.09133333333333334, "TestLiftUnlift": 0.011333333333333334}, "export/test_pass_infra": {"TestPassInfra": 0.7616666666666667}, "export/test_passes": {"TestPasses": 12.876333333333335}, "export/test_safeguard": {"TestSafeguard": 0.642}, "export/test_schema": {"TestSchema": 0.05566666666666666}, "export/test_serialize": {"TestDeserialize": 7.525666666666665, "TestOpVersioning": 0.0045000000000000005, "TestSaveLoad": 0.2813333333333333, "TestSchemaVersioning": 0.029666666666666664, "TestSerialize": 0.9826666666666665, "TestSerializeCustomClass": 0.082}, "export/test_sparse": {"TestSparseProp": 88.09766666666667}, "export/test_tools": {"TestExportTools": 0.3419999999999999}, "export/test_torchbind": {"TestCompileTorchbind": 1.3790000000000002, "TestExportTorchbind": 2.1463333333333328, "TestRegisterFakeClass": 0.0030000000000000005}, "export/test_tree_utils": {"TestTreeUtils": 0.023333333333333334}, "export/test_unflatten": {"TestUnflatten": 3.370666666666667}, "export/test_upgrade": {"TestUpgrade": 0.2272}, "export/test_verifier": {"TestVerifier": 0.798}, "functorch/test_aotdispatch": {"TestAOTAutograd": 13.992666666666665, "TestAOTAutogradWithDynamo": 18.842333333333332, "TestAOTDispatch": 0.5413333333333333, "TestAOTExport": 2.651333333333333, "TestAOTModuleSimplified": 0.641, "TestEagerFusionModuleInfoCPU": 966.933333333333, "TestEagerFusionOpInfoCPU": 2381.6750000000015, "TestPartitioning": 1.3526666666666667, "TestPythonKeyCPU": 1.232}, "functorch/test_control_flow": {"TestControlFlow": 0.6160000000000001, "TestControlFlowTraced": 123.87233333333334}, "functorch/test_dims": {"TestMin": 14.398000000000001, "TestMinFunctorchOnly": 13.323666666666666}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.11200000000000004, "TestAutogradFunctionVmapAPICPU": 0.02566666666666667, "TestCompileTransformsCPU": 9.464, "TestComposabilityCPU": 1.982333333333333, "TestExamplesCorrectnessCPU": 4.8069999999999995, "TestFunctionalizeCPU": 0.12500000000000003, "TestGradTransformCPU": 0.5306666666666668, "TestHelpersCPU": 0.009333333333333334, "TestHessianCPU": 0.042, "TestHigherOrderOperatorInteractionCPU": 0.028, "TestJacCPU": 0.8106666666666671, "TestJvpCPU": 0.05466666666666669, "TestLinearizeCPU": 0.20066666666666666, "TestMakeFunctional": 0.10000000000000003, "TestSliceArgnums": 0.015000000000000001, "TestVmapJvpInplaceViewCPU": 0.018333333333333333, "TestVmapOfGradCPU": 0.3483333333333334}, "functorch/test_logging": {"TestAOTLogging": 0.056}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.274, "RandomOpTestCase": 0.07100000000000001, "ReduceTestCase": 0.07433333333333335, "TestMemoryEfficientOpAuthoring": 0.0}, "functorch/test_minifier": {"TestMinifier": 0.20033333333333334}, "functorch/test_ops": {"TestOperatorsCPU": 3437.7126666666663}, "functorch/test_parsing": {"TestAnonymousAxis": 0.014666666666666666, "TestParsedExpression": 0.006000000000000001, "TestParsingUtils": 0.006666666666666667, "TestValidateRearrangeExpressions": 0.006666666666666667}, "functorch/test_rearrange": {"TestRearrange": 0.08700000000000001}, "functorch/test_vmap": {"TestRandomnessCPU": 1.8713333333333335, "TestTransformFailureCPU": 0.269, "TestVmapAPI": 0.2830000000000001, "TestVmapBatchedGradientCPU": 0.17900000000000005, "TestVmapDeviceTypeCPU": 0.02666666666666666, "TestVmapNestedTensorCPU": 0.04766666666666667, "TestVmapOperators": 3.312999999999999, "TestVmapOperatorsOpInfoCPU": 653.9236666666662}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.065666666666555}, "higher_order_ops/test_with_effects": {"TestWithEffects": 10.741666666666665}, "inductor/test_fx_fusion": {"TestFxFusion": 0.06166666666666667}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.03266666666666667}, "lazy/test_debug_util": {"DebugUtilTest": 0.075}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.066}, "lazy/test_generator": {"LazyGeneratorTest": 0.05966666666666667}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.2883333333333334}, "lazy/test_step_closures": {"ClosuresTest": 2.0113333333333334}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.3336666666666666, "TestLazyOpInfoCPU": 9.679999999999984, "TestLazyTensor": 0.079}, "nn/test_convolution": {"TestConvolutionNN": 12.980333333333334, "TestConvolutionNNDeviceTypeCPU": 6.955999999999952}, "nn/test_dropout": {"TestDropoutNN": 0.12866666666666668, "TestDropoutNNDeviceTypeCPU": 0.4126666666666667}, "nn/test_embedding": {"TestEmbeddingNN": 0.09966666666666668, "TestEmbeddingNNDeviceTypeCPU": 10.659000000000004}, "nn/test_init": {"TestNNInit": 3.4909999999999997}, "nn/test_lazy_modules": {"TestLazyModules": 0.5450000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.9313333333333332, "TestLoadStateDictSwap": 0.0030000000000000005}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.03266666666666667, "TestModuleHookNN": 0.10133333333333334, "TestModuleHooks": 0.11766666666666668, "TestStateDictHooks": 0.04700000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 7.9830000000000005, "TestMultiheadAttentionNNDeviceTypeCPU": 0.03833333333333334}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.28400000000000003}, "nn/test_parametrization": {"TestNNParametrization": 1.2109999999999996, "TestNNParametrizationDeviceCPU": 0.016666666666666666}, "nn/test_pooling": {"TestAvgPool": 0.3053333333333333, "TestPoolingNN": 0.45566666666666666, "TestPoolingNNDeviceTypeCPU": 30.558333333333337}, "nn/test_pruning": {"TestPruningNN": 0.12066666666666674}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.15466666666666665}, "profiler/test_memory_profiler": {"TestDataFlow": 1.3996666666666666, "TestIdentifyGradients": 0.31733333333333336, "TestMemoryProfiler": 0.018666666666666668, "TestMemoryProfilerE2E": 3.3303333333333334}, "profiler/test_profiler": {"TestExecutionTrace": 8.959333333333333, "TestExperimentalUtils": 5.3629999999999995, "TestProfiler": 17.561333333333334, "TestProfilerCUDA": 0.0006666666666666666, "TestProfilerITT": 0.018, "TestRecordFunction": 0.053333333333333344, "TestTorchTidyProfiler": 5.377999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.05033333333333334}, "profiler/test_record_function": {"TestRecordFunction": 0.09866666666666668}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.0073333333333325}, "test_ao_sparsity": {"TestActivationSparsifier": 0.12366666666666666, "TestBaseDataScheduler": 0.04666666666666667, "TestBaseDataSparsifier": 0.10066666666666667, "TestBaseSparsifier": 0.035666666666666666, "TestBaseStructuredSparsifier": 1.7139999999999997, "TestComposability": 2.4143333333333334, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.027, "TestFakeSparsity": 0.07566666666666667, "TestFxComposability": 2.1013333333333333, "TestNearlyDiagonalSparsifier": 0.8443333333333333, "TestNormDataSparsifiers": 1.1413333333333335, "TestQuantizationUtils": 0.022333333333333334, "TestQuantizedSparseKernels": 0.24366666666666667, "TestQuantizedSparseLayers": 0.5643333333333334, "TestSaliencyPruner": 0.02766666666666667, "TestScheduler": 0.014666666666666666, "TestSparsityUtilFunctions": 0.05499999999999999, "TestWeightNormSparsifier": 0.38066666666666665}, "test_autocast": {"TestAutocastCPU": 0.5953333333333335, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.005}, "test_autograd": {"TestAllowMutationOnSaved": 0.037000000000000005, "TestAutograd": 18.45433333333335, "TestAutogradComplex": 0.005333333333333333, "TestAutogradDeviceTypeCPU": 0.3320000000000001, "TestAutogradForwardMode": 0.09900000000000005, "TestAutogradForwardModeBatchedGrad": 0.019, "TestAutogradFunctional": 8.868666666666668, "TestAutogradInferenceMode": 0.04600000000000001, "TestAutogradLogging": 0.009666666666666667, "TestAutogradMultipleDispatchCPU": 0.03366666666666667, "TestMultithreadAutograd": 0.36800000000000005, "TestNestedCheckpoint": 0.3276666666666667, "TestSelectiveActivationCheckpoint": 0.030666666666666665}, "test_autograd_fallback": {"TestAutogradFallback": 0.12666666666666673}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 138.20000000000098}, "test_bundled_inputs": {"TestBundledInputs": 1.0250000000000001}, "test_comparison_utils": {"TestComparisonUtils": 0.019000000000000003}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0003333333333333333}, "test_complex": {"TestComplexTensorCPU": 0.05766666666666668}, "test_content_store": {"TestContentStoreCPU": 6.859666666666667}, "test_cpp_api_parity": {"TestCppApiParity": 3.413666666666655}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.04166666666666668, "TestMAIATensor": 0.007333333333333333, "TestORTTensor": 0.011000000000000001, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.04133333333333334, "TestMAIATensor": 0.007333333333333333, "TestORTTensor": 0.011000000000000001, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 28.386}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.4669999999999999}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 8.549000000000001}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.45766666666666667}, "test_custom_backend": {"TestCustomBackend": 0.07133333333333332}, "test_custom_ops": {"MiniOpTest": 0.8113333333333329, "MiniOpTestOther": 0.10466666666666669, "TestCustomOp": 3.0843333333333294, "TestCustomOpAPI": 0.21633333333333338, "TestCustomOpTestingCPU": 2.306, "TestCustomOperators": 0.2316666666666667, "TestGenerateOpcheckTests": 3.8409999999999997}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 36.35733333333334, "TestConcatDataset": 0.011666666666666667, "TestConvAfterFork": 0.132, "TestCustomPinFn": 0.001, "TestDataLoader": 35.388666666666666, "TestDataLoaderDeviceTypeCPU": 0.0026666666666666666, "TestDataLoaderPersistentWorkers": 56.99066666666667, "TestDatasetRandomSplit": 0.05066666666666667, "TestDictDataLoader": 0.06433333333333334, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004, "TestSetAffinity": 0.083, "TestStackDataset": 0.037666666666666675, "TestStringDataLoader": 0.0006666666666666666, "TestTensorDataset": 0.029333333333333336}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.008333333333333333, "TestDataChunk": 0.006666666666666667, "TestDataFramesPipes": 0.004, "TestFunctionalIterDataPipe": 5.253333333333332, "TestFunctionalMapDataPipe": 0.05100000000000001, "TestGraph": 0.015666666666666666, "TestIterDataPipeCountSampleYielded": 0.012000000000000002, "TestIterDataPipeGraphFastForward": 0.049999999999999996, "TestIterDataPipeSingletonConstraint": 0.024999999999999998, "TestIterableDataPipeBasic": 0.027000000000000007, "TestSerialization": 7.135666666666666, "TestSharding": 0.27, "TestStreamWrapper": 0.01966666666666667, "TestTyping": 0.006000000000000001}, "test_decomp": {"DecompOneOffTestsCPU": 0.037333333333333336, "HasDecompTest": 0.299, "TestDecompCPU": 255.5863333333341}, "test_deploy": {"TestFreezer": 0.012333333333333335}, "test_dispatch": {"TestDispatch": 24.798999999999996, "TestPythonDispatcher": 0.01}, "test_dlpack": {"TestTorchDlPackCPU": 0.2243333333333335}, "test_dynamic_shapes": {"TestDimConstraints": 1.6773333333333333, "TestFloorDiv": 0.013999999999999999, "TestGuardsExpressions": 0.025333333333333333, "TestPySymInt": 1.118333333333333, "TestSymNumberMagicMethods": 1.7193333333333296}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 2.3209999999999984, "TestExpandedWeightHelperFunctionCPU": 0.018000000000000002, "TestExpandedWeightModuleCPU": 6.092666666666666}, "test_fake_tensor": {"FakeTensorConstHandling": 0.048000000000000015, "FakeTensorConverterTest": 0.022000000000000002, "FakeTensorDispatchCache": 0.058666666666666666, "FakeTensorOpInfoTestCPU": 0.107, "FakeTensorOperatorInvariants": 0.271, "FakeTensorPropTest": 0.06, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.6973333333333335, "PropagateRealTensorsFakeTensorConstHandling": 0.08166666666666668, "PropagateRealTensorsFakeTensorConverterTest": 0.02066666666666667, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.08666666666666667, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.15800000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.04133333333333333, "PropagateRealTensorsFakeTensorTest": 0.19700000000000004}, "test_flop_counter": {"TestFlopCounter": 0.6113333333333334}, "test_foreach": {"TestForeachCPU": 70.67266666666703}, "test_function_schema": {"TestFunctionSchema": 0.317}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 36.18800000000001}, "test_functional_optim": {"TestFunctionalOptimParity": 0.233}, "test_functionalization": {"TestCrossRefFunctionalization": 1.9966666666666661, "TestFunctionalization": 2.492999999999999}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.026333333333333334}, "test_futures": {"TestFuture": 0.6886666666666668}, "test_fx": {"AnnotationsTest": 0.012000000000000004, "TestCSEPass": 0.21700000000000005, "TestCommonPass": 0.05499999999999999, "TestConstFold": 0.134, "TestConstParamShapeInControlFlow": 0.041, "TestDCE": 0.025666666666666667, "TestFX": 2.691666666666664, "TestFXAPIBackwardCompatibility": 0.024666666666666667, "TestFunctionalTracing": 0.3093333333333335, "TestMatcher": 0.32266666666666666, "TestOperatorSignaturesCPU": 3.36966666666663, "TestPassManager": 0.022333333333333334, "TestSourceMatcher": 1.1693333333333333, "TestSubgraphRewriter": 0.37833333333333347, "TestVisionTracing": 217.7826666666667, "TypeCheckerTest": 1.464999999999998}, "test_fx_experimental": {"TestFXExperimental": 17.347, "TestNormalizeOperatorsCPU": 54.92366666666671, "TestTranslationValidation": 0.17600000000000002}, "test_fx_passes": {"TestFXGraphPasses": 0.4843333333333335, "TestFXMatcherUtils": 0.08233333333333336}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.20800000000000005}, "test_import_stats": {"TestImportTime": 3.357666666666667}, "test_indexing": {"NumpyTestsCPU": 0.04400000000000001, "TestIndexingCPU": 2.0279999999999974}, "test_itt": {"TestItt": 0.014666666666666666}, "test_jit": {"TestAliasAnalysis": 0.285, "TestAsync": 0.4440000000000001, "TestAtenPow": 0.009, "TestAutodiffJit": 0.10499999999999998, "TestAutodiffSubgraphSlicing": 0.3213333333333334, "TestAwait": 0.4190000000000002, "TestBackends": 0.649, "TestBackendsWithCompiler": 0.14166666666666666, "TestBatchMM": 0.12933333333333333, "TestBuiltins": 0.054, "TestClassType": 2.9676666666666662, "TestComplex": 0.7993333333333336, "TestCustomOperators": 0.04466666666666667, "TestDCE": 0.019666666666666666, "TestDataParallel": 0.0023333333333333335, "TestDataclasses": 4.4479999999999995, "TestDeviceAnalysis": 3.816333333333333, "TestDict": 0.5376666666666668, "TestDtypeAnalysis": 0.18100000000000002, "TestDtypeCustomRulesCPU": 3.6686666666666636, "TestEnum": 0.2196666666666667, "TestFreezing": 2.446666666666666, "TestFrontend": 0.44366666666666665, "TestFrozenOptimizations": 12.933666666666666, "TestFunctionalBlocks": 0.006666666666666667, "TestFunctionalToInplaceActivation": 2.373666666666667, "TestGenerator": 0.068, "TestGetDefaultAttr": 0.016333333333333335, "TestGraphRewritePasses": 0.06733333333333334, "TestHash": 0.07766666666666666, "TestHooks": 0.6020000000000002, "TestIgnorableArgs": 0.01, "TestIgnoreContextManager": 0.03933333333333334, "TestInplaceToFunctionalActivation": 2.4306666666666668, "TestIsinstance": 0.18766666666666673, "TestJit": 5.18666666666666, "TestJitGeneratedModule": 10.824666666666715, "TestJitProfiler": 0.001, "TestJitUtils": 0.018333333333333337, "TestList": 1.6669999999999991, "TestLogging": 0.05100000000000001, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.21300000000000008, "TestMixTracingScripting": 1.3073333333333335, "TestModels": 2.0979999999999994, "TestModuleAPIs": 0.155, "TestModuleContainers": 1.086, "TestModuleInterface": 0.6693333333333334, "TestModules": 0.015333333333333332, "TestNamedTuple": 0.07, "TestNnapiBackend": 12.905999999999999, "TestOpDecompositions": 0.02266666666666667, "TestOptimizeForMobilePreserveDebugInfo": 0.21566666666666667, "TestParametrization": 0.09633333333333333, "TestPeephole": 0.44933333333333353, "TestProducerVersion": 0.002, "TestProfiler": 0.559, "TestPythonBindings": 0.031, "TestPythonBuiltinOP": 0.3166666666666667, "TestPythonIr": 0.021666666666666667, "TestRecursiveScript": 0.6886666666666669, "TestRemoveMutation": 0.1376666666666667, "TestSaveLoad": 0.7083333333333334, "TestSaveLoadFlatbuffer": 0.3963333333333334, "TestSaveLoadForOpVersion": 2.312, "TestScript": 37.4926666666667, "TestScriptDict": 0.02766666666666667, "TestScriptList": 0.8949999999999995, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.18866666666666668, "TestScriptProfile": 0.424, "TestSlice": 0.13200000000000006, "TestSparse": 0.05000000000000001, "TestStringFormatting": 0.12466666666666672, "TestSymbolicShapeAnalysis": 2.016666666666666, "TestTensorBuiltins": 0.07133333333333333, "TestTensorCreationOps": 0.05033333333333334, "TestTensorMethods": 0.011666666666666667, "TestTorchbind": 0.1166666666666667, "TestTracer": 2.9509999999999965, "TestTypeSharing": 0.4316666666666668, "TestTypesAndAnnotation": 0.13733333333333334, "TestTyping": 0.3810000000000002, "TestUnion": 0.48200000000000026, "TestUnsupportedOps": 0.03666666666666667, "TestUpgraders": 0.09600000000000002, "TestWarn": 0.053, "TestWith": 0.305}, "test_jit_autocast": {"TestAutocast": 0.13433333333333333, "TestJitTraceAutocast": 16.820000000000004}, "test_jit_disabled": {"TestJitDisabled": 0.113}, "test_jit_fuser_te": {"TestFuserCommon": 0.21666666666666665, "TestLoopnestRandomizationCPU": 0.045000000000000005, "TestNNCOpInfoCPU": 48.735666666667235, "TestTEFuserDynamic": 137.15533333333335, "TestTEFuserStatic": 57.928}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.08700000000000001, "TestFusionPatternCPU": 6.111333333333334, "TestModel": 3.381, "TestOpCPU": 45.62033333333334}, "test_legacy_vmap": {"TestVmapAPI": 1.2673333333333316, "TestVmapAPILegacy": 0.8206666666666668, "TestVmapBatchedGradientCPU": 0.08700000000000004, "TestVmapBatchedGradientLegacyCPU": 0.10700000000000005, "TestVmapOperators": 1.2956666666666665, "TestVmapOperatorsLegacy": 1.2066666666666668}, "test_license": {"TestLicense": 0.013999999999999999}, "test_linalg": {"TestLinalgCPU": 163.72100000000094}, "test_logging": {"LoggingTest": 2.3766666666666665}, "test_masked": {"TestMaskedCPU": 21.453666666666674}, "test_maskedtensor": {"TestBasicsCPU": 0.17966666666666667, "TestBinary": 0.37233333333333357, "TestOperatorsCPU": 7.520333333333313, "TestReductions": 0.09633333333333334, "TestUnary": 0.3603333333333336}, "test_meta": {"TestMetaCPU": 176.9696666666213, "TestMetaConverter": 0.05333333333333335}, "test_mkl_verbose": {"TestMKLVerbose": 3.9716666666666662}, "test_mkldnn": {"TestMkldnnCPU": 117.02299999999998}, "test_mkldnn_fusion": {"TestMkldnnFusion": 62.35999999999999}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.641}, "test_mobile_optimizer": {"TestOptimizer": 2.7449999999999997}, "test_model_dump": {"TestModelDump": 1.2089999999999999}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.014333333333333332}, "test_module_init": {"TestModuleInitCPU": 2.0139999999999927}, "test_module_tracker": {"TestModuleTracker": 0.024000000000000004}, "test_modules": {"TestModuleCPU": 539.1729999999843}, "test_monitor": {"TestMonitor": 0.030333333333333334, "TestMonitorTensorboard": 0.7733333333333333}, "test_multiprocessing": {"TestMultiprocessing": 44.64666666666667}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.4126666666666667, "SpawnTest": 24.841000000000005}, "test_namedtensor": {"TestNamedTensor": 0.3953333333333335}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.051}, "test_native_functions": {"TestNativeFunctions": 0.14}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.2110000000000001}, "test_nestedtensor": {"TestNestedTensor": 0.2090000000000001, "TestNestedTensorAutogradCPU": 1.082, "TestNestedTensorDeviceTypeCPU": 0.9516666666666662, "TestNestedTensorSubclassCPU": 17.476333333333347}, "test_nn": {"TestAddRelu": 0.0033333333333333335, "TestConstantPadNd": 0.0030000000000000005, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.2936666666666667, "TestFusionUtils": 0.004, "TestNN": 34.368999999999964, "TestNNDeviceTypeCPU": 112.86100000000035, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.004666666666666667}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.2533333333333334}, "test_openmp": {"TestOpenMP_ParallelFor": 6.233333333333333}, "test_ops": {"TestCommonCPU": 1461.4399999999932, "TestCompositeComplianceCPU": 767.776333333329, "TestFakeTensorCPU": 289.4940000000004, "TestMathBitsCPU": 55.5260000000001, "TestRefsOpsInfoCPU": 2.164999999999999, "TestSelfKwarg": 0.02366666666666667, "TestTagsCPU": 14.285666666666634}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 704.1233333333294}, "test_ops_gradients": {"TestBwdGradientsCPU": 1227.891666666665}, "test_ops_jit": {"TestJitCPU": 1066.9666666666649}, "test_optim": {"TestDifferentiableOptimizer": 0.19833333333333333, "TestLRScheduler": 0.9749999999999998, "TestOptim": 68.226, "TestOptimRenewedCPU": 47.86466666666669, "TestSWAUtils": 0.2146666666666667}, "test_out_dtype_op": {"TestOutDtypeOp": 0.337}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.0016666666666666668, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.021333333333333333, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.006000000000000001, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.002, "TestResolveName": 0.08466666666666667, "TestTorchFunctionMode": 0.0, "TestTorchFunctionOverride": 1.4733333333332839, "TestTorchFunctionWarning": 0.011666666666666667, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.04866666666666667, "ModelTest": 0.0013333333333333333, "TestAnalyze": 0.017333333333333336, "TestDependencyAPI": 0.07433333333333335, "TestDependencyHooks": 0.010666666666666666, "TestDiGraph": 0.024000000000000007, "TestGlobGroup": 0.02800000000000001, "TestImporter": 0.013999999999999999, "TestLoadBCPackages": 0.09566666666666666, "TestMangling": 0.022000000000000002, "TestMisc": 0.20633333333333337, "TestPackageFX": 0.10133333333333333, "TestPackageScript": 2.023333333333333, "TestRepackage": 0.008666666666666668, "TestResources": 0.013666666666666667, "TestSaveLoad": 0.068}, "test_per_overload_api": {"TestPerOverloadAPI": 0.02033333333333333}, "test_prims": {"TestDecompCPU": 0.056333333333333326, "TestPrimsBasic": 0.014333333333333335, "TestPrimsCPU": 0.06866666666666667, "TestRefsCPU": 0.010000000000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.12433333333333335, "TestGenericProxyTensorFake": 2.273999999999999, "TestGenericProxyTensorReal": 2.689666666666666, "TestGenericProxyTensorSymbolic": 18.750000000000004, "TestProxyTensorOpInfoCPU": 723.6346666666685, "TestRealProxyTensor": 0.014666666666666666, "TestSymbolicTracing": 3.7520000000000002}, "test_pruning_op": {"PruningOpTest": 0.3516666666666666}, "test_public_bindings": {"TestPublicBindings": 5.301333333333333}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006000000000000001, "TestPythonDispatch": 0.19566666666666677, "TestPythonDispatcher": 0.006000000000000001, "TestPythonRegistration": 0.19133333333333336, "TestWrapperSubclassAliasingCPU": 0.12800000000000006}, "test_pytree": {"TestCxxPytree": 0.013666666666666672, "TestGenericPytree": 0.12566666666666673, "TestPythonPytree": 0.0746666666666667}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.020000000000000004, "TestAOMigrationNNQuantized": 0.06100000000000002, "TestAOMigrationQuantization": 0.02466666666666667, "TestAOMigrationQuantizationFx": 0.023000000000000003, "TestBackendConfig": 0.061000000000000006, "TestBiasCorrectionEager": 2.0336666666666665, "TestBits": 0.005, "TestBitsCPU": 0.06466666666666666, "TestComparatorOps": 1.8239999999999998, "TestDeprecatedJitQuantized": 4.258333333333333, "TestDistributed": 0.031, "TestDuplicateDQPass": 3.961, "TestDynamicQuantizedModule": 65.87266666666666, "TestDynamicQuantizedOps": 30.417666666666662, "TestEqualizeEager": 0.5956666666666667, "TestEqualizeFx": 5.351333333333333, "TestFXGraphMatcher": 1.9573333333333334, "TestFXGraphMatcherModels": 10.593000000000002, "TestFXNumericSuiteCoreAPIs": 30.77133333333333, "TestFXNumericSuiteCoreAPIsModels": 43.14033333333333, "TestFXNumericSuiteNShadows": 45.27700000000001, "TestFakeQuantize": 0.5573333333333333, "TestFakeQuantizeOps": 2.796333333333333, "TestFloat8DtypeCPU": 0.10133333333333337, "TestFloat8DtypeCPUOnlyCPU": 0.7439999999999999, "TestFuseEager": 3.5986666666666665, "TestFuseFx": 2.414666666666666, "TestFusedObsFakeQuant": 0.2810000000000001, "TestFusedObsFakeQuantModule": 0.3136666666666667, "TestFusionPasses": 0.022666666666666665, "TestFxDetectInputWeightEqualization": 0.23233333333333336, "TestFxDetectOutliers": 0.2816666666666667, "TestFxModelReportClass": 0.566, "TestFxModelReportDetectDynamicStatic": 0.06833333333333334, "TestFxModelReportDetector": 0.20033333333333334, "TestFxModelReportObserver": 0.2316666666666667, "TestFxModelReportVisualizer": 0.22433333333333336, "TestGenerateNumericDebugHandle": 1.257, "TestGraphUtils": 1.4363333333333335, "TestHistogramObserver": 46.27366666666668, "TestMetaDataPorting": 9.081999999999999, "TestModelNumericsEager": 1.2086666666666666, "TestNumericSuiteEager": 12.290999999999999, "TestObserver": 4.264, "TestPT2ERepresentation": 32.596, "TestPadding": 23.179, "TestQNNPackOps": 7.165333333333334, "TestQuantizationDocs": 0.005333333333333333, "TestQuantizeDynamicJitOps": 2.6333333333333333, "TestQuantizeDynamicJitPasses": 5.662333333333334, "TestQuantizeEagerOps": 1.889333333333333, "TestQuantizeEagerPTQDynamic": 8.663333333333334, "TestQuantizeEagerPTQStatic": 39.22133333333334, "TestQuantizeEagerQAT": 13.297666666666666, "TestQuantizeEagerQATNumerics": 2.715333333333333, "TestQuantizeFx": 50.439999999999976, "TestQuantizeFxModels": 8.687666666666667, "TestQuantizeFxOps": 135.54, "TestQuantizeJit": 22.278333333333336, "TestQuantizeJitOps": 228.23833333333334, "TestQuantizeJitPasses": 6.2909999999999995, "TestQuantizePT2E": 51.050000000000004, "TestQuantizePT2EQAT": 38.851000000000006, "TestQuantizePT2EQATModels": 29.041666666666668, "TestQuantizePT2EQAT_ConvBn1d": 308.566, "TestQuantizePT2EQAT_ConvBn2d": 309.556, "TestQuantizePT2EX86Inductor": 125.74500000000002, "TestQuantizedConv": 68.57033333333335, "TestQuantizedEmbeddingOps": 1.7620000000000002, "TestQuantizedFunctionalOps": 4.163333333333333, "TestQuantizedLinear": 23.16633333333333, "TestQuantizedOps": 155.9283333333333, "TestQuantizedTensor": 2.896666666666666, "TestRecordHistogramObserver": 0.05533333333333334, "TestReferenceQuantizedModule": 0.108, "TestSerialization": 2.4613333333333336, "TestStaticQuantizedModule": 131.84966666666668, "TestSubgraphRewriter": 1.3399999999999999, "TestUtils": 0.030000000000000002, "TestXNNPACKQuantizer": 55.99133333333333, "TestXNNPACKQuantizerModels": 3.252333333333333}, "test_reductions": {"TestReductionsCPU": 197.76533333332122}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 6.734000000000001}, "test_schema_check": {"TestSchemaCheck": 0.18000000000000008, "TestSchemaCheckModeOpInfoCPU": 191.8089999999961}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.4666666666666668}, "test_serialization": {"TestBothSerializationCPU": 0.21866666666666668, "TestOldSerialization": 26.502, "TestSerialization": 8.839333333333329, "TestSubclassSerialization": 0.036}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.014333333333333332}, "test_shape_ops": {"TestShapeOpsCPU": 1.2926666666666653}, "test_show_pickle": {"TestShowPickle": 0.019}, "test_sort_and_select": {"TestSortAndSelectCPU": 2.1326666666666636}, "test_sparse": {"TestSparseAnyCPU": 392.88633333333263, "TestSparseCPU": 483.3476666666668, "TestSparseLegacyAndDeprecation": 0.06466666666666666, "TestSparseMaskedReductionsCPU": 1.528333333333334, "TestSparseMeta": 4.055, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 11.037999999999954}, "test_sparse_csr": {"TestSparseCSRCPU": 95.06166666666725, "TestSparseCSRSampler": 0.7000000000000001, "TestSparseCompressedCPU": 113.58066666666639, "TestSparseCompressedTritonKernelsCPU": 0.005333333333333333}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 6.088999999999989, "TestFFTDocExamplesCPU": 0.11833333333333336}, "test_stateless": {"TestPythonOptimizeMode": 3.4163333333333337, "TestStatelessDeprecation": 1.4583333333333333, "TestStatelessFunctionalAPI": 0.24433333333333343}, "test_subclass": {"TestSubclass": 0.21733333333333346}, "test_sympy_utils": {"TestNumbers": 0.035333333333333335, "TestSingletonInt": 0.006999999999999999, "TestSympyInterp": 8.684333333333333, "TestSympySolve": 0.24333333333333337, "TestValueRanges": 4.656666666666665}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.5623333333333337, "TestBufferProtocolCPU": 0.3710000000000003, "TestLikeTensorCreationCPU": 0.009000000000000001, "TestRandomTensorCreationCPU": 2.806999999999999, "TestTensorCreationCPU": 23.80466666666672}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0026666666666666666, "TestTensorBoardFigure": 0.0013333333333333333, "TestTensorBoardNumpy": 0.0033333333333333335, "TestTensorBoardPyTorchNumpy": 0.02033333333333334, "TestTensorBoardPytorchGraph": 0.01, "TestTensorBoardSummary": 0.03600000000000001, "TestTensorBoardSummaryWriter": 0.004, "TestTensorBoardUtils": 0.005333333333333333, "TestTensorBoardWriter": 0.0013333333333333333, "TestTensorProtoSummary": 0.011999999999999999}, "test_tensorexpr": {"TestTensorExprFuser": 46.45433333333333}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.008, "TestTensorExprPyBind": 0.6203333333333334}, "test_testing": {"TestAssertClose": 0.14666666666666672, "TestAssertCloseContainer": 0.008666666666666668, "TestAssertCloseErrorMessage": 0.08133333333333335, "TestAssertCloseQuantized": 0.014333333333333332, "TestAssertCloseSparseBSC": 0.022333333333333334, "TestAssertCloseSparseBSR": 0.022000000000000002, "TestAssertCloseSparseCOO": 0.029333333333333336, "TestAssertCloseSparseCSC": 0.023333333333333334, "TestAssertCloseSparseCSR": 0.025000000000000005, "TestFrameworkUtils": 11.857666666666667, "TestImports": 12.665666666666667, "TestMakeTensorCPU": 1.6449999999999954, "TestOpInfoSampleFunctionsCPU": 7.734333333333301, "TestOpInfos": 0.004, "TestTestParametrization": 0.04466666666666669, "TestTestParametrizationDeviceTypeCPU": 4.091333333333331, "TestTestingCPU": 0.18533333333333338}, "test_torch": {"TestBasicVitalSigns": 0.05233333333333334, "TestTorch": 3.819999999999991, "TestTorchDeviceTypeCPU": 17.05466666666666, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 22.844666666666665, "TestAttnMasksCPU": 18.003, "TestSDPACPU": 280.30966666666563, "TestSDPAFailureModesCPU": 0.03633333333333334, "TestTransformersCPU": 6.046666666666667}, "test_type_hints": {"TestTypeHints": 0.013666666666666667}, "test_type_info": {"TestDTypeInfo": 0.026333333333333337}, "test_type_promotion": {"TestTypePromotionCPU": 3.7876666666666616}, "test_typing": {"TestTyping": 73.20100000000002}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 456.16466666655225}, "test_utils": {"TestAssert": 0.05266666666666667, "TestBottleneck": 8.645999999999999, "TestCheckpoint": 0.08600000000000001, "TestCollectEnv": 0.983, "TestCppExtensionUtils": 0.08533333333333333, "TestDataLoaderUtils": 0.26733333333333337, "TestDeviceUtilsCPU": 35.501333333333726, "TestExtensionUtils": 0.004, "TestHipify": 0.001, "TestHipifyTrie": 0.0036666666666666666, "TestONNXUtils": 0.0036666666666666666, "TestRenderUtils": 0.011000000000000001, "TestStandaloneCPPJIT": 1.6523333333333332, "TestTraceback": 0.008666666666666668}, "test_view_ops": {"TestOldViewOpsCPU": 16.247333333333327, "TestViewOpsCPU": 1.0223333333333324, "TestViewOpsLAZY": 1.0696666666666668}, "test_vulkan": {"TestVulkanRewritePass": 0.0006666666666666666}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.01933333333333333, "WeakKeyDictionaryTestCase": 0.029, "WeakTest": 4.702}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 31.927333333333333, "TestXNNPACKOps": 5.092333333333333, "TestXNNPACKRewritePass": 2.047, "TestXNNPACKSerDes": 5.583333333333333}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.19033333333333344}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.10366666666666673, "TestClassGetItem": 0.0003333333333333333, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0023333333333333335, "TestMisc": 0.004333333333333334, "TestPickling": 0.19033333333333335, "TestPromotion": 0.0023333333333333335}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 14.885, "TestEinsumPath": 0.0, "TestMisc": 0.006000000000000001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0003333333333333333, "TestFinfo": 0.037000000000000005, "TestHalf": 0.0003333333333333333, "TestIinfo": 0.018, "TestMisc": 0.002, "TestPythonFloat": 0.0006666666666666666, "TestRepr": 0.0030000000000000005, "TestSingle": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0026666666666666666, "TestBooleanIndexing": 0.006333333333333333, "TestBroadcastedAssignments": 0.018000000000000002, "TestFancyIndexingCast": 0.0036666666666666666, "TestFloatNonIntegerArgument": 0.008, "TestIndexing": 0.17066666666666674, "TestMultiIndexingAutomated": 0.008666666666666668, "TestMultipleEllipsisError": 0.0016666666666666668, "TestNonIntegerArrayLike": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.04800000000000001, "TestArgmax": 1.0803333333333336, "TestArgmaxArgminCommon": 1.6589999999999971, "TestArgmin": 1.1543333333333337, "TestArrayAttributeDeletion": 0.007, "TestArrayConstruction": 0.05833333333333335, "TestArrayCreationCopyArgument": 0.06966666666666671, "TestArrayInterface": 0.027, "TestAssignment": 0.012000000000000002, "TestAttributes": 0.025000000000000005, "TestBinop": 0.020666666666666667, "TestBool": 28.412000000000003, "TestCequenceMethods": 0.002, "TestChoose": 0.019333333333333334, "TestClip": 0.010333333333333335, "TestCompress": 0.004666666666666667, "TestConversion": 0.04800000000000001, "TestCreation": 0.001, "TestDelMisc": 0.002, "TestDot": 0.06566666666666669, "TestDtypedescr": 0.002, "TestFancyIndexing": 0.035333333333333335, "TestFlag": 0.01466666666666667, "TestFormat": 0.007, "TestFromBuffer": 0.015333333333333338, "TestHash": 0.016666666666666666, "TestHashing": 0.009333333333333332, "TestIO": 0.005, "TestInner": 0.25466666666666665, "TestLexsort": 0.026000000000000006, "TestMatmul": 0.5246666666666667, "TestMatmulOperator": 0.35600000000000004, "TestMethods": 1.7543333333333333, "TestMinMax": 0.01, "TestMinScalarType": 0.007666666666666666, "TestNewaxis": 0.0036666666666666666, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.012000000000000002, "TestRepeat": 0.01833333333333333, "TestResize": 0.04900000000000001, "TestRichcompareScalar": 0.0006666666666666666, "TestScalarIndexing": 0.023333333333333334, "TestSizeOf": 0.014666666666666668, "TestSortFloatMisc": 0.21966666666666668, "TestStats": 0.2703333333333333, "TestSubscripting": 0.0016666666666666668, "TestTake": 0.035, "TestVdot": 0.042, "TestViewDtype": 0.008333333333333333, "TestWarnings": 0.002, "TestWhere": 0.6070000000000001, "TestWritebackIfCopy": 0.04066666666666668}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.025333333333333336, "TestArgwhere": 0.028, "TestArrayComparisons": 0.016999999999999998, "TestBaseRepr": 0.006666666666666667, "TestBinaryRepr": 0.012666666666666668, "TestBoolArray": 2.0416666666666665, "TestBoolCmp": 0.22633333333333336, "TestBoolScalar": 0.011666666666666667, "TestBroadcast": 0.12266666666666666, "TestClip": 0.2613333333333335, "TestConvolve": 0.017333333333333336, "TestCorrelate": 0.028333333333333335, "TestCreationFuncs": 1.2886666666666666, "TestCross": 0.07933333333333334, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.011666666666666667, "TestFromiter": 0.0013333333333333333, "TestIndex": 0.007666666666666666, "TestIndices": 0.04966666666666667, "TestIsclose": 0.111, "TestIsscalar": 0.0026666666666666666, "TestLikeFuncs": 0.0006666666666666666, "TestMoveaxis": 0.010666666666666666, "TestNonarrayArgs": 0.11766666666666671, "TestNonzeroAndCountNonzero": 0.35766666666666674, "TestOuterMisc": 0.007, "TestRequire": 0.006333333333333334, "TestResize": 0.03833333333333333, "TestRoll": 0.032, "TestRollaxis": 0.005333333333333333, "TestSeterr": 0.008, "TestStdVar": 0.034, "TestStdVarComplex": 0.015333333333333332, "TestStringFunction": 0.002, "TestTensordot": 0.016666666666666666, "TestTypes": 0.02}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0016666666666666668, "TestCommonType": 0.026333333333333337, "TestDocStrings": 0.0, "TestIsSubDType": 0.01, "TestScalarTypeNames": 0.04300000000000002}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.10500000000000008, "TestFromInt": 0.023000000000000003, "TestFromString": 0.025666666666666667}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0006666666666666666, "TestBitCount": 0.0003333333333333333, "TestClassGetItem": 0.0003333333333333333, "TestClassGetitemMisc": 0.0023333333333333335, "TestIsInteger": 0.004333333333333333}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.10699999999999998, "TestBaseMath": 10.046666666666667, "TestBitShifts": 0.09933333333333334, "TestComplexDivision": 0.07166666666666667, "TestConversion": 0.08333333333333333, "TestHash": 0.0, "TestModulus": 1.199, "TestMultiply": 0.0006666666666666666, "TestNegative": 0.020666666666666667, "TestPower": 0.14233333333333334, "TestRepr": 0.002, "TestScalarOpsMisc": 0.05500000000000003, "TestScalarSubclassingMisc": 0.016666666666666673, "TestSubtract": 0.019666666666666666, "TestTypes": 13.618}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.05200000000000001, "TestAtleast2d": 0.01966666666666667, "TestAtleast3d": 0.016, "TestBlock": 0.054333333333333345, "TestConcatenate": 0.19066666666666676, "TestHstack": 0.024000000000000007, "TestStackMisc": 0.12100000000000005, "TestVstack": 0.027000000000000007}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.010666666666666666, "TestFFTShift": 5.4943333333333335, "TestIRFFTN": 0.007333333333333334, "TestRFFTFreq": 0.010666666666666666}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 4.022666666666665, "TestFFTShift": 0.02766666666666667, "TestFFTThreadSafe": 1.4603333333333335}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.09100000000000001}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.007, "TestUnique": 0.21633333333333338}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.008, "TestAmax": 0.007333333333333333, "TestAmin": 0.006333333333333333, "TestAngle": 0.009666666666666667, "TestAny": 0.007666666666666666, "TestAverage": 0.03866666666666667, "TestBincount": 0.05966666666666667, "TestCheckFinite": 0.006666666666666667, "TestCopy": 0.009000000000000001, "TestCorrCoef": 0.04033333333333334, "TestCov": 0.07666666666666667, "TestCumprod": 0.03, "TestCumsum": 0.04033333333333334, "TestDelete": 0.02266666666666667, "TestDiff": 0.11666666666666665, "TestDigitize": 0.022000000000000006, "TestExtins": 0.007666666666666666, "TestFilterwindows": 0.7036666666666672, "TestFlip": 0.05000000000000001, "TestGradient": 0.27666666666666667, "TestInsert": 0.009666666666666665, "TestInterp": 0.07733333333333337, "TestKaiser": 0.011000000000000001, "TestMedian": 0.1406666666666667, "TestMeshgrid": 0.07033333333333334, "TestMsort": 0.0, "TestPercentile": 0.19366666666666674, "TestPiecewise": 0.013333333333333334, "TestProd": 0.028999999999999998, "TestPtp": 0.010333333333333333, "TestQuantile": 0.08133333333333335, "TestRot90": 0.08466666666666667, "TestSelect": 0.011666666666666667, "TestSinc": 0.013333333333333334, "TestSortComplex": 0.012000000000000002, "TestTrapz": 0.007, "TestTrimZeros": 0.014, "TestUnique": 0.009000000000000001, "Test_I0": 0.014666666666666666}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.15600000000000003, "TestHistogramOptimBinNums": 0.04066666666666669, "TestHistogramdd": 0.17800000000000002}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0013333333333333333, "TestConcatenator": 0.008, "TestDiagIndices": 0.005, "TestDiagIndicesFrom": 0.008, "TestFillDiagonal": 0.025666666666666667, "TestGrid": 0.010666666666666666, "TestIndexExpression": 0.011666666666666667, "TestIx_": 0.006666666666666667, "TestNdIndex": 0.0013333333333333333, "TestNdenumerate": 0.0013333333333333333, "TestRavelUnravelIndex": 0.03566666666666667}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.009666666666666669, "TestApplyOverAxes": 0.0016666666666666668, "TestArraySplit": 0.1406666666666667, "TestColumnStack": 0.011333333333333334, "TestDsplit": 0.011666666666666667, "TestDstack": 0.018000000000000002, "TestExpandDims": 0.006000000000000001, "TestHsplit": 0.014333333333333335, "TestKron": 0.016666666666666666, "TestMayShareMemory": 0.002, "TestPutAlongAxis": 0.008333333333333333, "TestSplit": 0.007666666666666668, "TestSqueeze": 0.03966666666666667, "TestTakeAlongAxis": 0.04433333333333334, "TestTile": 0.10066666666666668, "TestVsplit": 0.01}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.02566666666666667, "TestEye": 0.05133333333333334, "TestFliplr": 0.004666666666666667, "TestFlipud": 0.005, "TestHistogram2d": 0.034333333333333334, "TestTri": 0.08700000000000001, "TestTrilIndicesFrom": 0.0016666666666666668, "TestTriuIndices": 0.0026666666666666666, "TestTriuIndicesFrom": 0.0013333333333333333, "TestVander": 0.018666666666666665}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.005333333333333333, "TestCommonType": 0.042, "TestImag": 0.024000000000000004, "TestIscomplex": 0.012666666666666666, "TestIscomplexobj": 0.009333333333333332, "TestIsfinite": 0.03133333333333333, "TestIsinf": 0.02, "TestIsnan": 0.029666666666666664, "TestIsneginf": 0.0033333333333333335, "TestIsposinf": 0.005333333333333333, "TestIsreal": 0.012333333333333333, "TestIsrealobj": 0.0023333333333333335, "TestIsscalar": 0.006000000000000001, "TestMintypecode": 0.007666666666666666, "TestNanToNum": 0.022333333333333334, "TestReal": 0.02533333333333333, "TestRealIfClose": 0.008}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.18700000000000006, "TestCond": 0.25266666666666665, "TestDet": 0.157, "TestEig": 0.054, "TestEigh": 0.026333333333333337, "TestEighCases": 0.0, "TestEigvals": 0.06800000000000002, "TestEigvalsh": 0.027000000000000007, "TestEigvalshCases": 0.0, "TestInv": 0.056, "TestLstsq": 0.23700000000000002, "TestMatrixRank": 0.37233333333333335, "TestMisc": 0.05200000000000001, "TestMisc2": 0.004666666666666667, "TestMultiDot": 0.069, "TestNormDouble": 0.733, "TestNormInt64": 0.781, "TestNormSingle": 0.8246666666666668, "TestNorm_NonSystematic": 0.008333333333333333, "TestPinv": 0.11766666666666666, "TestPinvHermitian": 0.032, "TestQR": 6.378333333333335, "TestSVD": 0.054666666666666676, "TestSVDHermitian": 0.10933333333333335, "TestSolve": 0.08, "TestTensorinv": 0.029333333333333333, "TestTensorsolve": 0.017666666666666667}, "torch_np/test_basic": {"TestArrayToSequence": 0.006333333333333334, "TestCopyTo": 0.007, "TestCtorNested": 0.004, "TestDefaultDtype": 0.008, "TestDivmod": 0.018666666666666668, "TestExport": 0.0023333333333333335, "TestMisc": 0.001, "TestNormalizations": 0.005333333333333333, "TestOneArr": 0.30233333333333356, "TestOneArrAndAxesTuple": 0.009333333333333334, "TestOneArrAndAxis": 0.16166666666666676, "TestOneArrAndShape": 0.0023333333333333335, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.024666666666666667, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007666666666666666, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.0016666666666666668}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.13333333333333341}, "torch_np/test_dtype": {"TestConvertDType": 0.07433333333333338}, "torch_np/test_function_base": {"TestAppend": 0.025666666666666667}, "torch_np/test_ndarray_methods": {"TestAmax": 0.011000000000000001, "TestAmin": 0.011000000000000001, "TestArgmax": 1.4486666666666668, "TestArgmaxArgminCommon": 1.7076666666666647, "TestArgmin": 1.774333333333333, "TestContains": 0.0026666666666666666, "TestIndexing": 0.03133333333333333, "TestIter": 0.009666666666666665, "TestNoExtraMethods": 0.013999999999999999, "TestNonzero": 0.25133333333333335, "TestRavel": 0.009666666666666667, "TestReshape": 0.011000000000000001, "TestTranspose": 0.02266666666666667}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 3.3499999999998793, "TestNEP50Table": 0.10766666666666673}, "torch_np/test_random": {"TestChoice": 0.01, "TestNumpyGlobal": 0.0033333333333333335, "TestScalarReturn": 0.04966666666666669, "TestShuffle": 0.011000000000000003}, "torch_np/test_reductions": {"TestAll": 0.013333333333333334, "TestAny": 0.014666666666666666, "TestFlatnonzero": 0.13333333333333333, "TestGenericCumSumProd": 0.021666666666666667, "TestGenericReductions": 2.304666666666627, "TestMean": 0.029666666666666664, "TestSum": 0.418}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.04200000000000001, "TestIsScalar": 0.02733333333333335}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.8353333333333333, "TestNdarrayDunderVsUfunc": 0.29300000000000015, "TestUfuncDtypeKwd": 0.007666666666666668, "TestUnaryUfuncs": 0.061000000000000026}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.1400000000000001}}, "default": {"backends/xeon/test_launch": {"TestTorchrun": 1.7436666666666667}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.1376666666666668}, "distributions/test_constraints": {"test_constraints": 0.08700000000000006}, "distributions/test_distributions": {"TestAgainstScipy": 0.9780000000000001, "TestConstraints": 0.121, "TestDistributionShapes": 0.12233333333333339, "TestDistributions": 16.62833333333333, "TestFunctors": 0.009, "TestJit": 20.59766666666667, "TestKL": 2.7379999999999995, "TestLazyLogitsInitialization": 0.010666666666666666, "TestNumericalStability": 0.061666666666666675, "TestRsample": 0.612, "TestValidation": 0.2973333333333334}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.35133333333333333}, "dynamo/test_after_aot": {"TestAfterAot": 5.8500000000000005}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.319}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 13.871}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.24933333333333332, "AOTAutogradCacheTests": 18.08966666666667}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.947333333333333}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.03566666666666667, "TestCustomBackendAPI": 1.8319999999999999, "TestExplainWithBackend": 10.253666666666666, "TestOptimizations": 1.4986666666666661}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 12.418999999999999}, "dynamo/test_base_output": {"TestBaseOutput": 0.0026666666666666666}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 5.65925}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 6.199000000000001, "BytecodeTests": 0.4043333333333334}, "dynamo/test_compile": {"InPlaceCompilationTests": 7.538, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.47233333333333344}, "dynamo/test_config": {"ConfigTests": 0.2863333333333334}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.6060000000000001, "CppGuardManagerFuncTorchHigherOrderOpTests": 11.67075, "CppGuardManagerFunctionTests": 27.339000000000013, "CppGuardManagerHigherOrderOpTests": 10.13375, "CppGuardManagerMiscTests": 62.48275000000005, "CppGuardManagerReproTests": 63.167500000000004}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.6719999999999995}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.037}, "dynamo/test_decorators": {"DecoratorTests": 7.450333333333333}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0006666666666666666, "TestDeviceGuard": 0.015}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 239.98633333333328, "DynamicShapesCtxManagerTests": 4.636333333333333, "DynamicShapesExportTests": 29.127333333333343, "DynamicShapesFuncTorchHigherOrderOpTests": 99.349, "DynamicShapesFunctionTests": 73.28433333333332, "DynamicShapesHigherOrderOpTests": 16.182999999999996, "DynamicShapesMiscTests": 84.08433333333342, "DynamicShapesNNModuleTests": 6.787333333333333, "DynamicShapesReproTests": 100.2666666666667, "DynamicShapesSubGraphTests": 10.037333333333335, "DynamicShapesTestSDPA": 0.32866666666666666}, "dynamo/test_exc": {"ExcTests": 1.6673333333333333}, "dynamo/test_exceptions": {"ExceptionTests": 0.26433333333333336}, "dynamo/test_export": {"ExportTests": 17.884666666666664}, "dynamo/test_export_mutations": {"MutationExportTests": 0.2963333333333334}, "dynamo/test_frame_init": {"FrameInitTests": 0.015333333333333332}, "dynamo/test_functions": {"DefaultsTests": 0.7986666666666666, "FunctionTests": 17.365000000000006}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.9786666666666667}, "dynamo/test_global": {"TestGlobals": 0.3153333333333334}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.053333333333333365}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.07733333333333335, "FuncTorchHigherOrderOpTests": 13.225333333333333, "HigherOrderOpTests": 9.369333333333332, "HigherOrderOpVmapGuardTests": 4.579999999999999}, "dynamo/test_hooks": {"HooksTests": 26.399000000000004}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 10.024666666666667, "InlineInbuiltNNModulesExportTests": 19.34866666666666, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 12.196333333333333, "InlineInbuiltNNModulesFunctionTests": 22.26, "InlineInbuiltNNModulesHigherOrderOpTests": 8.015666666666666, "InlineInbuiltNNModulesMiscTests": 59.554666666666755, "InlineInbuiltNNModulesNNModuleTests": 5.9273333333333325}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 8.805}, "dynamo/test_interop": {"InteropTests": 0.4046666666666667}, "dynamo/test_logging": {"LoggingTests": 15.845666666666666}, "dynamo/test_minifier": {"MinifierTests": 1.416333333333333}, "dynamo/test_misc": {"MiscTests": 56.1820000000001, "TestTracer": 0.051}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0026666666666666666}, "dynamo/test_modules": {"NNModuleTests": 3.5919999999999987, "OptimizedModuleTest": 21.680000000000003}, "dynamo/test_nops": {"NopTests": 0.13166666666666668}, "dynamo/test_optimizers": {"End2EndTests": 0.6536666666666667, "OptimizerTests": 1.5826666666666667}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.19133333333333333}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.0086666666666666}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.532}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.6033333333333335}, "dynamo/test_recompiles": {"RecompileTests": 0.7770000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.24533333333333332}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.7140000000000001}, "dynamo/test_repros": {"ReproTests": 58.23700000000002}, "dynamo/test_resume": {"ResumeFunctionTests": 0.1366666666666667}, "dynamo/test_sdpa": {"TestSDPA": 0.19400000000000003}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.27166666666666667}, "dynamo/test_sources": {"SourceTests": 0.19533333333333336}, "dynamo/test_structured_trace": {"StructuredTraceTest": 15.597666666666667}, "dynamo/test_subclasses": {"SubclassTests": 4.736333333333333, "TestNestedTensor": 11.811}, "dynamo/test_subgraphs": {"SubGraphTests": 2.290333333333333}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.19400000000000003, "TraceRuleTests": 0.6283333333333333}, "dynamo/test_triton_kernels": {"KernelTests": 0.006666666666666668, "MutationTests": 0.001, "NoOptimizationKernelTests": 0.0023333333333333335, "no_opt_test_class": 0.005333333333333333}, "dynamo/test_unspec": {"UnspecTests": 13.120666666666667}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.29233333333333333}, "dynamo/test_view": {"ViewTests": 0.4386666666666667}, "export/test_converter": {"TestConverter": 6.3006666666666655}, "export/test_db": {"ExampleTests": 3.280333333333333}, "export/test_experimental": {"TestExperiment": 0.8113333333333334}, "export/test_export": {"TestDynamismExpression": 0.7216666666666667, "TestExport": 29.793666666666667, "TestExportCustomClass": 0.076, "TestOneOffModelExportResult": 1.155}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.6893333333333334, "NonStrictExportTestExport": 28.295999999999996}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.7413333333333334, "PreDispatchExportTestExport": 31.40700000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.017666666666666667}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.5246666666666667}, "export/test_hop": {"TestHOPCPU": 2.786666666666667, "TestHOPGeneric": 0.0030000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.09800000000000002, "TestLiftUnlift": 0.012000000000000002}, "export/test_pass_infra": {"TestPassInfra": 0.6643333333333334}, "export/test_passes": {"TestPasses": 13.072333333333335}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.1343333333333334, "RetraceExportTestExport": 43.833333333333336}, "export/test_safeguard": {"TestSafeguard": 0.6583333333333333}, "export/test_schema": {"TestSchema": 0.05266666666666667}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.252, "SerDesExportPreDispatchTestExport": 23.494333333333326, "SerDesExportTestDynamismExpression": 0.7343333333333333, "SerDesExportTestExport": 30.47966666666666}, "export/test_serialize": {"TestDeserialize": 7.571000000000001, "TestOpVersioning": 0.00475, "TestSaveLoad": 0.274, "TestSchemaVersioning": 0.03, "TestSerialize": 1.0416666666666667, "TestSerializeCustomClass": 0.09166666666666667}, "export/test_sparse": {"TestSparseProp": 75.27199999999995}, "export/test_tools": {"TestExportTools": 0.33899999999999997}, "export/test_torchbind": {"TestCompileTorchbind": 1.3343333333333334, "TestExportTorchbind": 1.8719999999999992, "TestRegisterFakeClass": 0.0033333333333333335}, "export/test_tree_utils": {"TestTreeUtils": 0.013666666666666666}, "export/test_unflatten": {"TestUnflatten": 2.9599999999999995}, "export/test_upgrade": {"TestUpgrade": 0.23050000000000004}, "export/test_verifier": {"TestVerifier": 0.8416666666666667}, "functorch/test_aotdispatch": {"TestAOTAutograd": 12.339666666666668, "TestAOTAutogradWithDynamo": 15.841999999999999, "TestAOTDispatch": 0.5003333333333333, "TestAOTExport": 2.31, "TestAOTModuleSimplified": 0.6396666666666667, "TestEagerFusionModuleInfoCPU": 886.7023333333333, "TestEagerFusionOpInfoCPU": 2210.9340000000016, "TestPartitioning": 1.3070000000000002, "TestPythonKeyCPU": 1.2486666666666668}, "functorch/test_control_flow": {"TestControlFlow": 0.5803333333333334, "TestControlFlowTraced": 112.69833333333332}, "functorch/test_dims": {"TestMin": 13.298333333333334, "TestMinFunctorchOnly": 13.03133333333333}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.11166666666666673, "TestAutogradFunctionVmapAPICPU": 0.024333333333333335, "TestCompileTransformsCPU": 9.642666666666665, "TestComposabilityCPU": 1.6453333333333326, "TestExamplesCorrectnessCPU": 4.862999999999999, "TestFunctionalizeCPU": 0.13266666666666668, "TestGradTransformCPU": 0.48200000000000004, "TestHelpersCPU": 0.010666666666666666, "TestHessianCPU": 0.031, "TestHigherOrderOperatorInteractionCPU": 0.029333333333333333, "TestJacCPU": 0.6186666666666669, "TestJvpCPU": 0.04433333333333334, "TestLinearizeCPU": 0.18100000000000002, "TestMakeFunctional": 0.09766666666666668, "TestSliceArgnums": 0.015666666666666672, "TestVmapJvpInplaceViewCPU": 0.012666666666666666, "TestVmapOfGradCPU": 0.31300000000000006}, "functorch/test_logging": {"TestAOTLogging": 0.057999999999999996}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.27066666666666667, "RandomOpTestCase": 0.068, "ReduceTestCase": 0.07, "TestMemoryEfficientOpAuthoring": 0.0}, "functorch/test_minifier": {"TestMinifier": 0.20000000000000004}, "functorch/test_ops": {"TestOperatorsCPU": 2911.142}, "functorch/test_parsing": {"TestAnonymousAxis": 0.015, "TestParsedExpression": 0.005333333333333333, "TestParsingUtils": 0.005333333333333333, "TestValidateRearrangeExpressions": 0.005333333333333333}, "functorch/test_rearrange": {"TestRearrange": 0.065}, "functorch/test_vmap": {"TestRandomnessCPU": 1.226, "TestTransformFailureCPU": 0.14100000000000001, "TestVmapAPI": 0.31533333333333347, "TestVmapBatchedGradientCPU": 0.1623333333333334, "TestVmapDeviceTypeCPU": 0.026000000000000006, "TestVmapNestedTensorCPU": 0.04166666666666668, "TestVmapOperators": 3.163666666666663, "TestVmapOperatorsOpInfoCPU": 518.7233333333328}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.515333333333246}, "higher_order_ops/test_with_effects": {"TestWithEffects": 8.768}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 8.568333333333333}, "inductor/test_binary_folding": {"FreezingCpuTests": 38.68333333333334}, "inductor/test_codecache": {"TestFxGraphCache": 38.91566666666665, "TestFxGraphCacheHashing": 0.8053333333333335, "TestUtils": 3.420666666666667, "test_codecache": 0.0003333333333333333}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.08466666666666667}, "inductor/test_compile_worker": {"TestCompileWorker": 15.952666666666667}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 219.02700000000056, "TestAutogradWithCompiledAutograd": 291.86633333333367, "TestCompiledAutograd": 180.98600000000002, "TestCustomOpWithCompiledAutograd": 1.2689999999999981}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 532.779, "CompiledOptimizerTests": 223.79766666666686}, "inductor/test_config": {"TestInductorConfig": 5.978666666666666}, "inductor/test_control_flow": {"CondTests": 0.006333333333333334, "WhileLoopTests": 0.0016666666666666668}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 491.56166666666667, "TestCppWrapper": 524.2183333333334}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1481.1956666666665, "TestCppWrapper": 1549.0029999999997}, "inductor/test_cpu_repro": {"CPUReproTests": 718.54}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 1627.9903333333332, "TestSelectAlgorithmDynamicShapesCPU": 1687.640333333333}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.002}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 11.235333333333335}, "inductor/test_debug_trace": {"TestDebugTrace": 3.361}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0006666666666666666}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.98266666666668}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 76.66033333333334}, "inductor/test_extension_backend": {"ExtensionBackendTests": 18.24866666666667}, "inductor/test_flex_attention": {"TestFlexAttention": 0.005666666666666667, "TestTemplatedSDPA": 0.007}, "inductor/test_foreach": {"ForeachTests": 18.55466666666676}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 86.733, "SDPAPatternRewriterCpuTests": 88.40466666666667}, "inductor/test_fx_fusion": {"TestFxFusion": 0.07433333333333335}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.021}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.03766666666666666, "TestGroupBatchFusion": 0.0, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.038666666666666676, "TestIndexingSimplification": 0.37233333333333335}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 57.518}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_metrics": {"TestMetrics": 0.015000000000000003}, "inductor/test_minifier": {"MinifierTests": 25.602000000000004}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 168.38766666666666, "TestPatternMatcher": 620.0606666666667}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.010333333333333335}, "inductor/test_profiler": {"DynamoProfilerTests": 0.0026666666666666666}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 17.201333333333334}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.004}, "inductor/test_torchbind": {"TestTorchbind": 10.205666666666666}, "inductor/test_torchinductor": {"CpuTests": 1476.6749999999993, "SweepInputsCpuTest": 117.52499999999999, "TestFull": 10.417}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1525.3919999999998}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1676.2233333333334, "TestInductorDynamicCPU": 0.02466666666666668}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 26106.449333333367}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 2.0733333333333337}, "inductor/test_triton_kernels": {"KernelTests": 0.031000000000000017, "MutationTests": 0.0026666666666666666, "NoOptimizationKernelTests": 0.008333333333333337, "no_opt_test_class": 0.011000000000000005}, "inductor/test_utils": {"TestUtils": 0.016333333333333335}, "lazy/test_debug_util": {"DebugUtilTest": 0.057333333333333326}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.06333333333333334}, "lazy/test_generator": {"LazyGeneratorTest": 0.09366666666666668}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.4026666666666667}, "lazy/test_step_closures": {"ClosuresTest": 2.01}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.34299999999999997, "TestLazyOpInfoCPU": 8.827666666666664, "TestLazyTensor": 0.08966666666666667}, "nn/test_convolution": {"TestConvolutionNN": 12.258000000000001, "TestConvolutionNNDeviceTypeCPU": 5.91966666666663}, "nn/test_dropout": {"TestDropoutNN": 0.09566666666666668, "TestDropoutNNDeviceTypeCPU": 0.23066666666666666}, "nn/test_embedding": {"TestEmbeddingNN": 0.07400000000000002, "TestEmbeddingNNDeviceTypeCPU": 6.073999999999992}, "nn/test_init": {"TestNNInit": 2.7703333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 0.5206666666666668}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.7873333333333333, "TestLoadStateDictSwap": 0.05466666666666667}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.018333333333333337, "TestModuleHookNN": 0.08466666666666668, "TestModuleHooks": 0.07900000000000001, "TestStateDictHooks": 0.028666666666666674}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.552666666666667, "TestMultiheadAttentionNNDeviceTypeCPU": 0.03366666666666667}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.2726666666666667}, "nn/test_parametrization": {"TestNNParametrization": 0.8423333333333335, "TestNNParametrizationDeviceCPU": 0.014666666666666666}, "nn/test_pooling": {"TestAvgPool": 0.19266666666666668, "TestPoolingNN": 0.36100000000000004, "TestPoolingNNDeviceTypeCPU": 29.082000000000004}, "nn/test_pruning": {"TestPruningNN": 0.08633333333333337}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.10933333333333332}, "profiler/test_memory_profiler": {"TestDataFlow": 1.1396666666666664, "TestIdentifyGradients": 0.20033333333333334, "TestMemoryProfiler": 0.016333333333333335, "TestMemoryProfilerE2E": 2.9313333333333333}, "profiler/test_profiler": {"TestExecutionTrace": 8.162666666666667, "TestExperimentalUtils": 4.9366666666666665, "TestProfiler": 17.60966666666667, "TestProfilerCUDA": 0.001, "TestProfilerITT": 0.013666666666666667, "TestRecordFunction": 0.04, "TestTorchTidyProfiler": 5.229}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.12000000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.07933333333333333}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.8453333333333326}, "test_ao_sparsity": {"TestActivationSparsifier": 0.066, "TestBaseDataScheduler": 0.023333333333333334, "TestBaseDataSparsifier": 0.082, "TestBaseSparsifier": 0.03633333333333333, "TestBaseStructuredSparsifier": 1.3003333333333331, "TestComposability": 1.2893333333333332, "TestCubicScheduler": 0.004666666666666667, "TestFPGMPruner": 0.019, "TestFakeSparsity": 0.08366666666666667, "TestFxComposability": 1.1266666666666667, "TestNearlyDiagonalSparsifier": 0.56, "TestNormDataSparsifiers": 0.8733333333333332, "TestQuantizationUtils": 0.02033333333333333, "TestQuantizedSparseKernels": 0.22766666666666668, "TestQuantizedSparseLayers": 0.39299999999999996, "TestSaliencyPruner": 0.023333333333333334, "TestScheduler": 0.015333333333333332, "TestSparsityUtilFunctions": 0.04700000000000001, "TestWeightNormSparsifier": 0.30833333333333335}, "test_autocast": {"TestAutocastCPU": 0.5810000000000001, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.004}, "test_autograd": {"TestAllowMutationOnSaved": 0.04600000000000001, "TestAutograd": 16.167000000000016, "TestAutogradComplex": 0.006000000000000001, "TestAutogradDeviceTypeCPU": 0.28033333333333343, "TestAutogradForwardMode": 0.10900000000000006, "TestAutogradForwardModeBatchedGrad": 0.014666666666666666, "TestAutogradFunctional": 8.627999999999995, "TestAutogradInferenceMode": 0.03600000000000001, "TestAutogradLogging": 0.010666666666666666, "TestAutogradMultipleDispatchCPU": 0.022333333333333334, "TestMultithreadAutograd": 0.16500000000000004, "TestNestedCheckpoint": 0.3523333333333334, "TestSelectiveActivationCheckpoint": 0.030666666666666665}, "test_autograd_fallback": {"TestAutogradFallback": 0.11633333333333336}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 129.98733333333647}, "test_bundled_inputs": {"TestBundledInputs": 0.9366666666666666}, "test_comparison_utils": {"TestComparisonUtils": 0.017333333333333336}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0003333333333333333}, "test_complex": {"TestComplexTensorCPU": 0.04766666666666667}, "test_content_store": {"TestContentStoreCPU": 6.751333333333334}, "test_cpp_api_parity": {"TestCppApiParity": 3.153999999999986}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.04033333333333334, "TestMAIATensor": 0.006666666666666667, "TestORTTensor": 0.011333333333333334, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.0026666666666666666, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.04066666666666668, "TestMAIATensor": 0.006666666666666667, "TestORTTensor": 0.011666666666666667, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.0026666666666666666, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 27.954333333333334}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.44566666666666666}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 7.685333333333333}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.4643333333333333}, "test_custom_backend": {"TestCustomBackend": 0.07133333333333332}, "test_custom_ops": {"MiniOpTest": 0.5830000000000002, "MiniOpTestOther": 0.05633333333333335, "TestCustomOp": 1.6813333333333305, "TestCustomOpAPI": 0.13133333333333339, "TestCustomOpTestingCPU": 1.764, "TestCustomOperators": 0.23133333333333336, "TestGenerateOpcheckTests": 2.845}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 34.046, "TestConcatDataset": 0.011333333333333334, "TestConvAfterFork": 0.08433333333333333, "TestCustomPinFn": 0.0016666666666666668, "TestDataLoader": 33.65433333333334, "TestDataLoaderDeviceTypeCPU": 0.0030000000000000005, "TestDataLoaderPersistentWorkers": 60.77366666666666, "TestDatasetRandomSplit": 0.05033333333333334, "TestDictDataLoader": 0.061, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004666666666666666, "TestSetAffinity": 0.082, "TestStackDataset": 0.03000000000000001, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.021}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006000000000000001, "TestDataChunk": 0.006999999999999999, "TestDataFramesPipes": 0.0026666666666666666, "TestFunctionalIterDataPipe": 4.842999999999999, "TestFunctionalMapDataPipe": 0.037, "TestGraph": 0.01066666666666667, "TestIterDataPipeCountSampleYielded": 0.006000000000000001, "TestIterDataPipeGraphFastForward": 0.03266666666666667, "TestIterDataPipeSingletonConstraint": 0.016, "TestIterableDataPipeBasic": 0.027333333333333334, "TestSerialization": 5.969333333333334, "TestSharding": 0.205, "TestStreamWrapper": 0.021333333333333333, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCPU": 0.7210000000000001, "HasDecompTest": 0.155, "TestDecompCPU": 4864.852000000009}, "test_deploy": {"TestFreezer": 0.012666666666666666}, "test_dispatch": {"TestDispatch": 24.020999999999997, "TestPythonDispatcher": 0.008666666666666668}, "test_dlpack": {"TestTorchDlPackCPU": 0.18466666666666678}, "test_dynamic_shapes": {"TestDimConstraints": 1.4433333333333334, "TestFloorDiv": 0.011000000000000001, "TestGuardsExpressions": 0.021666666666666667, "TestPySymInt": 0.9046666666666671, "TestSymNumberMagicMethods": 1.430333333333329}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 1.915333333333332, "TestExpandedWeightHelperFunctionCPU": 0.017333333333333336, "TestExpandedWeightModuleCPU": 5.224666666666667}, "test_fake_tensor": {"FakeTensorConstHandling": 0.05100000000000001, "FakeTensorConverterTest": 0.019333333333333338, "FakeTensorDispatchCache": 0.055333333333333325, "FakeTensorOpInfoTestCPU": 0.107, "FakeTensorOperatorInvariants": 0.26933333333333337, "FakeTensorPropTest": 0.062, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.6920000000000001, "PropagateRealTensorsFakeTensorConstHandling": 0.07633333333333335, "PropagateRealTensorsFakeTensorConverterTest": 0.018666666666666668, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.08100000000000002, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.14, "PropagateRealTensorsFakeTensorPropTest": 0.04033333333333333, "PropagateRealTensorsFakeTensorTest": 0.22233333333333338}, "test_flop_counter": {"TestFlopCounter": 0.5736666666666667}, "test_foreach": {"TestForeachCPU": 47.86500000000018}, "test_function_schema": {"TestFunctionSchema": 0.36966666666666664}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 34.98566666666667}, "test_functional_optim": {"TestFunctionalOptimParity": 0.09500000000000001}, "test_functionalization": {"TestCrossRefFunctionalization": 2.0743333333333323, "TestFunctionalization": 2.514666666666665}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.015333333333333332}, "test_futures": {"TestFuture": 0.6763333333333333}, "test_fx": {"AnnotationsTest": 0.012000000000000004, "TestCSEPass": 0.20900000000000005, "TestCommonPass": 0.054333333333333324, "TestConstFold": 0.13033333333333336, "TestConstParamShapeInControlFlow": 0.036000000000000004, "TestDCE": 0.024333333333333332, "TestFX": 2.5699999999999985, "TestFXAPIBackwardCompatibility": 0.023999999999999997, "TestFunctionalTracing": 0.3036666666666669, "TestMatcher": 0.32000000000000006, "TestOperatorSignaturesCPU": 3.100999999999969, "TestPassManager": 0.019000000000000003, "TestSourceMatcher": 1.1849999999999998, "TestSubgraphRewriter": 0.36633333333333346, "TestVisionTracing": 212.8033333333333, "TypeCheckerTest": 1.4069999999999983}, "test_fx_experimental": {"TestFXExperimental": 16.161666666666665, "TestNormalizeOperatorsCPU": 45.4026666666667, "TestTranslationValidation": 0.18966666666666665}, "test_fx_passes": {"TestFXGraphPasses": 0.4190000000000002, "TestFXMatcherUtils": 0.07200000000000001}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.21633333333333338}, "test_import_stats": {"TestImportTime": 3.023}, "test_indexing": {"NumpyTestsCPU": 0.05233333333333334, "TestIndexingCPU": 1.93533333333333}, "test_itt": {"TestItt": 0.013999999999999999}, "test_jit": {"TestAliasAnalysis": 0.45166666666666666, "TestAsync": 0.3303333333333334, "TestAtenPow": 0.008, "TestAutodiffJit": 0.06266666666666666, "TestAutodiffSubgraphSlicing": 0.27433333333333343, "TestAwait": 0.19233333333333338, "TestBackends": 0.5870000000000001, "TestBackendsWithCompiler": 0.134, "TestBatchMM": 0.071, "TestBuiltins": 0.04900000000000001, "TestClassType": 2.458666666666666, "TestComplex": 0.9006666666666666, "TestCustomOperators": 0.044000000000000004, "TestDCE": 0.019333333333333334, "TestDataParallel": 0.0013333333333333333, "TestDataclasses": 4.1290000000000004, "TestDeviceAnalysis": 3.8010000000000006, "TestDict": 0.36333333333333345, "TestDtypeAnalysis": 0.12666666666666668, "TestDtypeCustomRulesCPU": 3.2129999999999974, "TestEnum": 0.2700000000000001, "TestFreezing": 1.9536666666666669, "TestFrontend": 0.4356666666666667, "TestFrozenOptimizations": 10.240999999999998, "TestFunctionalBlocks": 0.010333333333333335, "TestFunctionalToInplaceActivation": 2.243666666666667, "TestGenerator": 0.06, "TestGetDefaultAttr": 0.015000000000000001, "TestGraphRewritePasses": 0.06, "TestHash": 0.08, "TestHooks": 0.6050000000000002, "TestIgnorableArgs": 0.012000000000000002, "TestIgnoreContextManager": 0.034, "TestInplaceToFunctionalActivation": 2.2733333333333334, "TestIsinstance": 0.3136666666666667, "TestJit": 5.001999999999996, "TestJitGeneratedModule": 10.355666666666705, "TestJitProfiler": 0.001, "TestJitUtils": 0.025000000000000005, "TestList": 1.1543333333333334, "TestLogging": 0.044333333333333336, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.32200000000000006, "TestMixTracingScripting": 1.2816666666666665, "TestModels": 2.034999999999999, "TestModuleAPIs": 0.14033333333333334, "TestModuleContainers": 1.0560000000000003, "TestModuleInterface": 0.48466666666666675, "TestModules": 0.012333333333333333, "TestNamedTuple": 0.063, "TestNnapiBackend": 11.674666666666667, "TestOpDecompositions": 0.018666666666666668, "TestOptimizeForMobilePreserveDebugInfo": 0.20100000000000004, "TestParametrization": 0.106, "TestPeephole": 0.39966666666666684, "TestProducerVersion": 0.0016666666666666668, "TestProfiler": 0.516, "TestPythonBindings": 0.03233333333333333, "TestPythonBuiltinOP": 0.4220000000000001, "TestPythonIr": 0.029666666666666664, "TestRecursiveScript": 0.5766666666666668, "TestRemoveMutation": 0.11833333333333335, "TestSaveLoad": 0.48033333333333345, "TestSaveLoadFlatbuffer": 0.3333333333333333, "TestSaveLoadForOpVersion": 2.2463333333333333, "TestScript": 34.579666666666704, "TestScriptDict": 0.02466666666666667, "TestScriptList": 0.7653333333333334, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.24500000000000008, "TestScriptProfile": 0.40700000000000003, "TestSlice": 0.15233333333333338, "TestSparse": 0.05466666666666666, "TestStringFormatting": 0.15100000000000002, "TestSymbolicShapeAnalysis": 1.6629999999999991, "TestTensorBuiltins": 0.06333333333333334, "TestTensorCreationOps": 0.04566666666666667, "TestTensorMethods": 0.009333333333333334, "TestTorchbind": 0.1476666666666667, "TestTracer": 2.898666666666664, "TestTypeSharing": 0.33633333333333343, "TestTypesAndAnnotation": 0.11433333333333334, "TestTyping": 0.38433333333333347, "TestUnion": 0.38900000000000023, "TestUnsupportedOps": 0.031, "TestUpgraders": 0.081, "TestWarn": 0.04566666666666667, "TestWith": 0.3216666666666666}, "test_jit_autocast": {"TestAutocast": 0.09500000000000001, "TestJitTraceAutocast": 15.764000000000001}, "test_jit_disabled": {"TestJitDisabled": 0.109}, "test_jit_fuser_te": {"TestFuserCommon": 0.11066666666666668, "TestLoopnestRandomizationCPU": 0.041, "TestNNCOpInfoCPU": 49.955333333333044, "TestTEFuserDynamic": 120.86200000000004, "TestTEFuserStatic": 42.72199999999999}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.103, "TestFusionPatternCPU": 6.896000000000001, "TestModel": 3.916666666666666, "TestOpCPU": 42.451333333333345}, "test_legacy_vmap": {"TestVmapAPI": 1.1359999999999983, "TestVmapAPILegacy": 1.0196666666666665, "TestVmapBatchedGradientCPU": 0.0746666666666667, "TestVmapBatchedGradientLegacyCPU": 0.09633333333333338, "TestVmapOperators": 0.9090000000000001, "TestVmapOperatorsLegacy": 0.9626666666666668}, "test_license": {"TestLicense": 0.015}, "test_linalg": {"TestLinalgCPU": 143.01766666666606}, "test_logging": {"LoggingTest": 2.4006666666666665}, "test_masked": {"TestMaskedCPU": 13.853666666666667}, "test_maskedtensor": {"TestBasicsCPU": 0.10500000000000002, "TestBinary": 0.26666666666666683, "TestOperatorsCPU": 7.23933333333332, "TestReductions": 0.06266666666666669, "TestUnary": 0.33133333333333354}, "test_meta": {"TestMetaCPU": 1424.5009999999154, "TestMetaConverter": 0.10866666666666669}, "test_mkl_verbose": {"TestMKLVerbose": 3.656}, "test_mkldnn": {"TestMkldnnCPU": 105.342}, "test_mkldnn_fusion": {"TestMkldnnFusion": 63.059}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.022}, "test_mobile_optimizer": {"TestOptimizer": 2.4603333333333333}, "test_model_dump": {"TestModelDump": 0.867}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.01}, "test_module_init": {"TestModuleInitCPU": 2.0079999999999965}, "test_module_tracker": {"TestModuleTracker": 0.021333333333333333}, "test_modules": {"TestModuleCPU": 403.65933333332237}, "test_monitor": {"TestMonitor": 0.024333333333333332, "TestMonitorTensorboard": 0.4626666666666666}, "test_multiprocessing": {"TestMultiprocessing": 43.95733333333334}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.4206666666666667, "SpawnTest": 24.477999999999998}, "test_namedtensor": {"TestNamedTensor": 0.38100000000000017}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.0273333333333332}, "test_native_functions": {"TestNativeFunctions": 0.1376666666666667}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.17800000000000005}, "test_nestedtensor": {"TestNestedTensor": 0.13333333333333341, "TestNestedTensorAutogradCPU": 0.8456666666666669, "TestNestedTensorDeviceTypeCPU": 0.7916666666666671, "TestNestedTensorSubclassCPU": 17.915333333333347}, "test_nn": {"TestAddRelu": 0.0030000000000000005, "TestConstantPadNd": 0.0030000000000000005, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.239, "TestFusionUtils": 0.004, "TestNN": 31.76033333333329, "TestNNDeviceTypeCPU": 102.44966666666745, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.004333333333333334}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.14600000000000007}, "test_openmp": {"TestOpenMP_ParallelFor": 5.719333333333334}, "test_ops": {"TestCommonCPU": 1226.4143333332943, "TestCompositeComplianceCPU": 701.942999999997, "TestFakeTensorCPU": 258.9573333333336, "TestMathBitsCPU": 43.052333333333365, "TestRefsOpsInfoCPU": 1.195000000000001, "TestSelfKwarg": 0.021, "TestTagsCPU": 13.506333333333325}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 517.7120000000069}, "test_ops_gradients": {"TestBwdGradientsCPU": 943.1946666666717}, "test_ops_jit": {"TestJitCPU": 845.7063333333323}, "test_optim": {"TestDifferentiableOptimizer": 0.1516666666666667, "TestLRScheduler": 0.8823333333333339, "TestOptim": 46.760999999999996, "TestOptimRenewedCPU": 35.07533333333342, "TestSWAUtils": 0.1436666666666667}, "test_out_dtype_op": {"TestOutDtypeOp": 0.3146666666666667}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.0013333333333333333, "TestDisabledUserWarnings": 0.0013333333333333333, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.017, "TestGradNewOnesOverride": 0.0013333333333333333, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.002, "TestResolveName": 0.08133333333333333, "TestTorchFunctionMode": 0.02566666666666668, "TestTorchFunctionOverride": 1.4679999999999511, "TestTorchFunctionWarning": 0.011666666666666665, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.03166666666666667, "ModelTest": 0.0, "TestAnalyze": 0.012333333333333335, "TestDependencyAPI": 0.03966666666666668, "TestDependencyHooks": 0.007666666666666666, "TestDiGraph": 0.015333333333333338, "TestGlobGroup": 0.019000000000000006, "TestImporter": 0.008666666666666668, "TestLoadBCPackages": 0.06899999999999999, "TestMangling": 0.012666666666666668, "TestMisc": 0.14133333333333334, "TestPackageFX": 0.05299999999999999, "TestPackageScript": 1.5639999999999992, "TestRepackage": 0.010666666666666666, "TestResources": 0.011000000000000001, "TestSaveLoad": 0.033}, "test_per_overload_api": {"TestPerOverloadAPI": 0.02}, "test_prims": {"TestDecompCPU": 0.10833333333333334, "TestPrimsBasic": 0.024999999999999998, "TestPrimsCPU": 0.11933333333333333, "TestRefsCPU": 0.012666666666666668}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.084, "TestGenericProxyTensorFake": 1.8143333333333331, "TestGenericProxyTensorReal": 2.2393333333333327, "TestGenericProxyTensorSymbolic": 15.790333333333335, "TestProxyTensorOpInfoCPU": 647.1903333333282, "TestRealProxyTensor": 0.012000000000000002, "TestSymbolicTracing": 3.132}, "test_pruning_op": {"PruningOpTest": 0.218}, "test_public_bindings": {"TestPublicBindings": 6.495333333333334}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006000000000000001, "TestPythonDispatch": 0.17966666666666675, "TestPythonDispatcher": 0.005666666666666667, "TestPythonRegistration": 0.15466666666666667, "TestWrapperSubclassAliasingCPU": 0.11433333333333336}, "test_pytree": {"TestCxxPytree": 0.01533333333333334, "TestGenericPytree": 0.13666666666666674, "TestPythonPytree": 0.07900000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.015, "TestAOMigrationNNQuantized": 0.04200000000000001, "TestAOMigrationQuantization": 0.02133333333333334, "TestAOMigrationQuantizationFx": 0.017666666666666667, "TestBackendConfig": 0.03800000000000001, "TestBiasCorrectionEager": 1.3143333333333334, "TestBits": 0.004666666666666667, "TestBitsCPU": 0.05233333333333334, "TestComparatorOps": 0.985, "TestDeprecatedJitQuantized": 4.059333333333333, "TestDistributed": 0.02, "TestDuplicateDQPass": 2.674, "TestDynamicQuantizedModule": 43.739666666666665, "TestDynamicQuantizedOps": 25.687, "TestEqualizeEager": 0.143, "TestEqualizeFx": 4.810333333333333, "TestFXGraphMatcher": 1.478, "TestFXGraphMatcherModels": 11.466333333333333, "TestFXNumericSuiteCoreAPIs": 25.786, "TestFXNumericSuiteCoreAPIsModels": 38.38833333333333, "TestFXNumericSuiteNShadows": 36.15033333333333, "TestFakeQuantize": 0.293, "TestFakeQuantizeOps": 1.673, "TestFloat8DtypeCPU": 0.08300000000000003, "TestFloat8DtypeCPUOnlyCPU": 0.40166666666666667, "TestFuseEager": 2.7646666666666664, "TestFuseFx": 2.294333333333333, "TestFusedObsFakeQuant": 0.072, "TestFusedObsFakeQuantModule": 0.19600000000000004, "TestFusionPasses": 0.021666666666666667, "TestFxDetectInputWeightEqualization": 0.20766666666666667, "TestFxDetectOutliers": 0.248, "TestFxModelReportClass": 0.64, "TestFxModelReportDetectDynamicStatic": 0.055333333333333325, "TestFxModelReportDetector": 0.18566666666666667, "TestFxModelReportObserver": 0.18199999999999997, "TestFxModelReportVisualizer": 0.19066666666666668, "TestGenerateNumericDebugHandle": 1.0313333333333334, "TestGraphUtils": 1.4246666666666667, "TestHistogramObserver": 26.935333333333336, "TestMetaDataPorting": 5.958666666666667, "TestModelNumericsEager": 1.0433333333333332, "TestNumericSuiteEager": 8.024333333333333, "TestObserver": 2.917, "TestPT2ERepresentation": 30.08966666666667, "TestPadding": 19.480333333333334, "TestQNNPackOps": 5.038, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 2.2743333333333333, "TestQuantizeDynamicJitPasses": 4.922666666666667, "TestQuantizeEagerOps": 1.5103333333333333, "TestQuantizeEagerPTQDynamic": 8.060666666666666, "TestQuantizeEagerPTQStatic": 24.15133333333333, "TestQuantizeEagerQAT": 10.566, "TestQuantizeEagerQATNumerics": 1.936333333333333, "TestQuantizeFx": 42.26066666666669, "TestQuantizeFxModels": 7.4496666666666655, "TestQuantizeFxOps": 104.56066666666668, "TestQuantizeJit": 19.981666666666666, "TestQuantizeJitOps": 218.4213333333333, "TestQuantizeJitPasses": 6.414999999999999, "TestQuantizePT2E": 53.13533333333334, "TestQuantizePT2EQAT": 37.080000000000005, "TestQuantizePT2EQATModels": 29.379333333333324, "TestQuantizePT2EQAT_ConvBn1d": 303.71600000000007, "TestQuantizePT2EQAT_ConvBn2d": 287.3176666666667, "TestQuantizePT2EX86Inductor": 124.04233333333336, "TestQuantizedConv": 47.025, "TestQuantizedEmbeddingOps": 0.6823333333333332, "TestQuantizedFunctionalOps": 2.367666666666667, "TestQuantizedLinear": 17.981333333333335, "TestQuantizedOps": 130.408, "TestQuantizedTensor": 1.4886666666666668, "TestRecordHistogramObserver": 0.03133333333333333, "TestReferenceQuantizedModule": 0.06433333333333334, "TestSerialization": 1.8503333333333332, "TestStaticQuantizedModule": 124.69666666666667, "TestSubgraphRewriter": 1.5110000000000001, "TestUtils": 0.018333333333333337, "TestXNNPACKQuantizer": 35.041333333333334, "TestXNNPACKQuantizerModels": 4.26}, "test_reductions": {"TestReductionsCPU": 187.9946666666549}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 3.560333333333334}, "test_schema_check": {"TestSchemaCheck": 0.15200000000000005, "TestSchemaCheckModeOpInfoCPU": 167.00733333332948}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.9670000000000004}, "test_serialization": {"TestBothSerializationCPU": 0.17166666666666666, "TestOldSerialization": 27.952, "TestSerialization": 8.53, "TestSubclassSerialization": 0.028666666666666663}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.013999999999999999}, "test_shape_ops": {"TestShapeOpsCPU": 1.0603333333333327}, "test_show_pickle": {"TestShowPickle": 0.01833333333333333}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.8023333333333291}, "test_sparse": {"TestSparseAnyCPU": 329.30999999999966, "TestSparseCPU": 18.83766666666666, "TestSparseLegacyAndDeprecation": 0.049666666666666665, "TestSparseMaskedReductionsCPU": 0.9483333333333337, "TestSparseMeta": 3.505999999999999, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 10.783333333333461}, "test_sparse_csr": {"TestSparseCSRCPU": 68.3450000000009, "TestSparseCSRSampler": 0.449, "TestSparseCompressedCPU": 82.08900000000001, "TestSparseCompressedTritonKernelsCPU": 0.005666666666666667}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.002}, "test_spectral_ops": {"TestFFTCPU": 5.3153333333333235, "TestFFTDocExamplesCPU": 0.06433333333333337}, "test_stateless": {"TestPythonOptimizeMode": 3.8826666666666667, "TestStatelessDeprecation": 1.5716666666666665, "TestStatelessFunctionalAPI": 0.2233333333333334}, "test_subclass": {"TestSubclass": 0.1550000000000001}, "test_sympy_utils": {"TestNumbers": 0.04866666666666667, "TestSingletonInt": 0.006333333333333333, "TestSympyInterp": 7.876, "TestSympySolve": 0.19300000000000003, "TestValueRanges": 5.367666666666665}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.474666666666667, "TestBufferProtocolCPU": 0.3060000000000002, "TestLikeTensorCreationCPU": 0.008666666666666668, "TestRandomTensorCreationCPU": 2.8796666666666666, "TestTensorCreationCPU": 17.16666666666669}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.021666666666666667, "TestTensorBoardFigure": 0.0003333333333333333, "TestTensorBoardNumpy": 0.0026666666666666666, "TestTensorBoardPyTorchNumpy": 0.035333333333333335, "TestTensorBoardPytorchGraph": 29.445666666666668, "TestTensorBoardSummary": 0.04833333333333334, "TestTensorBoardSummaryWriter": 0.008, "TestTensorBoardUtils": 0.16566666666666666, "TestTensorBoardWriter": 0.10033333333333334, "TestTensorProtoSummary": 0.010333333333333335}, "test_tensorexpr": {"TestTensorExprFuser": 44.602666666666664}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.008, "TestTensorExprPyBind": 0.5873333333333334}, "test_testing": {"TestAssertClose": 0.13666666666666674, "TestAssertCloseContainer": 0.008, "TestAssertCloseErrorMessage": 0.06566666666666666, "TestAssertCloseQuantized": 0.013333333333333334, "TestAssertCloseSparseBSC": 0.01966666666666667, "TestAssertCloseSparseBSR": 0.019333333333333338, "TestAssertCloseSparseCOO": 0.025666666666666667, "TestAssertCloseSparseCSC": 0.022000000000000002, "TestAssertCloseSparseCSR": 0.019333333333333334, "TestFrameworkUtils": 11.071666666666665, "TestImports": 12.122, "TestMakeTensorCPU": 1.407999999999994, "TestOpInfoSampleFunctionsCPU": 7.8689999999999385, "TestOpInfos": 0.004, "TestTestParametrization": 0.040000000000000015, "TestTestParametrizationDeviceTypeCPU": 3.4716666666666645, "TestTestingCPU": 0.17033333333333336}, "test_torch": {"TestBasicVitalSigns": 0.016, "TestTorch": 3.2093333333333263, "TestTorchDeviceTypeCPU": 12.030333333333395, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 19.95233333333333, "TestAttnMasksCPU": 18.15833333333333, "TestSDPACPU": 277.8723333333325, "TestSDPAFailureModesCPU": 0.03000000000000001, "TestTransformersCPU": 8.232999999999999}, "test_type_hints": {"TestTypeHints": 0.014}, "test_type_info": {"TestDTypeInfo": 0.024000000000000004}, "test_type_promotion": {"TestTypePromotionCPU": 3.325333333333319}, "test_typing": {"TestTyping": 71.0816666666667}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 327.57599999982955}, "test_utils": {"TestAssert": 0.05100000000000001, "TestBottleneck": 8.052333333333335, "TestCheckpoint": 0.07600000000000001, "TestCollectEnv": 0.961, "TestCppExtensionUtils": 0.08666666666666667, "TestDataLoaderUtils": 0.237, "TestDeviceUtilsCPU": 32.66099999999897, "TestExtensionUtils": 0.004, "TestHipify": 0.001, "TestHipifyTrie": 0.0023333333333333335, "TestONNXUtils": 0.0033333333333333335, "TestRenderUtils": 0.010666666666666666, "TestStandaloneCPPJIT": 1.6310000000000002, "TestTraceback": 0.008333333333333333}, "test_view_ops": {"TestOldViewOpsCPU": 10.844666666666676, "TestViewOpsCPU": 0.8353333333333329, "TestViewOpsLAZY": 0.8360000000000003}, "test_vulkan": {"TestVulkanRewritePass": 0.0006666666666666666}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.018, "WeakKeyDictionaryTestCase": 0.023000000000000003, "WeakTest": 3.864666666666666}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 31.675666666666668, "TestXNNPACKOps": 4.076666666666667, "TestXNNPACKRewritePass": 1.774, "TestXNNPACKSerDes": 4.855333333333334}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.1193333333333334}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.06566666666666669, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0016666666666666668, "TestMisc": 0.0033333333333333335, "TestPickling": 0.09500000000000001, "TestPromotion": 0.002}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 11.475666666666667, "TestEinsumPath": 0.0006666666666666666, "TestMisc": 0.006333333333333333}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.023000000000000003, "TestHalf": 0.0, "TestIinfo": 0.013333333333333334, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0026666666666666666, "TestBooleanIndexing": 0.006666666666666667, "TestBroadcastedAssignments": 0.02066666666666667, "TestFancyIndexingCast": 0.004, "TestFloatNonIntegerArgument": 0.008666666666666668, "TestIndexing": 0.18900000000000008, "TestMultiIndexingAutomated": 0.008666666666666668, "TestMultipleEllipsisError": 0.0016666666666666668, "TestNonIntegerArrayLike": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.02566666666666667, "TestArgmax": 1.057666666666667, "TestArgmaxArgminCommon": 1.224666666666666, "TestArgmin": 1.2723333333333335, "TestArrayAttributeDeletion": 0.008666666666666668, "TestArrayConstruction": 0.027666666666666673, "TestArrayCreationCopyArgument": 0.0716666666666667, "TestArrayInterface": 0.030333333333333327, "TestAssignment": 0.010000000000000002, "TestAttributes": 0.017000000000000005, "TestBinop": 0.014, "TestBool": 17.114333333333338, "TestCequenceMethods": 0.002, "TestChoose": 0.012000000000000002, "TestClip": 0.007333333333333334, "TestCompress": 0.006666666666666667, "TestConversion": 0.03566666666666667, "TestCreation": 0.001, "TestDelMisc": 0.002, "TestDot": 0.05700000000000002, "TestDtypedescr": 0.0013333333333333333, "TestFancyIndexing": 0.027, "TestFlag": 0.010333333333333333, "TestFormat": 0.005333333333333333, "TestFromBuffer": 0.019333333333333338, "TestHash": 0.012666666666666666, "TestHashing": 0.0033333333333333335, "TestIO": 0.0016666666666666668, "TestInner": 0.147, "TestLexsort": 0.03200000000000001, "TestMatmul": 0.30366666666666675, "TestMatmulOperator": 0.21799999999999997, "TestMethods": 1.222666666666667, "TestMinMax": 0.006000000000000001, "TestMinScalarType": 0.008333333333333333, "TestNewaxis": 0.004, "TestPEP3118Dtype": 0.0003333333333333333, "TestPutmask": 0.020666666666666667, "TestRepeat": 0.012000000000000002, "TestResize": 0.043666666666666666, "TestRichcompareScalar": 0.0006666666666666666, "TestScalarIndexing": 0.01966666666666667, "TestSizeOf": 0.010666666666666666, "TestSortFloatMisc": 0.14300000000000002, "TestStats": 0.24, "TestSubscripting": 0.002, "TestTake": 0.054333333333333345, "TestVdot": 0.030333333333333334, "TestViewDtype": 0.006666666666666667, "TestWarnings": 0.002, "TestWhere": 0.32933333333333337, "TestWritebackIfCopy": 0.027333333333333334}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.021333333333333333, "TestArgwhere": 0.039, "TestArrayComparisons": 0.014333333333333332, "TestBaseRepr": 0.008, "TestBinaryRepr": 0.012333333333333335, "TestBoolArray": 2.3906666666666663, "TestBoolCmp": 0.17899999999999996, "TestBoolScalar": 0.014666666666666666, "TestBroadcast": 0.10166666666666668, "TestClip": 0.22700000000000017, "TestConvolve": 0.026333333333333334, "TestCorrelate": 0.03333333333333333, "TestCreationFuncs": 1.1409999999999998, "TestCross": 0.04466666666666667, "TestDtypePositional": 0.0016666666666666668, "TestFloatExceptions": 0.011666666666666667, "TestFromiter": 0.0006666666666666666, "TestIndex": 0.007, "TestIndices": 0.036333333333333336, "TestIsclose": 0.08066666666666668, "TestIsscalar": 0.0023333333333333335, "TestLikeFuncs": 0.0003333333333333333, "TestMoveaxis": 0.014666666666666668, "TestNonarrayArgs": 0.13400000000000006, "TestNonzeroAndCountNonzero": 0.244, "TestOuterMisc": 0.004333333333333334, "TestRequire": 0.005333333333333333, "TestResize": 0.04633333333333334, "TestRoll": 0.034666666666666665, "TestRollaxis": 0.006333333333333333, "TestSeterr": 0.006999999999999999, "TestStdVar": 0.03166666666666667, "TestStdVarComplex": 0.013666666666666667, "TestStringFunction": 0.0016666666666666668, "TestTensordot": 0.011333333333333334, "TestTypes": 0.01566666666666667}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0016666666666666668, "TestCommonType": 0.027333333333333338, "TestDocStrings": 0.0, "TestIsSubDType": 0.01, "TestScalarTypeNames": 0.033333333333333354}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06633333333333338, "TestFromInt": 0.010333333333333333, "TestFromString": 0.02066666666666667}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0003333333333333333, "TestBitCount": 0.005, "TestClassGetItem": 0.0003333333333333333, "TestClassGetitemMisc": 0.0016666666666666668, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.09466666666666668, "TestBaseMath": 6.849333333333333, "TestBitShifts": 0.078, "TestComplexDivision": 0.04633333333333334, "TestConversion": 0.04766666666666667, "TestHash": 0.0, "TestModulus": 0.7803333333333334, "TestMultiply": 0.0003333333333333333, "TestNegative": 0.016999999999999998, "TestPower": 0.09866666666666668, "TestRepr": 0.0016666666666666668, "TestScalarOpsMisc": 0.043333333333333356, "TestScalarSubclassingMisc": 0.00966666666666667, "TestSubtract": 0.016333333333333335, "TestTypes": 11.023333333333333}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.04633333333333334, "TestAtleast2d": 0.02266666666666667, "TestAtleast3d": 0.017666666666666667, "TestBlock": 0.03533333333333335, "TestConcatenate": 0.1573333333333334, "TestHstack": 0.035, "TestStackMisc": 0.12300000000000004, "TestVstack": 0.028333333333333335}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007333333333333333, "TestFFTShift": 4.225999999999999, "TestIRFFTN": 0.004333333333333334, "TestRFFTFreq": 0.007}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.299, "TestFFTShift": 0.015, "TestFFTThreadSafe": 1.3653333333333333}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.056333333333333326}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.004666666666666667, "TestUnique": 0.17433333333333337}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.011000000000000001, "TestAmax": 0.007333333333333333, "TestAmin": 0.006666666666666667, "TestAngle": 0.007, "TestAny": 0.011333333333333334, "TestAverage": 0.025333333333333336, "TestBincount": 0.03, "TestCheckFinite": 0.0026666666666666666, "TestCopy": 0.008, "TestCorrCoef": 0.025333333333333333, "TestCov": 0.047333333333333345, "TestCumprod": 0.021, "TestCumsum": 0.035666666666666666, "TestDelete": 0.019333333333333338, "TestDiff": 0.06566666666666666, "TestDigitize": 0.01166666666666667, "TestExtins": 0.005333333333333333, "TestFilterwindows": 0.434666666666667, "TestFlip": 0.04666666666666667, "TestGradient": 0.2216666666666667, "TestInsert": 0.014, "TestInterp": 0.0556666666666667, "TestKaiser": 0.008, "TestMedian": 0.11533333333333336, "TestMeshgrid": 0.03933333333333334, "TestMsort": 0.0, "TestPercentile": 0.09900000000000003, "TestPiecewise": 0.008, "TestProd": 0.020666666666666667, "TestPtp": 0.01, "TestQuantile": 0.053333333333333344, "TestRot90": 0.064, "TestSelect": 0.016000000000000004, "TestSinc": 0.006666666666666667, "TestSortComplex": 0.012000000000000002, "TestTrapz": 0.004, "TestTrimZeros": 0.009333333333333334, "TestUnique": 0.0036666666666666666, "Test_I0": 0.010333333333333333}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.17200000000000001, "TestHistogramOptimBinNums": 0.03500000000000002, "TestHistogramdd": 0.19800000000000004}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0013333333333333333, "TestConcatenator": 0.008, "TestDiagIndices": 0.004333333333333334, "TestDiagIndicesFrom": 0.006333333333333334, "TestFillDiagonal": 0.021666666666666667, "TestGrid": 0.01, "TestIndexExpression": 0.009, "TestIx_": 0.006666666666666667, "TestNdIndex": 0.0013333333333333333, "TestNdenumerate": 0.0013333333333333333, "TestRavelUnravelIndex": 0.038666666666666676}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.012333333333333335, "TestApplyOverAxes": 0.0016666666666666668, "TestArraySplit": 0.15300000000000002, "TestColumnStack": 0.009000000000000001, "TestDsplit": 0.009, "TestDstack": 0.014666666666666668, "TestExpandDims": 0.009333333333333334, "TestHsplit": 0.012333333333333335, "TestKron": 0.014666666666666668, "TestMayShareMemory": 0.0016666666666666668, "TestPutAlongAxis": 0.008333333333333333, "TestSplit": 0.005333333333333333, "TestSqueeze": 0.031000000000000003, "TestTakeAlongAxis": 0.04533333333333334, "TestTile": 0.081, "TestVsplit": 0.008666666666666665}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.021333333333333333, "TestEye": 0.046000000000000006, "TestFliplr": 0.004, "TestFlipud": 0.0036666666666666666, "TestHistogram2d": 0.025000000000000005, "TestTri": 0.08433333333333333, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.0033333333333333335, "TestTriuIndicesFrom": 0.002, "TestVander": 0.024333333333333332}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.002, "TestCommonType": 0.03333333333333333, "TestImag": 0.013333333333333334, "TestIscomplex": 0.004666666666666666, "TestIscomplexobj": 0.004666666666666667, "TestIsfinite": 0.013, "TestIsinf": 0.012999999999999998, "TestIsnan": 0.015333333333333332, "TestIsneginf": 0.0023333333333333335, "TestIsposinf": 0.0023333333333333335, "TestIsreal": 0.008666666666666668, "TestIsrealobj": 0.002, "TestIsscalar": 0.0023333333333333335, "TestMintypecode": 0.006333333333333333, "TestNanToNum": 0.014666666666666666, "TestReal": 0.014666666666666666, "TestRealIfClose": 0.004333333333333334}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.25500000000000006, "TestCond": 0.221, "TestDet": 0.17566666666666672, "TestEig": 0.04533333333333334, "TestEigh": 0.03166666666666667, "TestEighCases": 0.0, "TestEigvals": 0.07800000000000001, "TestEigvalsh": 0.043666666666666666, "TestEigvalshCases": 0.0, "TestInv": 0.054, "TestLstsq": 0.2776666666666667, "TestMatrixRank": 0.327, "TestMisc": 0.063, "TestMisc2": 0.009666666666666665, "TestMultiDot": 0.10166666666666668, "TestNormDouble": 0.739, "TestNormInt64": 0.7573333333333335, "TestNormSingle": 0.7840000000000001, "TestNorm_NonSystematic": 0.007666666666666666, "TestPinv": 0.118, "TestPinvHermitian": 0.046000000000000006, "TestQR": 6.303666666666666, "TestSVD": 0.05066666666666667, "TestSVDHermitian": 0.10566666666666667, "TestSolve": 0.07166666666666667, "TestTensorinv": 0.03333333333333333, "TestTensorsolve": 0.021666666666666667}, "torch_np/test_basic": {"TestArrayToSequence": 0.008, "TestCopyTo": 0.007333333333333334, "TestCtorNested": 0.004, "TestDefaultDtype": 0.008333333333333333, "TestDivmod": 0.018333333333333337, "TestExport": 0.0023333333333333335, "TestMisc": 0.0030000000000000005, "TestNormalizations": 0.006000000000000001, "TestOneArr": 0.2830000000000002, "TestOneArrAndAxesTuple": 0.01, "TestOneArrAndAxis": 0.14433333333333342, "TestOneArrAndShape": 0.006666666666666669, "TestOneArrToScalar": 0.012000000000000002, "TestPythonArgsToArray": 0.011333333333333334, "TestSequenceOfArrays": 0.016666666666666673, "TestSequenceOfArraysToSingle": 0.008, "TestShapeLikeToArray": 0.005333333333333333, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.11666666666666674}, "torch_np/test_dtype": {"TestConvertDType": 0.07566666666666672}, "torch_np/test_function_base": {"TestAppend": 0.016333333333333335}, "torch_np/test_ndarray_methods": {"TestAmax": 0.006333333333333333, "TestAmin": 0.006333333333333333, "TestArgmax": 0.8530000000000006, "TestArgmaxArgminCommon": 1.1716666666666653, "TestArgmin": 1.241666666666667, "TestContains": 0.0016666666666666668, "TestIndexing": 0.022000000000000002, "TestIter": 0.005, "TestNoExtraMethods": 0.008666666666666668, "TestNonzero": 0.135, "TestRavel": 0.008333333333333333, "TestReshape": 0.006333333333333334, "TestTranspose": 0.010666666666666666}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 2.887333333333201, "TestNEP50Table": 0.10100000000000003}, "torch_np/test_random": {"TestChoice": 0.009666666666666669, "TestNumpyGlobal": 0.0030000000000000005, "TestScalarReturn": 0.04700000000000002, "TestShuffle": 0.010000000000000002}, "torch_np/test_reductions": {"TestAll": 0.015666666666666666, "TestAny": 0.017666666666666667, "TestFlatnonzero": 0.11333333333333333, "TestGenericCumSumProd": 0.015666666666666666, "TestGenericReductions": 1.8136666666666332, "TestMean": 0.021, "TestSum": 0.31933333333333336}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.037666666666666675, "TestIsScalar": 0.020333333333333346}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.514666666666667, "TestNdarrayDunderVsUfunc": 0.14966666666666675, "TestUfuncDtypeKwd": 0.004, "TestUnaryUfuncs": 0.043333333333333356}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.11600000000000006}}, "dynamo": {"backends/xeon/test_launch": {"TestTorchrun": 2.0396666666666667}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.8613333333333333}, "distributions/test_constraints": {"test_constraints": 0.07766666666666672}, "distributions/test_distributions": {"TestAgainstScipy": 0.0, "TestConstraints": 91.50666666666666, "TestDistributionShapes": 89.42733333333331, "TestDistributions": 0.004666666666666667, "TestFunctors": 4.348666666666667, "TestJit": 404.19266666666664, "TestKL": 0.09699999999999999, "TestLazyLogitsInitialization": 91.94933333333331, "TestNumericalStability": 0.0, "TestRsample": 0.0, "TestValidation": 107.01966666666668}, "dynamo/test_after_aot": {"TestAfterAot": 8.8575}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 14.994500000000002}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 1.6446666666666667}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.05666666666666667, "TestCustomBackendAPI": 1.4283333333333335, "TestExplainWithBackend": 11.779000000000002, "TestOptimizations": 0.719}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 14.862000000000002}, "dynamo/test_base_output": {"TestBaseOutput": 0.0035}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 7.258666666666667}, "dynamo/test_comptime": {"ComptimeTests": 0.30600000000000005}, "dynamo/test_config": {"ConfigTests": 0.3175}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.3945}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.024}, "dynamo/test_decorators": {"DecoratorTests": 0.4220000000000001}, "dynamo/test_exc": {"ExcTests": 1.275}, "dynamo/test_export_mutations": {"MutationExportTests": 0.247}, "dynamo/test_frame_init": {"FrameInitTests": 0.013000000000000001}, "dynamo/test_functions": {"DefaultsTests": 8.82699999999999, "FunctionTests": 10.975666666666648}, "dynamo/test_global": {"TestGlobals": 0.3450000000000001}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.07200000000000001, "FuncTorchHigherOrderOpTests": 2.0685000000000002, "HigherOrderOpTests": 6.9735}, "dynamo/test_hooks": {"HooksTests": 21.376}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 8.848999999999998}, "dynamo/test_interop": {"InteropTests": 0.36033333333333334}, "dynamo/test_logging": {"LoggingTests": 12.320000000000002}, "dynamo/test_minifier": {"MinifierTests": 1.2663333333333335}, "dynamo/test_misc": {"MiscTests": 34.29933333333337, "TestTracer": 0.05266666666666667}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.003}, "dynamo/test_nops": {"NopTests": 0.229}, "dynamo/test_optimizers": {"End2EndTests": 0.29000000000000004, "OptimizerTests": 1.7745000000000002}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.272}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.7496666666666668}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.535}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.742}, "dynamo/test_recompiles": {"RecompileTests": 0.6063333333333335}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.004}, "dynamo/test_repros": {"ReproTests": 35.38300000000001}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.23266666666666666}, "dynamo/test_subclasses": {"SubclassTests": 1.1260000000000001, "TestNestedTensor": 1.8824999999999998}, "dynamo/test_subgraphs": {"SubGraphTests": 2.394499999999999}, "dynamo/test_unspec": {"UnspecTests": 9.636333333333333}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.358}, "export/test_db": {"ExampleTests": 4.917333333333334}, "export/test_export": {"TestDynamismExpression": 0.8469999999999999, "TestExport": 25.82433333333334, "TestExportCustomClass": 0.1376666666666667, "TestOneOffModelExportResult": 0.10133333333333333}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.5670000000000001}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 1.1693333333333333}, "export/test_pass_infra": {"TestPassInfra": 0.94}, "export/test_passes": {"TestPasses": 5.087}, "export/test_safeguard": {"TestSafeguard": 1.2633333333333334}, "export/test_serialize": {"TestDeserialize": 13.136000000000001, "TestOpVersioning": 0.026333333333333337, "TestSaveLoad": 0.49933333333333335, "TestSchemaVersioning": 0.12266666666666666, "TestSerialize": 0.8210000000000001, "TestSerializeCustomClass": 0.11566666666666665}, "export/test_torchbind": {"TestExportTorchbind": 0.002}, "export/test_unflatten": {"TestUnflatten": 2.3540000000000005}, "export/test_upgrade": {"TestUpgrade": 0.6666666666666666}, "export/test_verifier": {"TestVerifier": 1.1003333333333334}, "functorch/test_aotdispatch": {"TestAOTAutograd": 49.92833333333332, "TestAOTAutogradWithDynamo": 0.0013333333333333333, "TestAOTDispatch": 7.960999999999999, "TestAOTExport": 6.267, "TestAOTModuleSimplified": 1.6046666666666667, "TestEagerFusionModuleInfoCPU": 2.836999999999989, "TestEagerFusionOpInfoCPU": 14.284666666666695, "TestPartitioning": 6.691333333333334, "TestPythonKeyCPU": 13.831333333333333}, "functorch/test_control_flow": {"TestControlFlow": 8.981333333333332, "TestControlFlowTraced": 400.49966666666677}, "functorch/test_dims": {"TestMin": 0.0026666666666666666, "TestMinFunctorchOnly": 0.0003333333333333333}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 4.591666666666666, "TestAutogradFunctionVmapAPICPU": 0.971, "TestCompileTransformsCPU": 10.893666666666666, "TestComposabilityCPU": 11.275333333333336, "TestExamplesCorrectnessCPU": 28.38233333333333, "TestFunctionalizeCPU": 3.4979999999999998, "TestGradTransformCPU": 22.99633333333333, "TestHelpersCPU": 0.9170000000000001, "TestHessianCPU": 4.696000000000001, "TestHigherOrderOperatorInteractionCPU": 1.3783333333333332, "TestJacCPU": 59.01766666666666, "TestJvpCPU": 6.7076666666666656, "TestLinearizeCPU": 1.546, "TestMakeFunctional": 1.7766666666666666, "TestSliceArgnums": 0.5013333333333335, "TestVmapJvpInplaceViewCPU": 4.979666666666667, "TestVmapOfGradCPU": 26.56866666666666}, "functorch/test_logging": {"TestAOTLogging": 0.2973333333333333}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.5139999999999999, "RandomOpTestCase": 0.4883333333333333, "ReduceTestCase": 0.7576666666666666, "TestMemoryEfficientOpAuthoring": 0.0003333333333333333}, "functorch/test_minifier": {"TestMinifier": 1.3426666666666665}, "functorch/test_ops": {"TestOperatorsCPU": 38.754333333337954}, "functorch/test_parsing": {"TestAnonymousAxis": 0.16766666666666666, "TestParsedExpression": 0.028666666666666663, "TestParsingUtils": 0.033, "TestValidateRearrangeExpressions": 0.030666666666666665}, "functorch/test_rearrange": {"TestRearrange": 4.022666666666667}, "functorch/test_vmap": {"TestRandomnessCPU": 149.888, "TestTransformFailureCPU": 0.07133333333333333, "TestVmapAPI": 46.02333333333333, "TestVmapBatchedGradientCPU": 35.625, "TestVmapDeviceTypeCPU": 1.8893333333333333, "TestVmapNestedTensorCPU": 2.5173333333333336, "TestVmapOperators": 1129.3383333333334, "TestVmapOperatorsOpInfoCPU": 34.68966666666682}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 13.202999999999685}, "higher_order_ops/test_with_effects": {"TestWithEffects": 7.158666666666668}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 18.93766666666667}, "inductor/test_binary_folding": {"FreezingCpuTests": 20.526}, "inductor/test_codecache": {"TestFxGraphCache": 18.68966666666667, "TestFxGraphCacheHashing": 0.8130000000000001, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.1725}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 181.41200000000032, "TestCompiledAutograd": 30.3225}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 162.66466666666676}, "inductor/test_config": {"TestInductorConfig": 3.524499999999999}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 178.40799999999996, "TestCppWrapper": 181.92900000000003}, "inductor/test_cpu_repro": {"CPUReproTests": 330.3435000000002}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 3.981666666666667}, "inductor/test_debug_trace": {"TestDebugTrace": 1.7309999999999999}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.001}, "inductor/test_extension_backend": {"ExtensionBackendTests": 2.9415}, "inductor/test_foreach": {"ForeachTests": 12.055499999999988}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuTests": 39.119}, "inductor/test_fx_fusion": {"TestFxFusion": 0.6626666666666666}, "inductor/test_group_batch_fusion": {"TestGroupBatchFusion": 0.0, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.028499999999999998, "TestIndexingSimplification": 0.3095}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 34.349333333333334}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_minifier": {"MinifierTests": 20.727000000000004}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 63.14566666666667, "TestPatternMatcher": 559.6676666666667}, "inductor/test_mmdecomp": {"TestDecompCPU": 27.10766666666667}, "inductor/test_profiler": {"DynamoProfilerTests": 0.0025}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 6.8069999999999995}, "inductor/test_torchinductor": {"CpuTests": 824.9639999999999, "SweepInputsCpuTest": 85.0695, "TestFull": 8.937000000000001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 759.1099999999989}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 862.2619999999996, "TestInductorDynamicCPU": 20.625}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 2732.8823333333326}, "lazy/test_debug_util": {"DebugUtilTest": 0.4993333333333334}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.5093333333333333}, "lazy/test_generator": {"LazyGeneratorTest": 0.305}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.22400000000000006}, "lazy/test_step_closures": {"ClosuresTest": 2.422333333333333}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.13566666666666666, "TestLazyOpInfoCPU": 2.835333333333321, "TestLazyTensor": 0.1566666666666667}, "nn/test_convolution": {"TestConvolutionNN": 23.963000000000005, "TestConvolutionNNDeviceTypeCPU": 206.34599999999992}, "nn/test_dropout": {"TestDropoutNN": 0.9176666666666667, "TestDropoutNNDeviceTypeCPU": 5.519666666666666}, "nn/test_embedding": {"TestEmbeddingNN": 4.384999999999999, "TestEmbeddingNNDeviceTypeCPU": 235.11299999999991}, "nn/test_init": {"TestNNInit": 1.7409999999999994}, "nn/test_lazy_modules": {"TestLazyModules": 12.810999999999998}, "nn/test_load_state_dict": {"TestLoadStateDict": 3.5483333333333325, "TestLoadStateDictSwap": 0.017333333333333333}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.49000000000000005, "TestModuleHookNN": 2.3223333333333334, "TestModuleHooks": 13.951333333333332, "TestStateDictHooks": 1.5213333333333336}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 24.473333333333333, "TestMultiheadAttentionNNDeviceTypeCPU": 1.4983333333333333}, "nn/test_packed_sequence": {"PackedSequenceTest": 6.8643333333333345}, "nn/test_parametrization": {"TestNNParametrization": 17.340666666666664, "TestNNParametrizationDeviceCPU": 0.12233333333333334}, "nn/test_pooling": {"TestAvgPool": 3.268666666666667, "TestPoolingNN": 1.3186666666666669, "TestPoolingNNDeviceTypeCPU": 54.27700000000001}, "nn/test_pruning": {"TestPruningNN": 6.614}, "profiler/test_execution_trace": {"TestExecutionTrace": 1.3743333333333332}, "profiler/test_memory_profiler": {"TestDataFlow": 0.0, "TestIdentifyGradients": 0.0, "TestMemoryProfiler": 0.001, "TestMemoryProfilerE2E": 0.0}, "profiler/test_profiler": {"TestExecutionTrace": 9.606666666666667, "TestExperimentalUtils": 37.038666666666664, "TestProfiler": 52.72433333333333, "TestProfilerCUDA": 0.0, "TestProfilerITT": 0.18133333333333335, "TestRecordFunction": 0.2293333333333333, "TestTorchTidyProfiler": 14.921999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 46.87733333333333}, "profiler/test_record_function": {"TestRecordFunction": 0.49433333333333335}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.957000000000001}, "test_ao_sparsity": {"TestActivationSparsifier": 0.009333333333333332, "TestBaseDataScheduler": 0.48066666666666674, "TestBaseDataSparsifier": 2.9896666666666665, "TestBaseSparsifier": 0.4663333333333333, "TestBaseStructuredSparsifier": 33.213, "TestComposability": 2.763333333333333, "TestCubicScheduler": 0.6373333333333333, "TestFPGMPruner": 1.0533333333333335, "TestFakeSparsity": 3.9283333333333332, "TestFxComposability": 10.249333333333333, "TestNearlyDiagonalSparsifier": 12.743333333333334, "TestNormDataSparsifiers": 5.870333333333334, "TestQuantizationUtils": 0.5993333333333334, "TestQuantizedSparseKernels": 0.12066666666666666, "TestQuantizedSparseLayers": 0.019999999999999997, "TestSaliencyPruner": 0.357, "TestScheduler": 0.7643333333333334, "TestSparsityUtilFunctions": 0.31133333333333335, "TestWeightNormSparsifier": 1.5496666666666667}, "test_autocast": {"TestAutocastCPU": 12.833666666666666, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.10833333333333334}, "test_autograd": {"TestAllowMutationOnSaved": 0.43733333333333335, "TestAutograd": 64.15800000000002, "TestAutogradComplex": 0.757, "TestAutogradDeviceTypeCPU": 8.261666666666667, "TestAutogradForwardMode": 2.583333333333334, "TestAutogradForwardModeBatchedGrad": 0.5043333333333333, "TestAutogradFunctional": 49.53733333333332, "TestAutogradInferenceMode": 1.0146666666666666, "TestAutogradLogging": 0.14500000000000002, "TestAutogradMultipleDispatchCPU": 1.0843333333333334, "TestMultithreadAutograd": 2.170666666666667, "TestNestedCheckpoint": 2.482666666666667, "TestSelectiveActivationCheckpoint": 0.1376666666666667}, "test_autograd_fallback": {"TestAutogradFallback": 1.910333333333333}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 660.438666666665}, "test_bundled_inputs": {"TestBundledInputs": 2.316333333333333}, "test_comparison_utils": {"TestComparisonUtils": 0.24833333333333332}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCPU": 1.0919999999999999}, "test_content_store": {"TestContentStoreCPU": 8.699333333333334}, "test_cpp_api_parity": {"TestCppApiParity": 129.8919999999997}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.9923333333333334, "TestMAIATensor": 0.4363333333333334, "TestORTTensor": 0.41700000000000004, "TestPybindTypeCasters": 0.09066666666666667, "TestRNGExtension": 0.009, "TestTorchLibrary": 0.008}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 1.0006666666666666, "TestMAIATensor": 0.438, "TestORTTensor": 0.4176666666666667, "TestPybindTypeCasters": 0.09166666666666667, "TestRNGExtension": 0.009, "TestTorchLibrary": 0.008}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 30.721}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.629}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 4.3726666666666665}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.6283333333333334}, "test_custom_ops": {"MiniOpTest": 9.025333333333334, "MiniOpTestOther": 0.4526666666666667, "TestCustomOp": 12.585333333333333, "TestCustomOpAPI": 1.0610000000000002, "TestCustomOpTestingCPU": 2.773333333333332, "TestGenerateOpcheckTests": 3.5073333333333334}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 34.26233333333334, "TestConcatDataset": 0.17866666666666667, "TestConvAfterFork": 0.13033333333333333, "TestCustomPinFn": 0.01933333333333333, "TestDataLoader": 102.51966666666665, "TestDataLoaderDeviceTypeCPU": 0.04533333333333334, "TestDataLoaderPersistentWorkers": 136.2413333333333, "TestDatasetRandomSplit": 3.477666666666666, "TestDictDataLoader": 0.157, "TestIndividualWorkerQueue": 0.011999999999999999, "TestNamedTupleDataLoader": 0.10933333333333334, "TestSetAffinity": 0.17466666666666666, "TestStackDataset": 0.6463333333333333, "TestStringDataLoader": 0.010666666666666666, "TestTensorDataset": 0.308}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.04033333333333333, "TestDataChunk": 0.2086666666666667, "TestDataFramesPipes": 0.051333333333333335, "TestFunctionalIterDataPipe": 4.6546666666666665, "TestFunctionalMapDataPipe": 1.4623333333333335, "TestGraph": 0.30933333333333335, "TestIterDataPipeCountSampleYielded": 0.06433333333333333, "TestIterDataPipeGraphFastForward": 2.437, "TestIterDataPipeSingletonConstraint": 0.17633333333333334, "TestIterableDataPipeBasic": 0.89, "TestSerialization": 6.5120000000000005, "TestSharding": 0.438, "TestStreamWrapper": 0.17366666666666672, "TestTyping": 0.061}, "test_decomp": {"DecompOneOffTestsCPU": 0.606, "HasDecompTest": 0.23266666666666666, "TestDecompCPU": 13.210999999999496}, "test_deploy": {"TestFreezer": 0.19733333333333336}, "test_dispatch": {"TestDispatch": 37.379333333333335, "TestPythonDispatcher": 0.09266666666666667}, "test_dlpack": {"TestTorchDlPackCPU": 9.380666666666665}, "test_dynamic_shapes": {"TestDimConstraints": 2.5690000000000004, "TestFloorDiv": 0.5326666666666667, "TestGuardsExpressions": 0.17833333333333332, "TestPySymInt": 0.0026666666666666666, "TestSymNumberMagicMethods": 0.0033333333333333335}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 8.509666666666662, "TestExpandedWeightHelperFunctionCPU": 1.1930000000000003, "TestExpandedWeightModuleCPU": 24.174999999999997}, "test_fake_tensor": {"FakeTensorConstHandling": 0.27999999999999997, "FakeTensorConverterTest": 0.29633333333333334, "FakeTensorDispatchCache": 1.1136666666666666, "FakeTensorOpInfoTestCPU": 0.09400000000000001, "FakeTensorOperatorInvariants": 0.37733333333333346, "FakeTensorPropTest": 0.231, "FakeTensorSerialization": 0.07233333333333332, "FakeTensorTest": 3.9706666666666677, "PropagateRealTensorsFakeTensorConstHandling": 0.08466666666666667, "PropagateRealTensorsFakeTensorConverterTest": 0.08633333333333332, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.09399999999999999, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.10300000000000002, "PropagateRealTensorsFakeTensorPropTest": 0.03566666666666667, "PropagateRealTensorsFakeTensorTest": 0.44166666666666704}, "test_flop_counter": {"TestFlopCounter": 0.0}, "test_foreach": {"TestForeachCPU": 32.26266666666681}, "test_function_schema": {"TestFunctionSchema": 0.7416666666666667}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 33.822}, "test_functional_optim": {"TestFunctionalOptimParity": 1.1986666666666665}, "test_functionalization": {"TestCrossRefFunctionalization": 0.0016666666666666668, "TestFunctionalization": 0.004}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.17366666666666664}, "test_futures": {"TestFuture": 3.016666666666667}, "test_fx": {"AnnotationsTest": 0.06533333333333334, "TestCSEPass": 2.355, "TestCommonPass": 0.6516666666666665, "TestConstFold": 1.7096666666666664, "TestConstParamShapeInControlFlow": 3.0593333333333335, "TestDCE": 0.32999999999999996, "TestFX": 137.8496666666667, "TestFXAPIBackwardCompatibility": 3.188333333333333, "TestFunctionalTracing": 73.14599999999997, "TestMatcher": 0.899, "TestOperatorSignaturesCPU": 15.084666666666712, "TestPassManager": 0.5276666666666667, "TestSourceMatcher": 1.7596666666666667, "TestSubgraphRewriter": 1.5810000000000002, "TestVisionTracing": 0.001, "TypeCheckerTest": 5.733666666666667}, "test_fx_experimental": {"TestFXExperimental": 368.7533333333333, "TestNormalizeOperatorsCPU": 6.56800000000003, "TestTranslationValidation": 0.3006666666666667}, "test_fx_passes": {"TestFXGraphPasses": 9.076666666666668, "TestFXMatcherUtils": 0.27333333333333343}, "test_fx_reinplace_pass": {"TestReinplacePass": 2.031333333333333}, "test_import_stats": {"TestImportTime": 3.264}, "test_indexing": {"NumpyTestsCPU": 1.4856666666666667, "TestIndexingCPU": 100.95666666666669}, "test_itt": {"TestItt": 0.18299999999999997}, "test_jit": {"TestAliasAnalysis": 0.525, "TestAsync": 2.2636666666666665, "TestAtenPow": 4.617999999999999, "TestAutodiffJit": 0.054333333333333324, "TestAutodiffSubgraphSlicing": 1.8369999999999997, "TestAwait": 1.9423333333333332, "TestBackends": 13.651666666666666, "TestBackendsWithCompiler": 6.302, "TestBatchMM": 1.1293333333333333, "TestBuiltins": 0.3256666666666667, "TestClassType": 3.7249999999999996, "TestComplex": 1.9666666666666666, "TestCustomOperators": 0.65, "TestDCE": 0.05499999999999999, "TestDataParallel": 0.04033333333333333, "TestDataclasses": 9.568, "TestDeviceAnalysis": 6.760000000000001, "TestDict": 0.2573333333333334, "TestDtypeAnalysis": 6.108333333333333, "TestDtypeCustomRulesCPU": 5.704666666666658, "TestEnum": 0.4376666666666667, "TestFreezing": 0.46000000000000024, "TestFrontend": 0.5780000000000001, "TestFrozenOptimizations": 0.2796666666666669, "TestFunctionalBlocks": 0.3913333333333333, "TestFunctionalToInplaceActivation": 6.037, "TestGenerator": 0.5863333333333334, "TestGetDefaultAttr": 0.09666666666666666, "TestGraphRewritePasses": 0.07166666666666667, "TestHash": 0.38800000000000007, "TestHooks": 2.5020000000000002, "TestIgnorableArgs": 0.059, "TestIgnoreContextManager": 0.2823333333333334, "TestInplaceToFunctionalActivation": 5.353666666666666, "TestIsinstance": 1.0820000000000005, "TestJit": 17.62333333333333, "TestJitGeneratedModule": 44.92033333333344, "TestJitProfiler": 0.8473333333333333, "TestJitUtils": 0.337, "TestList": 7.935999999999999, "TestLogging": 0.2986666666666667, "TestMKLDNNReinplacing": 0.030333333333333334, "TestMisc": 1.7199999999999998, "TestMixTracingScripting": 0.1613333333333334, "TestModels": 4.297, "TestModuleAPIs": 0.18233333333333332, "TestModuleContainers": 3.3226666666666667, "TestModuleInterface": 0.9220000000000003, "TestModules": 0.043666666666666666, "TestNamedTuple": 0.25200000000000006, "TestNnapiBackend": 0.2346666666666668, "TestOpDecompositions": 0.30633333333333335, "TestOptimizeForMobilePreserveDebugInfo": 0.369, "TestParametrization": 0.9099999999999998, "TestPeephole": 6.830666666666668, "TestProducerVersion": 0.015, "TestProfiler": 0.10666666666666669, "TestPythonBindings": 0.987, "TestPythonBuiltinOP": 4.273333333333333, "TestPythonIr": 0.4040000000000001, "TestRecursiveScript": 2.5339999999999994, "TestRemoveMutation": 3.507, "TestSaveLoad": 1.0440000000000003, "TestSaveLoadFlatbuffer": 0.5176666666666668, "TestSaveLoadForOpVersion": 2.3333333333333335, "TestScript": 75.76233333333342, "TestScriptDict": 0.4663333333333333, "TestScriptList": 1.3666666666666665, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.5446666666666667, "TestScriptProfile": 22.84866666666667, "TestSlice": 0.6970000000000001, "TestSparse": 0.19966666666666666, "TestStringFormatting": 0.4366666666666668, "TestSymbolicShapeAnalysis": 33.114, "TestTensorBuiltins": 0.559, "TestTensorCreationOps": 0.20633333333333334, "TestTensorMethods": 0.1466666666666667, "TestTorchbind": 0.23366666666666683, "TestTracer": 1.0683333333333336, "TestTypeSharing": 1.3230000000000002, "TestTypesAndAnnotation": 0.6383333333333334, "TestTyping": 2.169, "TestUnion": 2.7093333333333334, "TestUnsupportedOps": 0.15633333333333332, "TestUpgraders": 1.814, "TestWarn": 0.39099999999999996, "TestWith": 0.8643333333333333}, "test_jit_autocast": {"TestAutocast": 0.0016666666666666668, "TestJitTraceAutocast": 0.0}, "test_jit_disabled": {"TestJitDisabled": 0.2856666666666667}, "test_jit_fuser_te": {"TestFuserCommon": 0.43166666666666664, "TestLoopnestRandomizationCPU": 0.8083333333333332, "TestNNCOpInfoCPU": 63.0750000000021, "TestTEFuserDynamic": 145.48566666666667, "TestTEFuserStatic": 111.375}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 1.1063333333333334, "TestFusionPatternCPU": 14.601333333333331, "TestModel": 5.845000000000002, "TestOpCPU": 34.71333333333334}, "test_legacy_vmap": {"TestVmapAPI": 1.2593333333333323, "TestVmapAPILegacy": 13.143, "TestVmapBatchedGradientCPU": 0.07433333333333338, "TestVmapBatchedGradientLegacyCPU": 16.455666666666662, "TestVmapOperators": 1.0486666666666669, "TestVmapOperatorsLegacy": 116.17433333333331}, "test_license": {"TestLicense": 0.169}, "test_linalg": {"TestLinalgCPU": 1807.9679999999998}, "test_logging": {"LoggingTest": 2.254}, "test_masked": {"TestMaskedCPU": 36.584666666666635}, "test_maskedtensor": {"TestBasicsCPU": 6.252666666666666, "TestBinary": 7.8870000000000005, "TestOperatorsCPU": 7.530000000000018, "TestReductions": 4.868000000000001, "TestUnary": 18.033}, "test_meta": {"TestMetaCPU": 68.52100000000638, "TestMetaConverter": 2.840333333333333}, "test_mkl_verbose": {"TestMKLVerbose": 3.426}, "test_mkldnn": {"TestMkldnnCPU": 135.724}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.1973333333333334}, "test_mobile_optimizer": {"TestOptimizer": 5.019666666666667}, "test_model_dump": {"TestModelDump": 2.5796666666666663}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.11599999999999999}, "test_module_init": {"TestModuleInitCPU": 150.69100000000023}, "test_module_tracker": {"TestModuleTracker": 0.49933333333333324}, "test_modules": {"TestModuleCPU": 33.06466666666647}, "test_monitor": {"TestMonitor": 0.18933333333333335, "TestMonitorTensorboard": 0.0}, "test_multiprocessing": {"TestMultiprocessing": 26.26466666666667}, "test_multiprocessing_spawn": {"ErrorTest": 0.028666666666666663, "ForkTest": 0.8133333333333331, "SpawnTest": 28.715666666666667}, "test_namedtensor": {"TestNamedTensor": 7.540333333333333}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.8993333333333335}, "test_native_functions": {"TestNativeFunctions": 0.7306666666666669}, "test_native_mha": {"TestMHADeviceTypeCPU": 23.313666666666666}, "test_nestedtensor": {"TestNestedTensor": 3.139333333333333, "TestNestedTensorAutogradCPU": 5.449666666666668, "TestNestedTensorDeviceTypeCPU": 12.750333333333337, "TestNestedTensorSubclassCPU": 52.264333333333354}, "test_nn": {"TestAddRelu": 0.13133333333333333, "TestConstantPadNd": 0.10933333333333335, "TestFunctionalPickle": 0.014333333333333332, "TestFusionEval": 0.9926666666666667, "TestFusionUtils": 0.35600000000000004, "TestNN": 136.229, "TestNNDeviceTypeCPU": 563.8826666666669, "TestUtils": 0.023000000000000003}, "test_numba_integration": {"TestNumbaIntegration": 0.17466666666666672}, "test_numpy_interop": {"TestNumPyInteropCPU": 8.590000000000002}, "test_openmp": {"TestOpenMP_ParallelFor": 6.638999999999999}, "test_ops": {"TestCommonCPU": 34.196999999999335, "TestCompositeComplianceCPU": 4.984999999999785, "TestFakeTensorCPU": 3.2426666666664232, "TestMathBitsCPU": 3.0643333333332006, "TestRefsOpsInfoCPU": 1.5106666666666315, "TestSelfKwarg": 0.2086666666666667, "TestTagsCPU": 1.302999999999984}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 4.05166666666645}, "test_ops_gradients": {"TestBwdGradientsCPU": 7.247333333333319}, "test_ops_jit": {"TestJitCPU": 1.783333333333306}, "test_optim": {"TestDifferentiableOptimizer": 0.11966666666666664, "TestLRScheduler": 15.24233333333333, "TestOptim": 0.12300000000000003, "TestOptimRenewedCPU": 342.69833333333355, "TestSWAUtils": 6.008333333333333}, "test_out_dtype_op": {"TestOutDtypeOp": 1.1216666666666668}, "test_overrides": {"TestBroadcastAllOverride": 0.409, "TestDisabledTorchFunction": 0.012000000000000002, "TestDisabledUserWarnings": 0.018, "TestEinsumOverride": 0.6743333333333333, "TestGradCheckOverride": 0.47333333333333333, "TestGradNewOnesOverride": 0.009666666666666665, "TestIndexing": 0.09300000000000001, "TestIterator": 0.01, "TestNamedTuple": 0.01, "TestPickle": 0.009, "TestRNN": 0.07733333333333332, "TestResolveName": 0.21233333333333335, "TestTorchFunctionMode": 0.3986666666666667, "TestTorchFunctionOverride": 252.19966666667074, "TestTorchFunctionWarning": 0.027, "TestWrapTorchFunction": 0.010333333333333333}, "test_package": {"DirectoryReaderTest": 8.727666666666666, "ModelTest": 0.023000000000000003, "TestAnalyze": 1.3303333333333331, "TestDependencyAPI": 21.67, "TestDependencyHooks": 6.510333333333333, "TestDiGraph": 14.616999999999999, "TestGlobGroup": 18.44066666666667, "TestImporter": 7.472666666666666, "TestLoadBCPackages": 3.9090000000000003, "TestMangling": 13.057000000000002, "TestMisc": 14.796, "TestPackageFX": 8.045333333333334, "TestPackageScript": 33.52233333333334, "TestRepackage": 1.8816666666666666, "TestResources": 4.871666666666666, "TestSaveLoad": 13.611333333333334}, "test_per_overload_api": {"TestPerOverloadAPI": 1.062}, "test_prims": {"TestDecompCPU": 0.018333333333333337, "TestPrimsBasic": 0.37399999999999994, "TestPrimsCPU": 0.6973333333333334, "TestRefsCPU": 0.22599999999999998}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.39399999999999996, "TestGenericProxyTensorFake": 12.987, "TestGenericProxyTensorReal": 14.95433333333333, "TestGenericProxyTensorSymbolic": 28.369333333333334, "TestProxyTensorOpInfoCPU": 33.30100000000089, "TestRealProxyTensor": 0.02, "TestSymbolicTracing": 9.713000000000001}, "test_pruning_op": {"PruningOpTest": 0.21566666666666667}, "test_public_bindings": {"TestPublicBindings": 0.7396666666666668}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.4526666666666666, "TestPythonDispatch": 5.114666666666665, "TestPythonDispatcher": 0.11766666666666666, "TestPythonRegistration": 3.1726666666666667, "TestWrapperSubclassAliasingCPU": 0.5666666666666668}, "test_pytree": {"TestCxxPytree": 1.4313333333333331, "TestGenericPytree": 3.4343333333333326, "TestPythonPytree": 3.2870000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.121, "TestAOMigrationNNQuantized": 0.17366666666666672, "TestAOMigrationQuantization": 0.1416666666666667, "TestAOMigrationQuantizationFx": 0.323, "TestBackendConfig": 4.029, "TestBiasCorrectionEager": 2.9819999999999998, "TestBitsCPU": 0.3376666666666666, "TestComparatorOps": 2.3716666666666666, "TestDeprecatedJitQuantized": 4.976, "TestDistributed": 0.7216666666666667, "TestDuplicateDQPass": 9.349000000000002, "TestDynamicQuantizedModule": 65.986, "TestDynamicQuantizedOps": 35.56366666666667, "TestEqualizeEager": 2.7296666666666667, "TestEqualizeFx": 44.476333333333336, "TestFXGraphMatcher": 4.628666666666667, "TestFXGraphMatcherModels": 7.2683333333333335, "TestFXNumericSuiteCoreAPIs": 62.068000000000005, "TestFXNumericSuiteCoreAPIsModels": 39.341, "TestFXNumericSuiteNShadows": 50.796000000000014, "TestFakeQuantize": 4.4239999999999995, "TestFakeQuantizeOps": 18.168000000000003, "TestFloat8DtypeCPU": 4.172000000000001, "TestFloat8DtypeCPUOnlyCPU": 0.42766666666666664, "TestFuseEager": 14.225333333333333, "TestFuseFx": 7.395666666666668, "TestFusedObsFakeQuant": 1.9473333333333336, "TestFusedObsFakeQuantModule": 1.7060000000000002, "TestFusionPasses": 0.043666666666666666, "TestFxDetectInputWeightEqualization": 2.654333333333333, "TestFxDetectOutliers": 3.2539999999999996, "TestFxModelReportClass": 8.301666666666668, "TestFxModelReportDetectDynamicStatic": 0.574, "TestFxModelReportDetector": 3.668333333333333, "TestFxModelReportObserver": 2.94, "TestFxModelReportVisualizer": 6.95, "TestGenerateNumericDebugHandle": 0.5646666666666667, "TestGraphUtils": 1.7753333333333334, "TestHistogramObserver": 32.446000000000005, "TestMetaDataPorting": 14.428333333333333, "TestModelNumericsEager": 2.9293333333333336, "TestNumericSuiteEager": 39.29366666666667, "TestObserver": 5.949666666666666, "TestPT2ERepresentation": 2.151, "TestPadding": 15.625333333333336, "TestQNNPackOps": 7.880000000000002, "TestQuantizationDocs": 0.07266666666666667, "TestQuantizeDynamicJitOps": 2.2836666666666665, "TestQuantizeDynamicJitPasses": 6.196000000000001, "TestQuantizeEagerOps": 7.878333333333334, "TestQuantizeEagerPTQDynamic": 16.774333333333335, "TestQuantizeEagerPTQStatic": 41.55466666666666, "TestQuantizeEagerQAT": 35.36633333333333, "TestQuantizeEagerQATNumerics": 38.517, "TestQuantizeFx": 130.30233333333334, "TestQuantizeFxModels": 22.093, "TestQuantizeFxOps": 277.74566666666664, "TestQuantizeJit": 27.420666666666666, "TestQuantizeJitOps": 233.06066666666666, "TestQuantizeJitPasses": 11.331333333333335, "TestQuantizePT2E": 51.554, "TestQuantizePT2EQATModels": 1.9023333333333332, "TestQuantizePT2EQAT_ConvBn1d": 53.73466666666666, "TestQuantizePT2EQAT_ConvBn2d": 45.19800000000001, "TestQuantizePT2EX86Inductor": 86.81, "TestQuantizedConv": 77.12499999999999, "TestQuantizedEmbeddingOps": 10.196333333333333, "TestQuantizedFunctionalOps": 4.013333333333333, "TestQuantizedLinear": 26.266000000000002, "TestQuantizedOps": 175.74733333333336, "TestQuantizedTensor": 62.53800000000003, "TestRecordHistogramObserver": 0.162, "TestReferenceQuantizedModule": 1.321, "TestSerialization": 7.286666666666666, "TestStaticQuantizedModule": 134.48633333333336, "TestSubgraphRewriter": 2.692, "TestUtils": 1.461, "TestXNNPACKQuantizer": 28.456666666666663, "TestXNNPACKQuantizerModels": 2.4283333333333332}, "test_reductions": {"TestReductionsCPU": 487.57533333331986}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 138.31966666666665}, "test_schema_check": {"TestSchemaCheck": 0.4740000000000002, "TestSchemaCheckModeOpInfoCPU": 56.370666666668484}, "test_segment_reductions": {"TestSegmentReductionsCPU": 28.87966666666667}, "test_serialization": {"TestBothSerializationCPU": 0.16933333333333334, "TestOldSerialization": 34.162, "TestSerialization": 25.112000000000005, "TestSubclassSerialization": 0.43133333333333335}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.21}, "test_shape_ops": {"TestShapeOpsCPU": 15.162666666666667}, "test_show_pickle": {"TestShowPickle": 0.19633333333333333}, "test_sort_and_select": {"TestSortAndSelectCPU": 46.399333333333324}, "test_sparse": {"TestSparseAnyCPU": 373.17199999999866, "TestSparseCPU": 472.36433333333326, "TestSparseLegacyAndDeprecation": 0.119, "TestSparseMaskedReductionsCPU": 0.36366666666666675, "TestSparseMeta": 48.629, "TestSparseOneOff": 0.12833333333333333, "TestSparseUnaryUfuncsCPU": 12.608000000000061}, "test_sparse_csr": {"TestSparseCSRCPU": 194.6493333333332, "TestSparseCSRSampler": 0.738, "TestSparseCompressedCPU": 166.45900000000006, "TestSparseCompressedTritonKernelsCPU": 0.09100000000000001}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.1376666666666667}, "test_spectral_ops": {"TestFFTCPU": 28.611000000000022, "TestFFTDocExamplesCPU": 0.45133333333333353}, "test_stateless": {"TestPythonOptimizeMode": 3.465666666666667, "TestStatelessDeprecation": 1.58, "TestStatelessFunctionalAPI": 10.497}, "test_subclass": {"TestSubclass": 3.824999999999998}, "test_sympy_utils": {"TestNumbers": 0.3593333333333333, "TestSingletonInt": 0.02666666666666667, "TestSympyInterp": 33.03666666666667, "TestSympySolve": 1.2266666666666666, "TestValueRanges": 6.481333333333332}, "test_tensor_creation_ops": {"TestAsArrayCPU": 93.16033333333341, "TestBufferProtocolCPU": 41.79533333333333, "TestLikeTensorCreationCPU": 0.2816666666666667, "TestRandomTensorCreationCPU": 24.52566666666668, "TestTensorCreationCPU": 63.16333333333338}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.7136666666666667, "TestTensorBoardFigure": 0.017666666666666667, "TestTensorBoardNumpy": 0.06966666666666667, "TestTensorBoardPyTorchNumpy": 0.4223333333333334, "TestTensorBoardPytorchGraph": 32.116, "TestTensorBoardSummary": 1.9203333333333334, "TestTensorBoardSummaryWriter": 0.054666666666666676, "TestTensorBoardUtils": 0.753, "TestTensorBoardWriter": 0.576, "TestTensorProtoSummary": 0.3263333333333333}, "test_tensorexpr": {"TestTensorExprFuser": 0.0023333333333333335}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.10333333333333333, "TestTensorExprPyBind": 3.421333333333333}, "test_testing": {"TestAssertClose": 2.090666666666666, "TestAssertCloseContainer": 0.30866666666666664, "TestAssertCloseErrorMessage": 0.6336666666666667, "TestAssertCloseQuantized": 0.20099999999999998, "TestAssertCloseSparseBSC": 0.12566666666666668, "TestAssertCloseSparseBSR": 0.12666666666666668, "TestAssertCloseSparseCOO": 0.832, "TestAssertCloseSparseCSC": 0.12166666666666666, "TestAssertCloseSparseCSR": 0.15133333333333335, "TestFrameworkUtils": 10.963333333333333, "TestImports": 12.430333333333332, "TestMakeTensorCPU": 54.86166666666666, "TestOpInfoSampleFunctionsCPU": 11.172333333333368, "TestOpInfos": 0.017333333333333336, "TestTestParametrization": 0.15733333333333338, "TestTestParametrizationDeviceTypeCPU": 3.853666666666665, "TestTestingCPU": 1.661666666666667}, "test_torch": {"TestBasicVitalSigns": 0.18800000000000003, "TestTorch": 39.095666666666695, "TestTorchDeviceTypeCPU": 189.57166666666603, "TestVitalSignsCudaCPU": 0.009}, "test_transformers": {"TestAttnBiasCPU": 17.66633333333333, "TestAttnMasksCPU": 0.23333333333333342, "TestSDPACPU": 757.5106666666665, "TestSDPAFailureModesCPU": 0.4493333333333334, "TestTransformersCPU": 140.868}, "test_type_hints": {"TestTypeHints": 0.16866666666666666}, "test_type_info": {"TestDTypeInfo": 0.7256666666666668}, "test_type_promotion": {"TestTypePromotionCPU": 63.32900000000023}, "test_typing": {"TestTyping": 71.09766666666668}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 249.30499999997835}, "test_utils": {"TestAssert": 0.09400000000000001, "TestBottleneck": 8.171000000000001, "TestCheckpoint": 2.835666666666666, "TestCollectEnv": 0.9883333333333333, "TestCppExtensionUtils": 0.13833333333333334, "TestDataLoaderUtils": 4.282333333333333, "TestDeviceUtilsCPU": 51.27866666666864, "TestExtensionUtils": 0.10133333333333334, "TestHipify": 0.007, "TestHipifyTrie": 0.10799999999999998, "TestONNXUtils": 0.016666666666666666, "TestRenderUtils": 0.09066666666666667, "TestStandaloneCPPJIT": 1.7213333333333332, "TestTraceback": 0.042333333333333334}, "test_view_ops": {"TestOldViewOpsCPU": 26.12966666666668, "TestViewOpsCPU": 22.686000000000007, "TestViewOpsLAZY": 5.043333333333333}, "test_vulkan": {"TestVulkanRewritePass": 0.0006666666666666666}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.11133333333333333, "WeakKeyDictionaryTestCase": 0.2333333333333333, "WeakTest": 4.864333333333334}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 33.09366666666667, "TestXNNPACKOps": 9.337666666666665, "TestXNNPACKRewritePass": 1.9326666666666668, "TestXNNPACKSerDes": 5.386666666666667}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.8546666666666671}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.7343333333333337, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.018, "TestMisc": 0.02466666666666667, "TestPickling": 0.2633333333333335, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 28.043999999999997, "TestEinsumPath": 0.0, "TestMisc": 0.11133333333333334}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.20333333333333334, "TestHalf": 0.0, "TestIinfo": 0.08033333333333333, "TestMisc": 0.03266666666666667, "TestPythonFloat": 0.0003333333333333333, "TestRepr": 0.022333333333333334, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.06066666666666667, "TestBooleanIndexing": 0.10866666666666668, "TestBroadcastedAssignments": 0.2326666666666667, "TestFancyIndexingCast": 0.12966666666666668, "TestFloatNonIntegerArgument": 0.12466666666666665, "TestIndexing": 2.2046666666666663, "TestMultiIndexingAutomated": 0.21833333333333335, "TestMultipleEllipsisError": 0.03333333333333333, "TestNonIntegerArrayLike": 0.007666666666666666}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.18233333333333332, "TestArgmax": 2.29, "TestArgmaxArgminCommon": 18.937333333333342, "TestArgmin": 2.3599999999999994, "TestArrayAttributeDeletion": 0.11066666666666665, "TestArrayConstruction": 0.6703333333333336, "TestArrayCreationCopyArgument": 0.8113333333333337, "TestArrayInterface": 0.011333333333333334, "TestAssignment": 0.1366666666666667, "TestAttributes": 0.31299999999999994, "TestBinop": 0.261, "TestBool": 0.38400000000000006, "TestCequenceMethods": 0.016333333333333335, "TestChoose": 0.2926666666666667, "TestClip": 0.11366666666666665, "TestCompress": 0.11433333333333333, "TestConversion": 0.06133333333333333, "TestCreation": 0.0026666666666666666, "TestDelMisc": 0.011333333333333334, "TestDot": 0.8146666666666668, "TestDtypedescr": 0.015, "TestFancyIndexing": 0.38466666666666666, "TestFlag": 0.6100000000000002, "TestFormat": 0.09033333333333333, "TestFromBuffer": 0.155, "TestHash": 0.058666666666666666, "TestHashing": 0.04766666666666667, "TestIO": 0.0016666666666666668, "TestInner": 0.111, "TestLexsort": 0.5790000000000001, "TestMatmul": 2.289666666666666, "TestMatmulOperator": 0.5360000000000001, "TestMethods": 9.616333333333335, "TestMinMax": 0.026999999999999996, "TestMinScalarType": 0.06833333333333334, "TestNewaxis": 0.028333333333333332, "TestPEP3118Dtype": 0.0003333333333333333, "TestPutmask": 0.5823333333333334, "TestRepeat": 0.1723333333333333, "TestResize": 0.28933333333333333, "TestRichcompareScalar": 0.008, "TestScalarIndexing": 0.34833333333333333, "TestSizeOf": 0.14933333333333335, "TestSortFloatMisc": 6.021333333333334, "TestStats": 1.7776666666666667, "TestSubscripting": 0.035333333333333335, "TestTake": 0.48200000000000004, "TestVdot": 0.15266666666666667, "TestViewDtype": 0.10899999999999999, "TestWarnings": 0.043333333333333335, "TestWhere": 0.43566666666666665, "TestWritebackIfCopy": 0.2793333333333334}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.5396666666666666, "TestArgwhere": 0.6553333333333334, "TestArrayComparisons": 2.460333333333333, "TestBaseRepr": 0.18533333333333335, "TestBinaryRepr": 0.26799999999999996, "TestBoolArray": 5.010000000000001, "TestBoolCmp": 3.3066666666666666, "TestBoolScalar": 0.8223333333333334, "TestBroadcast": 0.578, "TestClip": 2.713333333333333, "TestConvolve": 0.19400000000000003, "TestCorrelate": 0.5890000000000001, "TestCreationFuncs": 0.18633333333333332, "TestCross": 0.9083333333333332, "TestDtypePositional": 0.017333333333333336, "TestFloatExceptions": 0.3326666666666666, "TestFromiter": 0.0, "TestIndex": 0.18266666666666667, "TestIndices": 0.36499999999999994, "TestIsclose": 1.3456666666666666, "TestIsscalar": 0.07, "TestLikeFuncs": 0.001, "TestMoveaxis": 0.06433333333333334, "TestNonarrayArgs": 1.1936666666666669, "TestNonzeroAndCountNonzero": 1.4676666666666665, "TestOuterMisc": 0.05533333333333334, "TestRequire": 0.06666666666666667, "TestResize": 0.5573333333333333, "TestRoll": 0.9386666666666666, "TestRollaxis": 0.057333333333333326, "TestSeterr": 0.24266666666666667, "TestStdVar": 6.365333333333333, "TestStdVarComplex": 0.081, "TestStringFunction": 0.18633333333333335, "TestTensordot": 0.09999999999999999, "TestTypes": 0.5433333333333333}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.1376666666666667, "TestCommonType": 0.27566666666666667, "TestDocStrings": 0.0003333333333333333, "TestIsSubDType": 0.08333333333333333, "TestScalarTypeNames": 0.2233333333333334}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 1.1890000000000003, "TestFromInt": 0.04066666666666666, "TestFromString": 0.49833333333333335}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.002, "TestBitCount": 0.0, "TestClassGetItem": 0.001, "TestClassGetitemMisc": 0.1426666666666667, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 1.7176666666666665, "TestBaseMath": 0.343, "TestBitShifts": 0.5300000000000002, "TestComplexDivision": 0.027999999999999997, "TestConversion": 0.13333333333333333, "TestHash": 0.0003333333333333333, "TestModulus": 0.5036666666666667, "TestMultiply": 0.0003333333333333333, "TestNegative": 0.03866666666666667, "TestPower": 0.08933333333333333, "TestRepr": 0.031, "TestScalarOpsMisc": 1.7069999999999996, "TestScalarSubclassingMisc": 0.5930000000000004, "TestSubtract": 0.038, "TestTypes": 0.334}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.5650000000000001, "TestAtleast2d": 0.156, "TestAtleast3d": 0.14866666666666667, "TestBlock": 0.18633333333333335, "TestConcatenate": 2.5666666666666664, "TestHstack": 0.2326666666666667, "TestStackMisc": 1.2140000000000002, "TestVstack": 0.216}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.008, "TestFFTShift": 0.7813333333333334, "TestIRFFTN": 0.034999999999999996, "TestRFFTFreq": 0.007666666666666666}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 78.883, "TestFFTShift": 0.303, "TestFFTThreadSafe": 1.133}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.6823333333333336}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0030000000000000005, "TestUnique": 3.833}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.032, "TestAmax": 0.053, "TestAmin": 0.056666666666666664, "TestAngle": 0.17433333333333334, "TestAny": 0.20733333333333334, "TestAverage": 0.46900000000000003, "TestBincount": 0.5493333333333333, "TestCheckFinite": 0.07266666666666667, "TestCopy": 0.06866666666666667, "TestCorrCoef": 0.48566666666666664, "TestCov": 0.8893333333333334, "TestCumprod": 0.017666666666666667, "TestCumsum": 0.02266666666666667, "TestDelete": 1.5679999999999998, "TestDiff": 1.031, "TestDigitize": 0.9050000000000001, "TestExtins": 0.32, "TestFilterwindows": 3.7073333333333323, "TestFlip": 0.20966666666666667, "TestGradient": 1.4969999999999999, "TestInsert": 2.815, "TestInterp": 15.447000000000001, "TestKaiser": 0.13966666666666666, "TestMedian": 4.972999999999999, "TestMeshgrid": 0.7810000000000001, "TestMsort": 0.0, "TestPercentile": 5.573999999999997, "TestPiecewise": 0.12200000000000001, "TestProd": 0.018333333333333337, "TestPtp": 0.10366666666666668, "TestQuantile": 0.9819999999999999, "TestRot90": 0.5313333333333333, "TestSelect": 0.07166666666666666, "TestSinc": 0.09066666666666667, "TestSortComplex": 0.29633333333333334, "TestTrapz": 0.8883333333333333, "TestTrimZeros": 0.18633333333333332, "TestUnique": 0.12366666666666666, "Test_I0": 0.25766666666666665}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 2.7306666666666666, "TestHistogramOptimBinNums": 1.336666666666667, "TestHistogramdd": 1.712}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.03133333333333333, "TestConcatenator": 0.05300000000000001, "TestDiagIndices": 0.051666666666666666, "TestDiagIndicesFrom": 0.06733333333333334, "TestFillDiagonal": 0.19433333333333333, "TestGrid": 0.09666666666666664, "TestIndexExpression": 0.159, "TestIx_": 0.05133333333333334, "TestNdIndex": 0.008666666666666668, "TestNdenumerate": 0.01, "TestRavelUnravelIndex": 1.2113333333333334}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.6703333333333333, "TestApplyOverAxes": 0.010333333333333333, "TestArraySplit": 1.3733333333333333, "TestColumnStack": 0.08733333333333333, "TestDsplit": 0.09833333333333331, "TestDstack": 0.15633333333333332, "TestExpandDims": 0.057999999999999996, "TestHsplit": 0.09499999999999999, "TestKron": 0.32833333333333337, "TestMayShareMemory": 0.09133333333333334, "TestPutAlongAxis": 0.10333333333333333, "TestSplit": 0.04633333333333334, "TestSqueeze": 0.5100000000000001, "TestTakeAlongAxis": 0.5073333333333334, "TestTile": 0.36200000000000004, "TestVsplit": 0.07766666666666668}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.5886666666666667, "TestEye": 0.7056666666666667, "TestFliplr": 0.016666666666666666, "TestFlipud": 0.051666666666666666, "TestHistogram2d": 0.5956666666666667, "TestTri": 0.2633333333333333, "TestTrilIndicesFrom": 0.015333333333333332, "TestTriuIndices": 0.07366666666666667, "TestTriuIndicesFrom": 0.015, "TestVander": 0.12366666666666666}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.009666666666666665, "TestCommonType": 0.633, "TestImag": 0.16166666666666668, "TestIscomplex": 0.04599999999999999, "TestIscomplexobj": 0.12666666666666668, "TestIsfinite": 0.30133333333333334, "TestIsinf": 0.25766666666666665, "TestIsnan": 0.2853333333333333, "TestIsneginf": 0.06066666666666667, "TestIsposinf": 0.06366666666666666, "TestIsreal": 0.06466666666666666, "TestIsrealobj": 0.049999999999999996, "TestIsscalar": 0.11666666666666665, "TestMintypecode": 0.03266666666666667, "TestNanToNum": 0.41033333333333327, "TestReal": 0.17033333333333334, "TestRealIfClose": 0.18666666666666668}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 1.6689999999999998, "TestCond": 2.1029999999999998, "TestDet": 0.3053333333333334, "TestEig": 0.3946666666666667, "TestEigh": 0.26766666666666666, "TestEighCases": 0.0, "TestEigvals": 0.3986666666666667, "TestEigvalsh": 0.2606666666666666, "TestEigvalshCases": 0.0, "TestInv": 0.41866666666666674, "TestLstsq": 3.3186666666666667, "TestMatrixRank": 0.45999999999999996, "TestMisc": 0.19433333333333333, "TestMisc2": 0.03366666666666667, "TestMultiDot": 0.46566666666666673, "TestNormDouble": 1.766333333333333, "TestNormInt64": 1.7686666666666664, "TestNormSingle": 1.6183333333333334, "TestNorm_NonSystematic": 0.024000000000000004, "TestPinv": 1.2489999999999999, "TestPinvHermitian": 0.2896666666666667, "TestQR": 4.292666666666666, "TestSVD": 0.6430000000000001, "TestSVDHermitian": 0.40666666666666673, "TestSolve": 0.9246666666666666, "TestTensorinv": 0.18733333333333332, "TestTensorsolve": 0.13033333333333333}, "torch_np/test_basic": {"TestArrayToSequence": 0.13633333333333333, "TestCopyTo": 0.12, "TestCtorNested": 0.03133333333333333, "TestDefaultDtype": 0.04666666666666667, "TestDivmod": 0.20966666666666667, "TestExport": 0.4723333333333333, "TestMisc": 0.037333333333333336, "TestNormalizations": 0.121, "TestOneArr": 5.460999999999991, "TestOneArrAndAxesTuple": 0.24266666666666667, "TestOneArrAndAxis": 2.7819999999999965, "TestOneArrAndShape": 0.414, "TestOneArrToScalar": 0.322, "TestPythonArgsToArray": 0.294, "TestSequenceOfArrays": 0.4203333333333335, "TestSequenceOfArraysToSingle": 0.233, "TestShapeLikeToArray": 0.08133333333333333, "TestSmokeNotImpl": 0.013666666666666667}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 1.8249999999999995}, "torch_np/test_dtype": {"TestConvertDType": 1.0986666666666671}, "torch_np/test_function_base": {"TestAppend": 0.32633333333333336}, "torch_np/test_ndarray_methods": {"TestAmax": 0.07533333333333332, "TestAmin": 0.209, "TestArgmax": 6.931666666666666, "TestArgmaxArgminCommon": 9.185666666666663, "TestArgmin": 1.2860000000000003, "TestContains": 0.020666666666666667, "TestIndexing": 0.30866666666666664, "TestIter": 0.04066666666666666, "TestNoExtraMethods": 0.10466666666666664, "TestNonzero": 0.3646666666666667, "TestRavel": 0.017666666666666667, "TestReshape": 0.018333333333333333, "TestTranspose": 0.017333333333333333}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 24.061666666666564, "TestNEP50Table": 0.4406666666666668}, "torch_np/test_random": {"TestChoice": 0.05233333333333334, "TestNumpyGlobal": 0.023000000000000003, "TestScalarReturn": 0.6830000000000003, "TestShuffle": 0.22566666666666665}, "torch_np/test_reductions": {"TestAll": 0.168, "TestAny": 0.13133333333333333, "TestFlatnonzero": 0.30833333333333335, "TestGenericCumSumProd": 0.18033333333333335, "TestGenericReductions": 11.577333333333252, "TestMean": 0.14300000000000002, "TestSum": 0.912}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.649666666666667, "TestIsScalar": 0.35466666666666674}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 14.834999999999988, "TestNdarrayDunderVsUfunc": 2.4123333333333328, "TestUfuncDtypeKwd": 0.041666666666666664, "TestUnaryUfuncs": 0.9810000000000006}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 1.9756666666666665}}}, "linux-focal-py3.12-clang10": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 1.7073333333333334}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.47900000000000004}, "distributions/test_constraints": {"test_constraints": 0.06900000000000005}, "distributions/test_distributions": {"TestAgainstScipy": 1.0473333333333332, "TestConstraints": 0.128, "TestDistributionShapes": 0.13466666666666674, "TestDistributions": 17.534333333333333, "TestFunctors": 0.01, "TestJit": 20.286, "TestKL": 2.764666666666667, "TestLazyLogitsInitialization": 0.012666666666666666, "TestNumericalStability": 0.07066666666666667, "TestRsample": 0.6306666666666666, "TestValidation": 0.31700000000000006}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.3076666666666667}, "dynamo/test_after_aot": {"TestAfterAot": 5.702000000000001}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 12.593333333333332}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.19466666666666665, "AOTAutogradCacheTests": 15.11266666666667}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 3.2373333333333325}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.037333333333333336, "TestCustomBackendAPI": 1.6613333333333333, "TestExplainWithBackend": 10.754333333333335, "TestOptimizations": 1.662333333333333}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 12.708}, "dynamo/test_base_output": {"TestBaseOutput": 0.0023333333333333335}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 5.988666666666667}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 5.957666666666667, "BytecodeTests": 0.49900000000000005}, "dynamo/test_compile": {"InPlaceCompilationTests": 6.95, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.4013333333333334}, "dynamo/test_config": {"ConfigTests": 0.3483333333333334}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.36999999999999994, "CppGuardManagerFuncTorchHigherOrderOpTests": 15.585333333333331, "CppGuardManagerFunctionTests": 28.986333333333345, "CppGuardManagerHigherOrderOpTests": 10.633999999999995, "CppGuardManagerMiscTests": 51.68133333333342, "CppGuardManagerReproTests": 51.53900000000002}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.3650000000000002}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.031}, "dynamo/test_decorators": {"DecoratorTests": 7.247333333333334}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.014}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 245.15733333333336, "DynamicShapesCtxManagerTests": 5.544666666666665, "DynamicShapesExportTests": 32.19133333333334, "DynamicShapesFuncTorchHigherOrderOpTests": 99.38000000000004, "DynamicShapesFunctionTests": 81.58399999999995, "DynamicShapesHigherOrderOpTests": 17.18433333333333, "DynamicShapesMiscTests": 94.44300000000005, "DynamicShapesNNModuleTests": 7.298666666666667, "DynamicShapesReproTests": 110.63100000000003, "DynamicShapesSubGraphTests": 9.826333333333332, "DynamicShapesTestSDPA": 0.3393333333333333}, "dynamo/test_exc": {"ExcTests": 1.654}, "dynamo/test_exceptions": {"ExceptionTests": 0.33733333333333343}, "dynamo/test_export": {"ExportTests": 16.655666666666665}, "dynamo/test_export_mutations": {"MutationExportTests": 0.3386666666666667}, "dynamo/test_frame_init": {"FrameInitTests": 0.026333333333333334}, "dynamo/test_functions": {"DefaultsTests": 0.8780000000000001, "FunctionTests": 17.22466666666668}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.1056666666666668}, "dynamo/test_global": {"TestGlobals": 0.3636666666666668}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.042333333333333355}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.24833333333333332, "FuncTorchHigherOrderOpTests": 13.635333333333335, "HigherOrderOpTests": 8.475, "HigherOrderOpVmapGuardTests": 3.974}, "dynamo/test_hooks": {"HooksTests": 25.242000000000004}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 10.089666666666668, "InlineInbuiltNNModulesExportTests": 17.382666666666665, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 13.45133333333333, "InlineInbuiltNNModulesFunctionTests": 30.17100000000001, "InlineInbuiltNNModulesHigherOrderOpTests": 7.711333333333333, "InlineInbuiltNNModulesMiscTests": 57.22700000000007, "InlineInbuiltNNModulesNNModuleTests": 4.905333333333332}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 7.8066666666666675}, "dynamo/test_interop": {"InteropTests": 0.36133333333333334}, "dynamo/test_logging": {"LoggingTests": 16.258333333333336}, "dynamo/test_minifier": {"MinifierTests": 1.1953333333333334}, "dynamo/test_misc": {"MiscTests": 64.79833333333342, "TestTracer": 0.05033333333333334}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0026666666666666666}, "dynamo/test_modules": {"NNModuleTests": 2.932999999999998, "OptimizedModuleTest": 17.281666666666663}, "dynamo/test_nops": {"NopTests": 0.225}, "dynamo/test_optimizers": {"End2EndTests": 0.5353333333333334}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.26466666666666666}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.9876666666666667}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.49299999999999994}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.5736666666666669}, "dynamo/test_recompiles": {"RecompileTests": 0.6173333333333334}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.337}, "dynamo/test_repros": {"ReproTests": 48.78600000000004}, "dynamo/test_resume": {"ResumeFunctionTests": 0.238}, "dynamo/test_sdpa": {"TestSDPA": 0.343}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.4453333333333334}, "dynamo/test_sources": {"SourceTests": 0.311}, "dynamo/test_structured_trace": {"StructuredTraceTest": 12.081666666666665}, "dynamo/test_subclasses": {"SubclassTests": 4.063999999999998, "TestNestedTensor": 11.118666666666668}, "dynamo/test_subgraphs": {"SubGraphTests": 2.3316666666666657}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.07100000000000001, "TraceRuleTests": 0.5619999999999999}, "dynamo/test_unspec": {"UnspecTests": 12.311666666666667}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.3593333333333333}, "dynamo/test_view": {"ViewTests": 0.421}, "export/test_converter": {"TestConverter": 6.877666666666667}, "export/test_db": {"ExampleTests": 3.0949999999999993}, "export/test_experimental": {"TestExperiment": 0.7516666666666666}, "export/test_export": {"TestDynamismExpression": 0.6133333333333334, "TestExport": 27.46666666666667, "TestExportCustomClass": 0.07666666666666666, "TestOneOffModelExportResult": 1.0656666666666668}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.65, "NonStrictExportTestExport": 28.346000000000007}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.5813333333333334, "PreDispatchExportTestExport": 27.089000000000002}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.028}, "export/test_hop": {"TestHOPCPU": 3.0043333333333333, "TestHOPGeneric": 0.0033333333333333335}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0023333333333333335, "TestLift": 0.20200000000000004, "TestLiftUnlift": 0.010666666666666666}, "export/test_pass_infra": {"TestPassInfra": 0.618}, "export/test_passes": {"TestPasses": 12.705666666666666}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.875, "RetraceExportTestExport": 43.298}, "export/test_safeguard": {"TestSafeguard": 0.727}, "export/test_schema": {"TestSchema": 0.1466666666666667}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.24833333333333332, "SerDesExportPreDispatchTestExport": 20.73866666666666, "SerDesExportTestDynamismExpression": 0.773, "SerDesExportTestExport": 33.69433333333333}, "export/test_serialize": {"TestDeserialize": 7.069333333333332, "TestOpVersioning": 0.004666666666666667, "TestSaveLoad": 0.26366666666666666, "TestSchemaVersioning": 0.028666666666666663, "TestSerialize": 0.96, "TestSerializeCustomClass": 0.077}, "export/test_sparse": {"TestSparseProp": 0.016666666666666673}, "export/test_tools": {"TestExportTools": 0.3096666666666666}, "export/test_torchbind": {"TestCompileTorchbind": 1.3016666666666667, "TestExportTorchbind": 1.697333333333333, "TestRegisterFakeClass": 0.0036666666666666666}, "export/test_tree_utils": {"TestTreeUtils": 0.015333333333333332}, "export/test_unflatten": {"TestUnflatten": 3.1336666666666666}, "export/test_upgrade": {"TestUpgrade": 0.30200000000000005}, "export/test_verifier": {"TestVerifier": 0.6683333333333333}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.861666666666665, "TestAOTAutogradWithDynamo": 16.000666666666667, "TestAOTDispatch": 0.5003333333333334, "TestAOTExport": 2.524666666666666, "TestAOTModuleSimplified": 0.5966666666666667, "TestEagerFusionModuleInfoCPU": 896.7313333333333, "TestEagerFusionOpInfoCPU": 2172.6250000000014, "TestPartitioning": 1.1766666666666667, "TestPythonKeyCPU": 1.2096666666666667}, "functorch/test_control_flow": {"TestControlFlow": 0.5346666666666667, "TestControlFlowTraced": 124.59466666666663}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.08933333333333338, "TestAutogradFunctionVmapAPICPU": 0.02466666666666667, "TestCompileTransformsCPU": 8.032, "TestComposabilityCPU": 1.8349999999999997, "TestExamplesCorrectnessCPU": 4.558999999999999, "TestFunctionalizeCPU": 0.09866666666666668, "TestGradTransformCPU": 0.4826666666666668, "TestHelpersCPU": 0.010333333333333333, "TestHessianCPU": 0.04066666666666666, "TestHigherOrderOperatorInteractionCPU": 0.02066666666666667, "TestJacCPU": 0.48000000000000015, "TestJvpCPU": 0.045333333333333344, "TestLinearizeCPU": 0.315, "TestMakeFunctional": 0.09100000000000003, "TestSliceArgnums": 0.012000000000000004, "TestVmapJvpInplaceViewCPU": 0.01333333333333333, "TestVmapOfGradCPU": 0.2986666666666667}, "functorch/test_logging": {"TestAOTLogging": 0.1376666666666667}, "functorch/test_minifier": {"TestMinifier": 0.3319999999999999}, "functorch/test_ops": {"TestOperatorsCPU": 3099.3919999999957}, "functorch/test_vmap": {"TestRandomnessCPU": 0.9163333333333341, "TestTransformFailureCPU": 0.09966666666666668, "TestVmapAPI": 0.2806666666666668, "TestVmapBatchedGradientCPU": 0.1326666666666667, "TestVmapDeviceTypeCPU": 0.016666666666666666, "TestVmapNestedTensorCPU": 0.030666666666666675, "TestVmapOperators": 3.218333333333328, "TestVmapOperatorsOpInfoCPU": 533.0133333333323}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.6343333333332275}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.591666666666667}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 7.396}, "inductor/test_binary_folding": {"FreezingCpuTests": 40.620666666666665}, "inductor/test_codecache": {"TestFxGraphCache": 36.155333333333324, "TestFxGraphCacheHashing": 0.586, "TestUtils": 3.3186666666666667, "test_codecache": 0.0006666666666666666}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.09300000000000001}, "inductor/test_compile_worker": {"TestCompileWorker": 7.819}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 303.4486666666672, "TestCompiledAutograd": 201.72466666666665, "TestCustomOpWithCompiledAutograd": 1.6216666666666637}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 543.5080000000002, "CompiledOptimizerTests": 234.4046666666669}, "inductor/test_config": {"TestInductorConfig": 5.102666666666665}, "inductor/test_control_flow": {"CondTests": 0.006666666666666667, "WhileLoopTests": 0.0016666666666666668}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1490.7026666666668, "TestCppWrapper": 1504.8306666666667}, "inductor/test_cpu_repro": {"CPUReproTests": 700.9043333333334}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 1646.25, "TestSelectAlgorithmDynamicShapesCPU": 1698.582}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0030000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.354}, "inductor/test_debug_trace": {"TestDebugTrace": 2.4586666666666663}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.001}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 34.13766666666667}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 76.02666666666667}, "inductor/test_extension_backend": {"ExtensionBackendTests": 22.585333333333335}, "inductor/test_flex_attention": {"TestFlexAttention": 0.008333333333333333, "TestTemplatedSDPA": 0.022333333333333344}, "inductor/test_foreach": {"ForeachTests": 16.983666666666693}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 86.113, "SDPAPatternRewriterCpuTests": 86.694}, "inductor/test_fx_fusion": {"TestFxFusion": 0.07033333333333334}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.018000000000000002}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.03366666666666667, "TestGroupBatchFusion": 0.0003333333333333333, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.055333333333333325, "TestIndexingSimplification": 0.5383333333333333}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 57.89866666666666}, "inductor/test_minifier": {"MinifierTests": 24.345}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 170.734, "TestPatternMatcher": 595.2243333333333}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.10033333333333333}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 17.622666666666667}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.012666666666666672}, "inductor/test_torchbind": {"TestTorchbind": 9.616666666666665}, "inductor/test_torchinductor": {"CpuTests": 1509.145333333333, "SweepInputsCpuTest": 122.76199999999999, "TestFull": 10.648666666666665}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1511.553333333333}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1658.1856666666656, "TestInductorDynamicCPU": 0.032666666666666684}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 26090.984000000015}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.27266666666666667}, "inductor/test_triton_kernels": {"KernelTests": 0.2203333333333334, "MutationTests": 0.02266666666666668, "NoOptimizationKernelTests": 0.012000000000000004, "no_opt_test_class": 0.0045000000000000005}, "inductor/test_utils": {"TestUtils": 0.017}, "lazy/test_debug_util": {"DebugUtilTest": 0.05633333333333334}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.077}, "lazy/test_generator": {"LazyGeneratorTest": 0.05966666666666667}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.3376666666666667}, "lazy/test_step_closures": {"ClosuresTest": 2.0109999999999997}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.291, "TestLazyOpInfoCPU": 7.567000000000007, "TestLazyTensor": 0.061}, "nn/test_convolution": {"TestConvolutionNN": 12.655999999999999, "TestConvolutionNNDeviceTypeCPU": 6.196999999999967}, "nn/test_dropout": {"TestDropoutNN": 0.11866666666666666, "TestDropoutNNDeviceTypeCPU": 0.3013333333333334}, "nn/test_embedding": {"TestEmbeddingNN": 0.16800000000000004, "TestEmbeddingNNDeviceTypeCPU": 5.970333333333329}, "nn/test_init": {"TestNNInit": 3.26}, "nn/test_lazy_modules": {"TestLazyModules": 0.5193333333333335}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.6953333333333335, "TestLoadStateDictSwap": 0.039999999999999994}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.026, "TestModuleHookNN": 0.06300000000000001, "TestModuleHooks": 0.08166666666666668, "TestStateDictHooks": 0.031333333333333345}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 5.837666666666666, "TestMultiheadAttentionNNDeviceTypeCPU": 0.02466666666666667}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.211}, "nn/test_parametrization": {"TestNNParametrization": 0.9080000000000003, "TestNNParametrizationDeviceCPU": 0.014666666666666666}, "nn/test_pooling": {"TestAvgPool": 0.2163333333333333, "TestPoolingNN": 0.3746666666666667, "TestPoolingNNDeviceTypeCPU": 29.319666666666667}, "nn/test_pruning": {"TestPruningNN": 0.09300000000000004}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.25266666666666665}, "profiler/test_memory_profiler": {"TestDataFlow": 0.9479999999999998, "TestIdentifyGradients": 0.27666666666666667, "TestMemoryProfiler": 0.019, "TestMemoryProfilerE2E": 2.447666666666667}, "profiler/test_profiler": {"TestExecutionTrace": 8.020333333333333, "TestExperimentalUtils": 4.3676666666666675, "TestProfiler": 17.700666666666667, "TestProfilerCUDA": 0.0013333333333333333, "TestProfilerITT": 0.011999999999999999, "TestRecordFunction": 0.04533333333333334, "TestTorchTidyProfiler": 4.877}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.08366666666666668}, "profiler/test_record_function": {"TestRecordFunction": 0.08633333333333333}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.916666666666666}, "test_ao_sparsity": {"TestActivationSparsifier": 0.08633333333333333, "TestBaseDataScheduler": 0.030333333333333334, "TestBaseDataSparsifier": 0.08, "TestBaseSparsifier": 0.029666666666666664, "TestBaseStructuredSparsifier": 1.334666666666667, "TestComposability": 1.5330000000000001, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.022333333333333334, "TestFakeSparsity": 0.08033333333333333, "TestFxComposability": 1.6199999999999999, "TestNearlyDiagonalSparsifier": 0.5723333333333334, "TestNormDataSparsifiers": 0.834, "TestQuantizationUtils": 0.022333333333333334, "TestQuantizedSparseKernels": 0.19200000000000003, "TestQuantizedSparseLayers": 0.38866666666666666, "TestSaliencyPruner": 0.028666666666666663, "TestScheduler": 0.012666666666666668, "TestSparsityUtilFunctions": 0.035, "TestWeightNormSparsifier": 0.22766666666666668}, "test_autocast": {"TestAutocastCPU": 0.5826666666666668, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.004333333333333334}, "test_autograd": {"TestAllowMutationOnSaved": 0.03466666666666667, "TestAutograd": 15.679666666666698, "TestAutogradComplex": 0.005, "TestAutogradDeviceTypeCPU": 0.2550000000000001, "TestAutogradForwardMode": 0.09033333333333338, "TestAutogradForwardModeBatchedGrad": 0.013666666666666669, "TestAutogradFunctional": 7.734999999999993, "TestAutogradInferenceMode": 0.03466666666666668, "TestAutogradLogging": 0.011666666666666665, "TestAutogradMultipleDispatchCPU": 0.02233333333333333, "TestMultithreadAutograd": 0.16033333333333336, "TestNestedCheckpoint": 0.35733333333333334, "TestSelectiveActivationCheckpoint": 0.028}, "test_autograd_fallback": {"TestAutogradFallback": 0.08833333333333336}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 127.80333333333601}, "test_bundled_inputs": {"TestBundledInputs": 0.931}, "test_comparison_utils": {"TestComparisonUtils": 0.022333333333333334}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0003333333333333333}, "test_complex": {"TestComplexTensorCPU": 0.05000000000000001}, "test_content_store": {"TestContentStoreCPU": 6.013000000000001}, "test_cpp_api_parity": {"TestCppApiParity": 3.0359999999999885}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.029333333333333336, "TestMAIATensor": 0.007, "TestORTTensor": 0.011666666666666667, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.0026666666666666666, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.02833333333333334, "TestMAIATensor": 0.006999999999999999, "TestORTTensor": 0.011000000000000001, "TestPybindTypeCasters": 0.0016666666666666668, "TestRNGExtension": 0.0026666666666666666, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 152.77333333333334}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.444}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 7.773333333333333}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.4686666666666666}, "test_custom_backend": {"TestCustomBackend": 0.06899999999999999}, "test_custom_ops": {"MiniOpTest": 0.6176666666666669, "MiniOpTestOther": 0.06266666666666669, "TestCustomOp": 2.1749999999999954, "TestCustomOpAPI": 0.13900000000000004, "TestCustomOpTestingCPU": 1.4863333333333335, "TestCustomOperators": 0.2886666666666667, "TestGenerateOpcheckTests": 2.9143333333333334}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 28.928, "TestConcatDataset": 0.009, "TestConvAfterFork": 0.11766666666666666, "TestCustomPinFn": 0.0016666666666666668, "TestDataLoader": 31.938333333333336, "TestDataLoaderDeviceTypeCPU": 0.0030000000000000005, "TestDataLoaderPersistentWorkers": 57.149333333333324, "TestDatasetRandomSplit": 0.11766666666666666, "TestDictDataLoader": 0.07100000000000001, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004333333333333334, "TestSetAffinity": 0.08333333333333333, "TestStackDataset": 0.02366666666666667, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.017666666666666667}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006333333333333333, "TestDataChunk": 0.006000000000000001, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 5.0376666666666665, "TestFunctionalMapDataPipe": 0.030666666666666665, "TestGraph": 0.013000000000000003, "TestIterDataPipeCountSampleYielded": 0.006333333333333334, "TestIterDataPipeGraphFastForward": 0.037333333333333336, "TestIterDataPipeSingletonConstraint": 0.017, "TestIterableDataPipeBasic": 0.018333333333333337, "TestSerialization": 5.8069999999999995, "TestSharding": 0.211, "TestStreamWrapper": 0.018000000000000002, "TestTyping": 0.0036666666666666666}, "test_decomp": {"DecompOneOffTestsCPU": 0.794, "HasDecompTest": 0.14800000000000002, "TestDecompCPU": 5069.967333333345}, "test_deploy": {"TestFreezer": 0.015}, "test_dispatch": {"TestDispatch": 27.960666666666665, "TestPythonDispatcher": 0.01}, "test_dlpack": {"TestTorchDlPackCPU": 0.25266666666666676}, "test_dynamic_shapes": {"TestDimConstraints": 1.4706666666666666, "TestFloorDiv": 0.011000000000000001, "TestGuardsExpressions": 0.019999999999999997, "TestPySymInt": 0.8210000000000003, "TestSymNumberMagicMethods": 1.4309999999999956}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 2.0549999999999984, "TestExpandedWeightHelperFunctionCPU": 0.017, "TestExpandedWeightModuleCPU": 5.909}, "test_fake_tensor": {"FakeTensorConstHandling": 0.048666666666666684, "FakeTensorConverterTest": 0.021333333333333333, "FakeTensorDispatchCache": 0.057, "FakeTensorOpInfoTestCPU": 0.09200000000000001, "FakeTensorOperatorInvariants": 0.26033333333333336, "FakeTensorPropTest": 0.056666666666666664, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.6460000000000001, "PropagateRealTensorsFakeTensorConstHandling": 0.07800000000000001, "PropagateRealTensorsFakeTensorConverterTest": 0.019333333333333338, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.07933333333333335, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.15866666666666668, "PropagateRealTensorsFakeTensorPropTest": 0.04033333333333333, "PropagateRealTensorsFakeTensorTest": 0.2113333333333334}, "test_flop_counter": {"TestFlopCounter": 0.4753333333333334}, "test_foreach": {"TestForeachCPU": 48.9440000000005}, "test_function_schema": {"TestFunctionSchema": 0.3196666666666667}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 35.934333333333335}, "test_functional_optim": {"TestFunctionalOptimParity": 0.13366666666666668}, "test_functionalization": {"TestCrossRefFunctionalization": 2.4619999999999993, "TestFunctionalization": 2.6036666666666655}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.017333333333333336}, "test_futures": {"TestFuture": 0.6783333333333333}, "test_fx": {"AnnotationsTest": 0.01166666666666667, "TestCSEPass": 0.22500000000000006, "TestCommonPass": 0.056333333333333326, "TestConstFold": 0.14700000000000002, "TestConstParamShapeInControlFlow": 0.039, "TestDCE": 0.02733333333333333, "TestFX": 2.52033333333333, "TestFXAPIBackwardCompatibility": 0.025000000000000005, "TestFunctionalTracing": 0.001, "TestMatcher": 0.31533333333333335, "TestOperatorSignaturesCPU": 3.0386666666666478, "TestPassManager": 0.023333333333333334, "TestSourceMatcher": 1.274, "TestSubgraphRewriter": 0.25466666666666676, "TestVisionTracing": 210.535, "TypeCheckerTest": 1.4199999999999988}, "test_fx_experimental": {"TestFXExperimental": 17.19333333333333, "TestNormalizeOperatorsCPU": 54.342333333333336, "TestTranslationValidation": 0.17166666666666666}, "test_fx_passes": {"TestFXGraphPasses": 0.4560000000000002, "TestFXMatcherUtils": 0.08366666666666668}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.2850000000000001}, "test_import_stats": {"TestImportTime": 2.981666666666667}, "test_indexing": {"NumpyTestsCPU": 0.03833333333333335, "TestIndexingCPU": 1.9689999999999965}, "test_itt": {"TestItt": 0.016333333333333335}, "test_jit": {"TestAliasAnalysis": 0.23600000000000007, "TestAsync": 0.35300000000000004, "TestAtenPow": 0.009666666666666665, "TestAutodiffJit": 0.08933333333333333, "TestAutodiffSubgraphSlicing": 0.25700000000000006, "TestAwait": 0.2006666666666667, "TestBackends": 0.528, "TestBackendsWithCompiler": 0.09800000000000002, "TestBatchMM": 0.06599999999999999, "TestBuiltins": 0.048999999999999995, "TestClassType": 1.4656666666666665, "TestComplex": 0.6736666666666667, "TestCustomOperators": 0.035333333333333335, "TestDCE": 0.016333333333333335, "TestDataParallel": 0.0023333333333333335, "TestDataclasses": 4.218, "TestDeviceAnalysis": 3.866, "TestDict": 0.3450000000000002, "TestDtypeAnalysis": 0.13933333333333334, "TestDtypeCustomRulesCPU": 3.293333333333329, "TestEnum": 0.19533333333333336, "TestFreezing": 1.8383333333333336, "TestFrontend": 0.2313333333333333, "TestFrozenOptimizations": 11.488333333333332, "TestFunctionalBlocks": 0.005666666666666667, "TestFunctionalToInplaceActivation": 2.373333333333333, "TestGenerator": 0.050333333333333334, "TestGetDefaultAttr": 0.020666666666666667, "TestGraphRewritePasses": 0.04066666666666666, "TestHash": 0.055999999999999994, "TestHooks": 0.5640000000000002, "TestIgnorableArgs": 0.011000000000000001, "TestIgnoreContextManager": 0.036333333333333336, "TestInplaceToFunctionalActivation": 2.416, "TestIsinstance": 0.15500000000000005, "TestJit": 5.008333333333328, "TestJitGeneratedModule": 10.231333333333358, "TestJitProfiler": 0.001, "TestJitUtils": 0.014333333333333337, "TestList": 1.0873333333333337, "TestLogging": 0.03566666666666667, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.17400000000000002, "TestMixTracingScripting": 1.099, "TestModels": 1.953333333333333, "TestModuleAPIs": 0.17800000000000002, "TestModuleContainers": 1.1023333333333334, "TestModuleInterface": 0.557, "TestModules": 0.013, "TestNamedTuple": 0.053666666666666675, "TestNnapiBackend": 12.319333333333333, "TestOpDecompositions": 0.014666666666666666, "TestOptimizeForMobilePreserveDebugInfo": 0.23133333333333336, "TestParametrization": 0.129, "TestPeephole": 0.4040000000000002, "TestProducerVersion": 0.002, "TestProfiler": 0.6393333333333334, "TestPythonBindings": 0.027, "TestPythonBuiltinOP": 0.3013333333333334, "TestPythonIr": 0.02033333333333333, "TestRecursiveScript": 0.5443333333333334, "TestRemoveMutation": 0.12966666666666668, "TestSaveLoad": 0.4206666666666668, "TestSaveLoadFlatbuffer": 0.2846666666666668, "TestSaveLoadForOpVersion": 1.9993333333333334, "TestScript": 26.40833333333336, "TestScriptDict": 0.021, "TestScriptList": 0.5860000000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.12933333333333333, "TestScriptProfile": 0.4336666666666667, "TestSlice": 0.14466666666666675, "TestSparse": 0.042333333333333334, "TestStringFormatting": 0.10333333333333335, "TestSymbolicShapeAnalysis": 1.7343333333333328, "TestTensorBuiltins": 0.07400000000000001, "TestTensorCreationOps": 0.037, "TestTensorMethods": 0.011666666666666667, "TestTorchbind": 0.10333333333333337, "TestTracer": 2.5343333333333304, "TestTypeSharing": 0.3063333333333334, "TestTypesAndAnnotation": 0.10800000000000003, "TestTyping": 0.33466666666666683, "TestUnion": 0.37266666666666676, "TestUnsupportedOps": 0.02266666666666667, "TestUpgraders": 0.08533333333333333, "TestWarn": 0.038666666666666676, "TestWith": 0.2976666666666667}, "test_jit_autocast": {"TestAutocast": 0.08133333333333333, "TestJitTraceAutocast": 17.466333333333335}, "test_jit_disabled": {"TestJitDisabled": 0.11399999999999999}, "test_jit_fuser_te": {"TestFuserCommon": 0.11066666666666668, "TestLoopnestRandomizationCPU": 0.050666666666666665, "TestNNCOpInfoCPU": 50.65700000000027, "TestTEFuserDynamic": 109.94500000000001, "TestTEFuserStatic": 42.187}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0006666666666666666, "TestEnableDisableLlgaFuser": 0.09933333333333333, "TestFusionPatternCPU": 5.318666666666666, "TestModel": 2.6276666666666664, "TestOpCPU": 31.588666666666665}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.9500000000000001, "TestVmapBatchedGradientLegacyCPU": 0.09333333333333338, "TestVmapOperatorsLegacy": 1.074}, "test_license": {"TestLicense": 0.014333333333333332}, "test_linalg": {"TestLinalgCPU": 126.3609999999996}, "test_logging": {"LoggingTest": 2.0526666666666666}, "test_masked": {"TestMaskedCPU": 15.05733333333333}, "test_maskedtensor": {"TestBasicsCPU": 0.10033333333333334, "TestBinary": 0.4206666666666669, "TestOperatorsCPU": 5.906666666666633, "TestReductions": 0.056333333333333346, "TestUnary": 0.3150000000000002}, "test_meta": {"TestMetaCPU": 1503.7426666665524, "TestMetaConverter": 0.10600000000000002}, "test_mkl_verbose": {"TestMKLVerbose": 3.7776666666666667}, "test_mkldnn": {"TestMkldnnCPU": 95.1083333333333}, "test_mkldnn_fusion": {"TestMkldnnFusion": 59.463}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.5836666666666672}, "test_mobile_optimizer": {"TestOptimizer": 2.3463333333333334}, "test_model_dump": {"TestModelDump": 0.7639999999999999}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.012666666666666666}, "test_module_tracker": {"TestModuleTracker": 0.019333333333333338}, "test_modules": {"TestModuleCPU": 429.25533333332527}, "test_monitor": {"TestMonitor": 0.027, "TestMonitorTensorboard": 0.48266666666666663}, "test_multiprocessing": {"TestMultiprocessing": 43.82366666666667}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.4303333333333333, "SpawnTest": 23.711}, "test_namedtensor": {"TestNamedTensor": 0.45966666666666683}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.0676666666666665}, "test_native_functions": {"TestNativeFunctions": 0.15133333333333335}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.18366666666666673}, "test_nestedtensor": {"TestNestedTensor": 0.1573333333333334, "TestNestedTensorAutogradCPU": 0.9093333333333332, "TestNestedTensorDeviceTypeCPU": 0.7523333333333339, "TestNestedTensorSubclassCPU": 16.587000000000007}, "test_nn": {"TestAddRelu": 0.0030000000000000005, "TestConstantPadNd": 0.0033333333333333335, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.25633333333333336, "TestFusionUtils": 0.004, "TestNN": 33.70166666666661, "TestNNDeviceTypeCPU": 105.00166666666725, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.003666666666666667}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.16900000000000007}, "test_openmp": {"TestOpenMP_ParallelFor": 5.851999999999999}, "test_ops": {"TestCommonCPU": 1231.9503333333107, "TestCompositeComplianceCPU": 711.3493333333304, "TestFakeTensorCPU": 251.75166666666746, "TestMathBitsCPU": 38.98299999999995, "TestRefsOpsInfoCPU": 1.0850000000000009, "TestSelfKwarg": 0.025666666666666667, "TestTagsCPU": 11.375999999999975}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 567.1776666666691}, "test_ops_gradients": {"TestBwdGradientsCPU": 967.1900000000063}, "test_ops_jit": {"TestJitCPU": 859.8809999999986}, "test_optim": {"TestDifferentiableOptimizer": 0.1596666666666667, "TestLRScheduler": 0.776666666666667, "TestOptim": 49.194, "TestOptimRenewedCPU": 36.50300000000009, "TestSWAUtils": 0.1403333333333333}, "test_out_dtype_op": {"TestOutDtypeOp": 0.21533333333333338}, "test_overrides": {"TestBroadcastAllOverride": 0.0023333333333333335, "TestDisabledTorchFunction": 0.0016666666666666668, "TestDisabledUserWarnings": 0.0016666666666666668, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.015333333333333332, "TestGradNewOnesOverride": 0.0016666666666666668, "TestIndexing": 0.006000000000000001, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.0023333333333333335, "TestRNN": 0.002, "TestResolveName": 0.08433333333333333, "TestTorchFunctionMode": 0.02833333333333335, "TestTorchFunctionOverride": 1.5653333333332737, "TestTorchFunctionWarning": 0.005333333333333333, "TestWrapTorchFunction": 0.0013333333333333333}, "test_package": {"DirectoryReaderTest": 0.04466666666666667, "ModelTest": 0.005333333333333332, "TestAnalyze": 0.012333333333333333, "TestDependencyAPI": 0.04400000000000001, "TestDependencyHooks": 0.007666666666666666, "TestDiGraph": 0.020333333333333335, "TestGlobGroup": 0.02466666666666667, "TestImporter": 0.014333333333333335, "TestLoadBCPackages": 0.07466666666666666, "TestMangling": 0.022000000000000002, "TestMisc": 0.04766666666666667, "TestPackageFX": 0.09199999999999998, "TestPackageScript": 1.7216666666666665, "TestRepackage": 0.007666666666666666, "TestResources": 0.011000000000000001, "TestSaveLoad": 0.03433333333333334}, "test_per_overload_api": {"TestPerOverloadAPI": 0.019000000000000003}, "test_prims": {"TestDecompCPU": 0.07466666666666666, "TestPrimsBasic": 0.017333333333333336, "TestPrimsCPU": 0.09433333333333334, "TestRefsCPU": 0.015000000000000001}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.08633333333333333, "TestGenericProxyTensorFake": 2.0979999999999994, "TestGenericProxyTensorReal": 2.3736666666666664, "TestGenericProxyTensorSymbolic": 18.038666666666664, "TestProxyTensorOpInfoCPU": 636.1236666666607, "TestRealProxyTensor": 0.015666666666666666, "TestSymbolicTracing": 3.2709999999999995}, "test_pruning_op": {"PruningOpTest": 0.2143333333333333}, "test_public_bindings": {"TestPublicBindings": 5.033666666666666}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.004333333333333334, "TestPythonDispatch": 0.18566666666666679, "TestPythonDispatcher": 0.005666666666666667, "TestPythonRegistration": 0.161, "TestWrapperSubclassAliasingCPU": 0.11100000000000003}, "test_pytree": {"TestCxxPytree": 0.014333333333333339, "TestGenericPytree": 0.1233333333333334, "TestPythonPytree": 0.07500000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.014, "TestAOMigrationNNQuantized": 0.04900000000000001, "TestAOMigrationQuantization": 0.020000000000000004, "TestAOMigrationQuantizationFx": 0.017, "TestBackendConfig": 0.043000000000000003, "TestBiasCorrectionEager": 1.6326666666666665, "TestBitsCPU": 0.055333333333333345, "TestComparatorOps": 1.2786666666666668, "TestDeprecatedJitQuantized": 3.8676666666666666, "TestDistributed": 0.022333333333333334, "TestDuplicateDQPass": 2.389, "TestDynamicQuantizedModule": 43.11000000000001, "TestDynamicQuantizedOps": 25.62966666666667, "TestEqualizeEager": 0.19466666666666665, "TestEqualizeFx": 6.228333333333333, "TestFXGraphMatcher": 1.6063333333333334, "TestFXGraphMatcherModels": 8.583666666666666, "TestFXNumericSuiteCoreAPIs": 26.324666666666662, "TestFXNumericSuiteCoreAPIsModels": 33.608000000000004, "TestFXNumericSuiteNShadows": 37.37766666666667, "TestFakeQuantize": 0.31533333333333335, "TestFakeQuantizeOps": 1.8446666666666662, "TestFloat8DtypeCPU": 0.08300000000000002, "TestFloat8DtypeCPUOnlyCPU": 0.42733333333333334, "TestFuseEager": 2.675333333333333, "TestFuseFx": 2.91, "TestFusedObsFakeQuant": 0.06933333333333334, "TestFusedObsFakeQuantModule": 0.18166666666666667, "TestFusionPasses": 0.02566666666666667, "TestFxDetectInputWeightEqualization": 0.20933333333333337, "TestFxDetectOutliers": 0.39266666666666666, "TestFxModelReportClass": 0.5426666666666667, "TestFxModelReportDetectDynamicStatic": 0.06733333333333334, "TestFxModelReportDetector": 0.22833333333333336, "TestFxModelReportObserver": 0.214, "TestFxModelReportVisualizer": 0.2773333333333334, "TestGenerateNumericDebugHandle": 0.8079999999999999, "TestGraphUtils": 1.235, "TestHistogramObserver": 26.182000000000002, "TestMetaDataPorting": 5.941333333333333, "TestModelNumericsEager": 1.0773333333333335, "TestNumericSuiteEager": 8.552, "TestObserver": 3.0673333333333326, "TestPT2ERepresentation": 26.012, "TestPadding": 18.397666666666666, "TestQNNPackOps": 5.204, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 1.8283333333333334, "TestQuantizeDynamicJitPasses": 4.892, "TestQuantizeEagerOps": 1.7766666666666666, "TestQuantizeEagerPTQDynamic": 8.293, "TestQuantizeEagerPTQStatic": 22.808666666666667, "TestQuantizeEagerQAT": 10.543999999999999, "TestQuantizeEagerQATNumerics": 1.9516666666666664, "TestQuantizeFx": 41.326000000000015, "TestQuantizeFxModels": 6.818666666666666, "TestQuantizeFxOps": 104.33300000000001, "TestQuantizeJit": 21.30366666666667, "TestQuantizeJitOps": 209.60433333333333, "TestQuantizeJitPasses": 5.320666666666667, "TestQuantizePT2E": 46.90333333333334, "TestQuantizePT2EQATModels": 25.339999999999993, "TestQuantizePT2EQAT_ConvBn1d": 315.27500000000003, "TestQuantizePT2EQAT_ConvBn2d": 314.8853333333334, "TestQuantizePT2EX86Inductor": 125.56233333333334, "TestQuantizedConv": 47.160666666666664, "TestQuantizedEmbeddingOps": 0.8300000000000001, "TestQuantizedFunctionalOps": 2.492, "TestQuantizedLinear": 18.429, "TestQuantizedOps": 125.40366666666667, "TestQuantizedTensor": 1.6269999999999996, "TestRecordHistogramObserver": 0.030666666666666665, "TestReferenceQuantizedModule": 0.042, "TestSerialization": 1.8920000000000001, "TestStaticQuantizedModule": 110.75533333333335, "TestSubgraphRewriter": 1.3523333333333334, "TestUtils": 0.02566666666666667, "TestXNNPACKQuantizer": 35.38666666666666, "TestXNNPACKQuantizerModels": 2.7379999999999995}, "test_reductions": {"TestReductionsCPU": 188.88533333332157}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 3.9516666666666658}, "test_schema_check": {"TestSchemaCheck": 0.1443333333333334, "TestSchemaCheckModeOpInfoCPU": 161.69066666666345}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.9403333333333338}, "test_serialization": {"TestBothSerializationCPU": 0.143, "TestOldSerialization": 24.31866666666667, "TestSerialization": 8.50733333333333, "TestSubclassSerialization": 0.03166666666666667}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.017333333333333333}, "test_shape_ops": {"TestShapeOpsCPU": 0.8533333333333336}, "test_show_pickle": {"TestShowPickle": 0.019666666666666666}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.9046666666666632}, "test_sparse": {"TestSparseAnyCPU": 433.8173333333318, "TestSparseCPU": 25.82733333333334, "TestSparseLegacyAndDeprecation": 0.04733333333333333, "TestSparseMaskedReductionsCPU": 1.0173333333333339, "TestSparseMeta": 3.756666666666666, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 10.183666666666644}, "test_sparse_csr": {"TestSparseCSRCPU": 61.77833333333351, "TestSparseCSRSampler": 0.3753333333333333, "TestSparseCompressedCPU": 87.24000000000002, "TestSparseCompressedTritonKernelsCPU": 0.0033333333333333335}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0033333333333333335}, "test_spectral_ops": {"TestFFTCPU": 5.405333333333328, "TestFFTDocExamplesCPU": 0.06633333333333337}, "test_stateless": {"TestPythonOptimizeMode": 3.873666666666667, "TestStatelessDeprecation": 1.563, "TestStatelessFunctionalAPI": 0.2023333333333334}, "test_subclass": {"TestSubclass": 0.16366666666666677}, "test_sympy_utils": {"TestNumbers": 0.12433333333333334, "TestSingletonInt": 0.007333333333333333, "TestSympyInterp": 9.305999999999997, "TestSympySolve": 0.19800000000000004, "TestValueRanges": 4.765333333333332}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.49933333333333363, "TestBufferProtocolCPU": 0.4153333333333336, "TestLikeTensorCreationCPU": 0.009000000000000001, "TestRandomTensorCreationCPU": 2.834333333333333, "TestTensorCreationCPU": 13.417000000000007}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.017666666666666667, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.0026666666666666666, "TestTensorBoardPyTorchNumpy": 0.03133333333333333, "TestTensorBoardPytorchGraph": 34.63399999999999, "TestTensorBoardSummary": 0.04500000000000001, "TestTensorBoardSummaryWriter": 0.006000000000000001, "TestTensorBoardUtils": 0.14800000000000002, "TestTensorBoardWriter": 0.104, "TestTensorProtoSummary": 0.011000000000000001}, "test_tensorexpr": {"TestTensorExprFuser": 44.836333333333336}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.008, "TestTensorExprPyBind": 0.5893333333333334}, "test_testing": {"TestAssertClose": 0.1193333333333334, "TestAssertCloseContainer": 0.008, "TestAssertCloseErrorMessage": 0.06066666666666667, "TestAssertCloseQuantized": 0.011000000000000001, "TestAssertCloseSparseBSC": 0.017666666666666667, "TestAssertCloseSparseBSR": 0.017333333333333336, "TestAssertCloseSparseCOO": 0.02266666666666667, "TestAssertCloseSparseCSC": 0.017333333333333336, "TestAssertCloseSparseCSR": 0.018000000000000002, "TestFrameworkUtils": 9.767333333333333, "TestImports": 11.642999999999999, "TestMakeTensorCPU": 1.1223333333333325, "TestOpInfoSampleFunctionsCPU": 6.349999999999919, "TestOpInfos": 0.004, "TestTestParametrization": 0.034666666666666686, "TestTestParametrizationDeviceTypeCPU": 3.334333333333331, "TestTestingCPU": 0.15566666666666673}, "test_torch": {"TestBasicVitalSigns": 0.014666666666666668, "TestTorch": 3.3063333333333276, "TestTorchDeviceTypeCPU": 12.658333333333383, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 20.240333333333332, "TestSDPACPU": 264.13399999999916, "TestSDPAFailureModesCPU": 0.019333333333333338, "TestTransformersCPU": 6.953666666666667}, "test_type_hints": {"TestTypeHints": 0.016}, "test_type_info": {"TestDTypeInfo": 0.023000000000000007}, "test_type_promotion": {"TestTypePromotionCPU": 2.8349999999999844}, "test_typing": {"TestTyping": 75.0946666666667}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 353.41133333315884}, "test_utils": {"TestAssert": 0.05166666666666667, "TestBottleneck": 8.227333333333332, "TestCheckpoint": 0.07500000000000001, "TestCollectEnv": 0.9726666666666667, "TestCppExtensionUtils": 0.08266666666666667, "TestDataLoaderUtils": 0.24566666666666667, "TestDeviceUtilsCPU": 29.96333333333385, "TestExtensionUtils": 0.004, "TestHipify": 0.001, "TestHipifyTrie": 0.004, "TestONNXUtils": 0.0033333333333333335, "TestRenderUtils": 0.01, "TestStandaloneCPPJIT": 1.636, "TestTraceback": 0.009000000000000001}, "test_view_ops": {"TestOldViewOpsCPU": 12.04200000000001, "TestViewOpsCPU": 0.7830000000000004, "TestViewOpsLAZY": 1.1513333333333333}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.018000000000000002, "WeakKeyDictionaryTestCase": 0.020666666666666667, "WeakTest": 3.551666666666666}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 32.264, "TestXNNPACKOps": 4.264666666666667, "TestXNNPACKRewritePass": 1.7626666666666668, "TestXNNPACKSerDes": 4.879333333333334}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.14033333333333342}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.07200000000000005, "TestClassGetItem": 0.13599999999999998, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0023333333333333335, "TestMisc": 0.004, "TestPickling": 0.13433333333333336, "TestPromotion": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 11.311333333333332, "TestEinsumPath": 0.002, "TestMisc": 0.006999999999999999}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.02566666666666667, "TestHalf": 0.0, "TestIinfo": 0.015333333333333332, "TestMisc": 0.004333333333333334, "TestPythonFloat": 0.0, "TestRepr": 0.0026666666666666666, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0023333333333333335, "TestBooleanIndexing": 0.008666666666666666, "TestBroadcastedAssignments": 0.018666666666666668, "TestFancyIndexingCast": 0.0036666666666666666, "TestFloatNonIntegerArgument": 0.009666666666666667, "TestIndexing": 0.17233333333333342, "TestMultiIndexingAutomated": 0.009333333333333334, "TestMultipleEllipsisError": 0.002, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.017333333333333336, "TestArgwhere": 0.04133333333333333, "TestArrayComparisons": 0.011666666666666667, "TestBaseRepr": 0.005333333333333333, "TestBinaryRepr": 0.008, "TestBoolArray": 2.1163333333333334, "TestBoolCmp": 0.16266666666666665, "TestBoolScalar": 0.009333333333333334, "TestBroadcast": 0.006333333333333334, "TestClip": 0.16400000000000012, "TestConvolve": 0.017333333333333336, "TestCorrelate": 0.028333333333333335, "TestCreationFuncs": 0.7983333333333333, "TestCross": 0.05833333333333333, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.009333333333333334, "TestFromiter": 0.0, "TestIndex": 0.004666666666666667, "TestIndices": 0.04, "TestIsclose": 0.06733333333333333, "TestIsscalar": 0.002, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.011000000000000001, "TestNonarrayArgs": 0.0736666666666667, "TestNonzeroAndCountNonzero": 0.18500000000000003, "TestOuterMisc": 0.006000000000000001, "TestRequire": 0.005333333333333333, "TestResize": 0.11766666666666668, "TestRoll": 0.035333333333333335, "TestRollaxis": 0.005333333333333333, "TestSeterr": 0.007, "TestStdVar": 0.020666666666666667, "TestStdVarComplex": 0.010333333333333335, "TestStringFunction": 0.0023333333333333335, "TestTensordot": 0.012333333333333333, "TestTypes": 0.013000000000000003}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.018666666666666668, "TestDocStrings": 0.0, "TestIsSubDType": 0.007, "TestScalarTypeNames": 0.02400000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.07166666666666673, "TestFromInt": 0.005, "TestFromString": 0.01966666666666667}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0006666666666666666, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.001, "TestIsInteger": 0.0023333333333333335}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.07, "TestBaseMath": 6.483, "TestBitShifts": 0.06866666666666667, "TestComplexDivision": 0.03933333333333334, "TestConversion": 0.03566666666666667, "TestHash": 0.0, "TestModulus": 0.617, "TestMultiply": 0.0, "TestNegative": 0.013, "TestPower": 0.09866666666666668, "TestRepr": 0.001, "TestScalarOpsMisc": 0.04966666666666669, "TestScalarSubclassingMisc": 0.03200000000000002, "TestSubtract": 0.013, "TestTypes": 9.967}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.035333333333333335, "TestAtleast2d": 0.015333333333333336, "TestAtleast3d": 0.013666666666666667, "TestBlock": 0.03166666666666668, "TestConcatenate": 0.14066666666666675, "TestHstack": 0.02033333333333334, "TestStackMisc": 0.18633333333333338, "TestVstack": 0.023333333333333334}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007333333333333333, "TestFFTShift": 4.0603333333333325, "TestIRFFTN": 0.005333333333333333, "TestRFFTFreq": 0.007}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.364666666666666, "TestFFTShift": 0.015666666666666666, "TestFFTThreadSafe": 1.5430000000000001}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.037}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0006666666666666666, "TestUnique": 0.215}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.008, "TestAmax": 0.005666666666666667, "TestAmin": 0.005333333333333333, "TestAngle": 0.007333333333333333, "TestAny": 0.007, "TestAverage": 0.030000000000000002, "TestBincount": 0.03166666666666667, "TestCheckFinite": 0.0026666666666666666, "TestCopy": 0.009666666666666665, "TestCorrCoef": 0.026, "TestCov": 0.04700000000000001, "TestCumprod": 0.023000000000000003, "TestCumsum": 0.036, "TestDelete": 0.02, "TestDiff": 0.06366666666666666, "TestDigitize": 0.013333333333333336, "TestExtins": 0.004666666666666667, "TestFilterwindows": 0.46200000000000035, "TestFlip": 0.034333333333333334, "TestGradient": 0.125, "TestInsert": 0.010666666666666666, "TestInterp": 0.052000000000000025, "TestKaiser": 0.007666666666666666, "TestMedian": 0.08266666666666668, "TestMeshgrid": 0.03900000000000001, "TestMsort": 0.0, "TestPercentile": 0.0996666666666667, "TestPiecewise": 0.009666666666666669, "TestProd": 0.02666666666666667, "TestPtp": 0.007666666666666666, "TestQuantile": 0.04966666666666667, "TestRot90": 0.06799999999999999, "TestSelect": 0.01, "TestSinc": 0.006333333333333334, "TestSortComplex": 0.009333333333333334, "TestTrapz": 0.004666666666666667, "TestTrimZeros": 0.010333333333333335, "TestUnique": 0.0033333333333333335, "Test_I0": 0.01}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.1196666666666667, "TestHistogramOptimBinNums": 0.029666666666666675, "TestHistogramdd": 0.11366666666666668}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006000000000000001, "TestDiagIndices": 0.004333333333333334, "TestDiagIndicesFrom": 0.006333333333333334, "TestFillDiagonal": 0.019, "TestGrid": 0.009333333333333334, "TestIndexExpression": 0.008, "TestIx_": 0.005, "TestNdIndex": 0.0013333333333333333, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.024000000000000007}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.013333333333333334, "TestApplyOverAxes": 0.0016666666666666668, "TestArraySplit": 0.13633333333333336, "TestColumnStack": 0.008666666666666668, "TestDsplit": 0.009333333333333334, "TestDstack": 0.013333333333333336, "TestExpandDims": 0.007, "TestHsplit": 0.010666666666666666, "TestKron": 0.012000000000000002, "TestMayShareMemory": 0.0023333333333333335, "TestPutAlongAxis": 0.010666666666666666, "TestSplit": 0.006333333333333333, "TestSqueeze": 0.045000000000000005, "TestTakeAlongAxis": 0.05233333333333334, "TestTile": 0.07766666666666668, "TestVsplit": 0.008}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.031, "TestEye": 0.06033333333333334, "TestFliplr": 0.006000000000000001, "TestFlipud": 0.008666666666666668, "TestHistogram2d": 0.04566666666666667, "TestTri": 0.10066666666666667, "TestTrilIndicesFrom": 0.0016666666666666668, "TestTriuIndices": 0.0026666666666666666, "TestTriuIndicesFrom": 0.0016666666666666668, "TestVander": 0.018666666666666668}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0013333333333333333, "TestCommonType": 0.022000000000000002, "TestImag": 0.01, "TestIscomplex": 0.004333333333333334, "TestIscomplexobj": 0.004, "TestIsfinite": 0.011666666666666667, "TestIsinf": 0.01, "TestIsnan": 0.011333333333333334, "TestIsneginf": 0.0023333333333333335, "TestIsposinf": 0.0023333333333333335, "TestIsreal": 0.009666666666666665, "TestIsrealobj": 0.0013333333333333333, "TestIsscalar": 0.0013333333333333333, "TestMintypecode": 0.004333333333333334, "TestNanToNum": 0.013000000000000003, "TestReal": 0.011666666666666667, "TestRealIfClose": 0.0036666666666666666}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.1596666666666667, "TestCond": 0.21633333333333335, "TestDet": 0.12066666666666666, "TestEig": 0.038666666666666676, "TestEigh": 0.02033333333333334, "TestEighCases": 0.0, "TestEigvals": 0.04866666666666667, "TestEigvalsh": 0.018333333333333337, "TestEigvalshCases": 0.0003333333333333333, "TestInv": 0.04066666666666667, "TestLstsq": 0.18466666666666667, "TestMatrixRank": 0.303, "TestMisc": 0.03733333333333333, "TestMisc2": 0.0030000000000000005, "TestMultiDot": 0.05200000000000001, "TestNormDouble": 0.7389999999999999, "TestNormInt64": 0.757, "TestNormSingle": 0.7600000000000001, "TestNorm_NonSystematic": 0.0030000000000000005, "TestPinv": 0.09966666666666668, "TestPinvHermitian": 0.025333333333333333, "TestQR": 4.878999999999999, "TestSVD": 0.046000000000000006, "TestSVDHermitian": 0.08366666666666667, "TestSolve": 0.15233333333333335, "TestTensorinv": 0.019666666666666666, "TestTensorsolve": 0.014666666666666666}, "torch_np/test_basic": {"TestArrayToSequence": 0.01, "TestCopyTo": 0.008, "TestCtorNested": 0.004, "TestDefaultDtype": 0.008666666666666668, "TestDivmod": 0.01966666666666667, "TestExport": 0.0026666666666666666, "TestMisc": 0.0030000000000000005, "TestNormalizations": 0.006666666666666667, "TestOneArr": 0.2870000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.15533333333333343, "TestOneArrAndShape": 0.007666666666666669, "TestOneArrToScalar": 0.012000000000000002, "TestPythonArgsToArray": 0.028, "TestSequenceOfArrays": 0.026000000000000013, "TestSequenceOfArraysToSingle": 0.012000000000000002, "TestShapeLikeToArray": 0.005333333333333333, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.1460000000000001}, "torch_np/test_dtype": {"TestConvertDType": 0.07033333333333337}, "torch_np/test_function_base": {"TestAppend": 0.018666666666666668}, "torch_np/test_ndarray_methods": {"TestAmax": 0.006000000000000001, "TestAmin": 0.006000000000000001, "TestArgmax": 0.8423333333333338, "TestArgmaxArgminCommon": 1.3846666666666654, "TestArgmin": 0.949666666666667, "TestContains": 0.002, "TestIndexing": 0.14400000000000002, "TestIter": 0.004333333333333334, "TestNoExtraMethods": 0.008, "TestNonzero": 0.11433333333333333, "TestRavel": 0.005333333333333333, "TestReshape": 0.011333333333333334, "TestTranspose": 0.007666666666666666}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 2.9389999999998717, "TestNEP50Table": 0.08466666666666671}, "torch_np/test_random": {"TestChoice": 0.009333333333333334, "TestNumpyGlobal": 0.0030000000000000005, "TestScalarReturn": 0.04733333333333336, "TestShuffle": 0.010333333333333335}, "torch_np/test_reductions": {"TestAll": 0.008666666666666666, "TestAny": 0.009666666666666667, "TestFlatnonzero": 0.02366666666666667, "TestGenericCumSumProd": 0.017666666666666667, "TestGenericReductions": 1.736666666666639, "TestMean": 0.019000000000000003, "TestSum": 0.25}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.036666666666666674, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3933333333333336, "TestNdarrayDunderVsUfunc": 0.1403333333333334, "TestUfuncDtypeKwd": 0.004, "TestUnaryUfuncs": 0.12233333333333335}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.1420000000000001}}, "dynamo": {"backends/xeon/test_launch": {"TestTorchrun": 1.958}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.602}, "distributions/test_constraints": {"test_constraints": 0.08900000000000007}, "distributions/test_distributions": {"TestAgainstScipy": 0.0, "TestConstraints": 82.33966666666667, "TestDistributionShapes": 85.197, "TestDistributions": 0.0023333333333333335, "TestFunctors": 4.306666666666667, "TestJit": 367.382, "TestKL": 0.001, "TestLazyLogitsInitialization": 83.64433333333334, "TestNumericalStability": 0.0, "TestRsample": 0.0, "TestValidation": 97.56033333333333}, "functorch/test_aotdispatch": {"TestAOTAutograd": 42.728, "TestAOTAutogradWithDynamo": 0.0030000000000000005, "TestAOTDispatch": 7.0569999999999995, "TestAOTExport": 5.229666666666667, "TestAOTModuleSimplified": 1.5326666666666666, "TestEagerFusionModuleInfoCPU": 2.545666666666653, "TestEagerFusionOpInfoCPU": 14.825000000000124, "TestPartitioning": 5.3999999999999995, "TestPythonKeyCPU": 15.566333333333334}, "functorch/test_control_flow": {"TestControlFlow": 9.174000000000001, "TestControlFlowTraced": 431.1090000000001}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 5.619666666666666, "TestAutogradFunctionVmapAPICPU": 1.0083333333333335, "TestCompileTransformsCPU": 9.816666666666668, "TestComposabilityCPU": 11.633333333333335, "TestExamplesCorrectnessCPU": 29.997, "TestFunctionalizeCPU": 3.2723333333333335, "TestGradTransformCPU": 25.013333333333325, "TestHelpersCPU": 0.8889999999999999, "TestHessianCPU": 5.104333333333333, "TestHigherOrderOperatorInteractionCPU": 1.5750000000000002, "TestJacCPU": 63.96433333333332, "TestJvpCPU": 7.717333333333333, "TestLinearizeCPU": 1.8783333333333332, "TestMakeFunctional": 1.896333333333333, "TestSliceArgnums": 0.4503333333333334, "TestVmapJvpInplaceViewCPU": 5.172666666666666, "TestVmapOfGradCPU": 29.88033333333333}, "functorch/test_logging": {"TestAOTLogging": 0.3953333333333333}, "functorch/test_minifier": {"TestMinifier": 1.0796666666666666}, "functorch/test_ops": {"TestOperatorsCPU": 36.69733333333656}, "functorch/test_vmap": {"TestRandomnessCPU": 146.30399999999997, "TestTransformFailureCPU": 0.07033333333333333, "TestVmapAPI": 47.236333333333334, "TestVmapBatchedGradientCPU": 33.195, "TestVmapDeviceTypeCPU": 1.8516666666666666, "TestVmapNestedTensorCPU": 1.7673333333333334, "TestVmapOperators": 1185.3216666666667, "TestVmapOperatorsOpInfoCPU": 34.77433333333328}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 12.859666666666302}, "higher_order_ops/test_with_effects": {"TestWithEffects": 7.1753333333333345}, "lazy/test_debug_util": {"DebugUtilTest": 0.416}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.4553333333333333}, "lazy/test_generator": {"LazyGeneratorTest": 0.383}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.29500000000000004}, "lazy/test_step_closures": {"ClosuresTest": 2.3510000000000004}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.09633333333333334, "TestLazyOpInfoCPU": 2.810999999999984, "TestLazyTensor": 0.14633333333333334}, "nn/test_convolution": {"TestConvolutionNN": 24.218333333333334, "TestConvolutionNNDeviceTypeCPU": 204.34666666666638}, "nn/test_dropout": {"TestDropoutNN": 0.834, "TestDropoutNNDeviceTypeCPU": 5.249666666666667}, "nn/test_embedding": {"TestEmbeddingNN": 4.267333333333333, "TestEmbeddingNNDeviceTypeCPU": 233.13566666666657}, "nn/test_init": {"TestNNInit": 1.5039999999999998}, "nn/test_lazy_modules": {"TestLazyModules": 12.973666666666668}, "nn/test_load_state_dict": {"TestLoadStateDict": 3.818333333333333, "TestLoadStateDictSwap": 0.018666666666666665}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.46566666666666673, "TestModuleHookNN": 2.297333333333333, "TestModuleHooks": 13.969000000000001, "TestStateDictHooks": 1.5186666666666666}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 23.476333333333333, "TestMultiheadAttentionNNDeviceTypeCPU": 1.529}, "nn/test_packed_sequence": {"PackedSequenceTest": 2.764333333333333}, "nn/test_parametrization": {"TestNNParametrization": 17.30966666666667, "TestNNParametrizationDeviceCPU": 0.10566666666666667}, "nn/test_pooling": {"TestAvgPool": 2.7900000000000005, "TestPoolingNN": 1.2166666666666666, "TestPoolingNNDeviceTypeCPU": 50.70099999999999}, "nn/test_pruning": {"TestPruningNN": 6.528}, "profiler/test_execution_trace": {"TestExecutionTrace": 1.3186666666666667}, "profiler/test_memory_profiler": {"TestDataFlow": 0.0, "TestIdentifyGradients": 0.0, "TestMemoryProfiler": 0.0, "TestMemoryProfilerE2E": 0.0}, "profiler/test_profiler": {"TestExecutionTrace": 10.088333333333333, "TestExperimentalUtils": 5.82, "TestProfiler": 15.394666666666666, "TestProfilerCUDA": 0.0, "TestProfilerITT": 0.164, "TestRecordFunction": 0.2353333333333333, "TestTorchTidyProfiler": 6.126333333333332}, "profiler/test_profiler_tree": {"TestProfilerTree": 1.3710000000000002}, "profiler/test_record_function": {"TestRecordFunction": 0.492}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.226666666666667}, "test_ao_sparsity": {"TestActivationSparsifier": 0.011000000000000001, "TestBaseDataScheduler": 0.49033333333333334, "TestBaseDataSparsifier": 3.1186666666666665, "TestBaseSparsifier": 0.5353333333333333, "TestBaseStructuredSparsifier": 38.42000000000001, "TestComposability": 2.575333333333333, "TestCubicScheduler": 0.4106666666666667, "TestFPGMPruner": 1.1613333333333333, "TestFakeSparsity": 4.070666666666667, "TestFxComposability": 10.273, "TestNearlyDiagonalSparsifier": 1.0766666666666667, "TestNormDataSparsifiers": 5.400333333333333, "TestQuantizationUtils": 0.27, "TestQuantizedSparseKernels": 0.154, "TestQuantizedSparseLayers": 0.024333333333333335, "TestSaliencyPruner": 0.37566666666666665, "TestScheduler": 0.7503333333333333, "TestSparsityUtilFunctions": 0.4576666666666667, "TestWeightNormSparsifier": 1.1963333333333332}, "test_autocast": {"TestAutocastCPU": 12.914, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.10433333333333333}, "test_autograd": {"TestAllowMutationOnSaved": 0.383, "TestAutograd": 69.26066666666668, "TestAutogradComplex": 0.663, "TestAutogradDeviceTypeCPU": 8.030666666666667, "TestAutogradForwardMode": 2.3913333333333333, "TestAutogradForwardModeBatchedGrad": 0.535, "TestAutogradFunctional": 49.28933333333333, "TestAutogradInferenceMode": 0.8093333333333335, "TestAutogradLogging": 0.15166666666666664, "TestAutogradMultipleDispatchCPU": 1.428, "TestMultithreadAutograd": 1.886, "TestNestedCheckpoint": 2.2113333333333327, "TestSelectiveActivationCheckpoint": 0.11066666666666665}, "test_autograd_fallback": {"TestAutogradFallback": 1.8776666666666666}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 634.0769999999694}, "test_bundled_inputs": {"TestBundledInputs": 1.9149999999999998}, "test_comparison_utils": {"TestComparisonUtils": 0.3740000000000001}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0003333333333333333}, "test_complex": {"TestComplexTensorCPU": 1.0503333333333331}, "test_content_store": {"TestContentStoreCPU": 8.063666666666668}, "test_cpp_api_parity": {"TestCppApiParity": 135.35066666666634}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.9480000000000001, "TestMAIATensor": 0.444, "TestORTTensor": 0.454, "TestPybindTypeCasters": 0.015, "TestRNGExtension": 0.009, "TestTorchLibrary": 0.007333333333333333}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.9516666666666667, "TestMAIATensor": 0.44733333333333336, "TestORTTensor": 0.456, "TestPybindTypeCasters": 0.014666666666666666, "TestRNGExtension": 0.009, "TestTorchLibrary": 0.007666666666666666}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 106.19133333333332}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.6276666666666667}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 9.373666666666669}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.6103333333333333}, "test_custom_ops": {"MiniOpTest": 9.455333333333334, "MiniOpTestOther": 0.5033333333333334, "TestCustomOp": 17.02066666666667, "TestCustomOpAPI": 1.1296666666666668, "TestCustomOpTestingCPU": 3.1303333333333323, "TestGenerateOpcheckTests": 3.3053333333333335}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 31.034666666666666, "TestConcatDataset": 0.143, "TestConvAfterFork": 0.17166666666666666, "TestCustomPinFn": 0.023000000000000003, "TestDataLoader": 100.58433333333333, "TestDataLoaderDeviceTypeCPU": 0.057666666666666665, "TestDataLoaderPersistentWorkers": 121.19900000000003, "TestDatasetRandomSplit": 2.8973333333333335, "TestDictDataLoader": 0.19099999999999998, "TestIndividualWorkerQueue": 0.011666666666666667, "TestNamedTupleDataLoader": 0.167, "TestSetAffinity": 0.19899999999999998, "TestStackDataset": 0.6090000000000001, "TestStringDataLoader": 0.015, "TestTensorDataset": 0.2946666666666667}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.039, "TestDataChunk": 0.25400000000000006, "TestDataFramesPipes": 0.05466666666666666, "TestFunctionalIterDataPipe": 4.935999999999999, "TestFunctionalMapDataPipe": 1.4500000000000002, "TestGraph": 0.3133333333333334, "TestIterDataPipeCountSampleYielded": 0.056999999999999995, "TestIterDataPipeGraphFastForward": 2.2066666666666666, "TestIterDataPipeSingletonConstraint": 0.16533333333333333, "TestIterableDataPipeBasic": 0.68, "TestSerialization": 6.177, "TestSharding": 0.44500000000000006, "TestStreamWrapper": 0.103, "TestTyping": 0.06466666666666666}, "test_decomp": {"DecompOneOffTestsCPU": 0.6603333333333334, "HasDecompTest": 0.269, "TestDecompCPU": 13.393999999999961}, "test_deploy": {"TestFreezer": 0.24666666666666667}, "test_dispatch": {"TestDispatch": 37.635333333333335, "TestPythonDispatcher": 0.09600000000000002}, "test_dlpack": {"TestTorchDlPackCPU": 8.375333333333332}, "test_dynamic_shapes": {"TestDimConstraints": 2.4066666666666667, "TestFloorDiv": 0.383, "TestGuardsExpressions": 0.19800000000000004, "TestPySymInt": 0.0033333333333333335, "TestSymNumberMagicMethods": 0.0023333333333333335}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 9.342333333333329, "TestExpandedWeightHelperFunctionCPU": 1.2073333333333334, "TestExpandedWeightModuleCPU": 24.82966666666668}, "test_fake_tensor": {"FakeTensorConstHandling": 0.31200000000000006, "FakeTensorConverterTest": 0.31033333333333335, "FakeTensorDispatchCache": 1.1079999999999997, "FakeTensorOpInfoTestCPU": 0.10466666666666664, "FakeTensorOperatorInvariants": 0.39300000000000007, "FakeTensorPropTest": 0.24833333333333332, "FakeTensorSerialization": 0.07400000000000001, "FakeTensorTest": 3.8316666666666666, "PropagateRealTensorsFakeTensorConstHandling": 0.09333333333333332, "PropagateRealTensorsFakeTensorConverterTest": 0.09299999999999999, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.10433333333333332, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.11033333333333332, "PropagateRealTensorsFakeTensorPropTest": 0.038, "PropagateRealTensorsFakeTensorTest": 0.613666666666667}, "test_flop_counter": {"TestFlopCounter": 0.0003333333333333333}, "test_foreach": {"TestForeachCPU": 32.71100000000097}, "test_function_schema": {"TestFunctionSchema": 0.7533333333333334}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 33.599}, "test_functional_optim": {"TestFunctionalOptimParity": 1.097}, "test_functionalization": {"TestCrossRefFunctionalization": 0.08933333333333333, "TestFunctionalization": 0.0026666666666666666}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.26166666666666666}, "test_futures": {"TestFuture": 2.951333333333333}, "test_fx": {"AnnotationsTest": 0.06766666666666667, "TestCSEPass": 2.2099999999999995, "TestCommonPass": 0.6010000000000001, "TestConstFold": 1.7229999999999999, "TestConstParamShapeInControlFlow": 3.2146666666666666, "TestDCE": 0.34333333333333327, "TestFX": 142.21099999999993, "TestFXAPIBackwardCompatibility": 3.469666666666667, "TestFunctionalTracing": 0.002, "TestMatcher": 1.0693333333333335, "TestOperatorSignaturesCPU": 12.975666666666692, "TestPassManager": 0.6196666666666667, "TestSourceMatcher": 1.574, "TestSubgraphRewriter": 1.4393333333333336, "TestVisionTracing": 0.0016666666666666668, "TypeCheckerTest": 5.697}, "test_fx_experimental": {"TestFXExperimental": 355.14966666666663, "TestNormalizeOperatorsCPU": 7.299666666666671, "TestTranslationValidation": 0.34766666666666673}, "test_fx_passes": {"TestFXGraphPasses": 6.851666666666667, "TestFXMatcherUtils": 0.2490000000000001}, "test_fx_reinplace_pass": {"TestReinplacePass": 1.7956666666666667}, "test_import_stats": {"TestImportTime": 3.318}, "test_indexing": {"NumpyTestsCPU": 1.7249999999999996, "TestIndexingCPU": 97.95633333333335}, "test_itt": {"TestItt": 0.26966666666666667}, "test_jit": {"TestAliasAnalysis": 0.5626666666666666, "TestAsync": 2.1216666666666666, "TestAtenPow": 4.283666666666667, "TestAutodiffJit": 0.051, "TestAutodiffSubgraphSlicing": 1.75, "TestAwait": 2.0353333333333334, "TestBackends": 13.827666666666666, "TestBackendsWithCompiler": 6.162, "TestBatchMM": 1.1900000000000002, "TestBuiltins": 0.336, "TestClassType": 3.1786666666666665, "TestComplex": 1.7763333333333329, "TestCustomOperators": 0.6593333333333334, "TestDCE": 0.05566666666666667, "TestDataParallel": 0.043666666666666666, "TestDataclasses": 10.409666666666666, "TestDeviceAnalysis": 6.176333333333333, "TestDict": 0.4400000000000002, "TestDtypeAnalysis": 6.122, "TestDtypeCustomRulesCPU": 5.60066666666665, "TestEnum": 0.42866666666666675, "TestFreezing": 0.4873333333333337, "TestFrontend": 0.26433333333333336, "TestFrozenOptimizations": 0.3250000000000002, "TestFunctionalBlocks": 0.35333333333333333, "TestFunctionalToInplaceActivation": 6.163, "TestGenerator": 0.6980000000000001, "TestGetDefaultAttr": 0.11599999999999999, "TestGraphRewritePasses": 0.06833333333333334, "TestHash": 0.5626666666666666, "TestHooks": 2.307666666666667, "TestIgnorableArgs": 0.05566666666666666, "TestIgnoreContextManager": 0.14433333333333334, "TestInplaceToFunctionalActivation": 4.983, "TestIsinstance": 1.067666666666667, "TestJit": 18.536999999999995, "TestJitGeneratedModule": 43.91533333333334, "TestJitProfiler": 0.8343333333333333, "TestJitUtils": 0.314, "TestList": 8.314333333333332, "TestLogging": 0.3196666666666667, "TestMKLDNNReinplacing": 0.03933333333333333, "TestMisc": 1.692333333333333, "TestMixTracingScripting": 0.16400000000000006, "TestModels": 4.721666666666667, "TestModuleAPIs": 0.19333333333333333, "TestModuleContainers": 3.1316666666666664, "TestModuleInterface": 0.9220000000000002, "TestModules": 0.04133333333333333, "TestNamedTuple": 0.29966666666666675, "TestNnapiBackend": 0.2386666666666668, "TestOpDecompositions": 0.30166666666666664, "TestOptimizeForMobilePreserveDebugInfo": 0.45933333333333337, "TestParametrization": 1.2939999999999998, "TestPeephole": 7.056333333333334, "TestProducerVersion": 0.017333333333333336, "TestProfiler": 0.09666666666666669, "TestPythonBindings": 0.9283333333333333, "TestPythonBuiltinOP": 4.508333333333334, "TestPythonIr": 0.38833333333333336, "TestRecursiveScript": 2.1856666666666666, "TestRemoveMutation": 3.361666666666667, "TestSaveLoad": 0.8140000000000002, "TestSaveLoadFlatbuffer": 0.6893333333333335, "TestSaveLoadForOpVersion": 2.6866666666666674, "TestScript": 68.47100000000007, "TestScriptDict": 0.5539999999999999, "TestScriptList": 1.324, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.49233333333333346, "TestScriptProfile": 22.650333333333332, "TestSlice": 0.6330000000000001, "TestSparse": 0.19000000000000003, "TestStringFormatting": 0.45233333333333353, "TestSymbolicShapeAnalysis": 33.57033333333333, "TestTensorBuiltins": 0.5766666666666667, "TestTensorCreationOps": 0.19766666666666666, "TestTensorMethods": 0.11199999999999999, "TestTorchbind": 0.2303333333333335, "TestTracer": 1.0160000000000007, "TestTypeSharing": 1.2780000000000002, "TestTypesAndAnnotation": 0.5943333333333335, "TestTyping": 2.163, "TestUnion": 2.6033333333333335, "TestUnsupportedOps": 0.14100000000000001, "TestUpgraders": 1.5310000000000004, "TestWarn": 0.3816666666666666, "TestWith": 0.85}, "test_jit_autocast": {"TestAutocast": 0.0, "TestJitTraceAutocast": 0.0}, "test_jit_disabled": {"TestJitDisabled": 0.37966666666666665}, "test_jit_fuser_te": {"TestFuserCommon": 0.235, "TestLoopnestRandomizationCPU": 0.9116666666666666, "TestNNCOpInfoCPU": 70.4833333333343, "TestTEFuserDynamic": 169.04533333333333, "TestTEFuserStatic": 117.07966666666664}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 1.0739999999999998, "TestFusionPatternCPU": 14.922666666666666, "TestModel": 6.195333333333333, "TestOpCPU": 37.75733333333333}, "test_legacy_vmap": {"TestVmapAPILegacy": 12.482, "TestVmapBatchedGradientLegacyCPU": 17.687, "TestVmapOperatorsLegacy": 110.83999999999999}, "test_license": {"TestLicense": 0.2973333333333334}, "test_linalg": {"TestLinalgCPU": 1540.267666666666}, "test_logging": {"LoggingTest": 2.2696666666666663}, "test_masked": {"TestMaskedCPU": 38.235666666666624}, "test_maskedtensor": {"TestBasicsCPU": 6.049666666666667, "TestBinary": 7.576666666666668, "TestOperatorsCPU": 7.409333333333342, "TestReductions": 4.847333333333334, "TestUnary": 20.249999999999996}, "test_meta": {"TestMetaCPU": 63.24666666666709, "TestMetaConverter": 2.578333333333333}, "test_mkl_verbose": {"TestMKLVerbose": 4.021}, "test_mkldnn": {"TestMkldnnCPU": 127.36933333333333}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0003333333333333333}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.073666666666667}, "test_mobile_optimizer": {"TestOptimizer": 4.682666666666667}, "test_model_dump": {"TestModelDump": 2.894}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.11866666666666666}, "test_module_tracker": {"TestModuleTracker": 0.47866666666666663}, "test_modules": {"TestModuleCPU": 35.52366666666758}, "test_monitor": {"TestMonitor": 0.27166666666666667, "TestMonitorTensorboard": 0.0}, "test_multiprocessing": {"TestMultiprocessing": 25.593999999999998}, "test_multiprocessing_spawn": {"ErrorTest": 0.025666666666666667, "ForkTest": 0.874, "SpawnTest": 23.52033333333333}, "test_namedtensor": {"TestNamedTensor": 6.987666666666665}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.8133333333333332}, "test_native_functions": {"TestNativeFunctions": 0.7366666666666669}, "test_native_mha": {"TestMHADeviceTypeCPU": 23.81}, "test_nestedtensor": {"TestNestedTensor": 2.326, "TestNestedTensorAutogradCPU": 5.819, "TestNestedTensorDeviceTypeCPU": 12.588333333333333, "TestNestedTensorSubclassCPU": 50.54833333333334}, "test_nn": {"TestAddRelu": 0.10566666666666667, "TestConstantPadNd": 0.09066666666666667, "TestFunctionalPickle": 0.017666666666666667, "TestFusionEval": 1.199, "TestFusionUtils": 0.3713333333333333, "TestNN": 136.97099999999998, "TestNNDeviceTypeCPU": 547.3333333333336, "TestUtils": 0.023000000000000003}, "test_numba_integration": {"TestNumbaIntegration": 0.2566666666666667}, "test_numpy_interop": {"TestNumPyInteropCPU": 8.503333333333332}, "test_openmp": {"TestOpenMP_ParallelFor": 7.791333333333334}, "test_ops": {"TestCommonCPU": 35.11666666666826, "TestCompositeComplianceCPU": 5.303333333333239, "TestFakeTensorCPU": 3.268999999999753, "TestMathBitsCPU": 2.954333333333173, "TestRefsOpsInfoCPU": 1.1486666666666545, "TestSelfKwarg": 0.156, "TestTagsCPU": 1.3756666666666504}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 4.374999999999767}, "test_ops_gradients": {"TestBwdGradientsCPU": 8.314666666666536}, "test_ops_jit": {"TestJitCPU": 1.550999999999979}, "test_optim": {"TestDifferentiableOptimizer": 0.09033333333333336, "TestLRScheduler": 14.388666666666664, "TestOptimRenewedCPU": 367.10166666666674, "TestSWAUtils": 5.780999999999999}, "test_out_dtype_op": {"TestOutDtypeOp": 1.046}, "test_overrides": {"TestBroadcastAllOverride": 0.39333333333333337, "TestDisabledTorchFunction": 0.012666666666666666, "TestDisabledUserWarnings": 0.018, "TestEinsumOverride": 0.5923333333333333, "TestGradCheckOverride": 0.48299999999999993, "TestGradNewOnesOverride": 0.01, "TestIndexing": 0.09466666666666668, "TestIterator": 0.009333333333333332, "TestNamedTuple": 0.010666666666666666, "TestPickle": 0.009666666666666665, "TestRNN": 0.06833333333333334, "TestResolveName": 0.225, "TestTorchFunctionMode": 0.38800000000000007, "TestTorchFunctionOverride": 239.9136666666708, "TestTorchFunctionWarning": 0.01933333333333333, "TestWrapTorchFunction": 0.010333333333333333}, "test_package": {"DirectoryReaderTest": 8.778666666666666, "ModelTest": 0.02733333333333333, "TestAnalyze": 1.1523333333333334, "TestDependencyAPI": 19.699333333333332, "TestDependencyHooks": 5.4993333333333325, "TestDiGraph": 14.036666666666667, "TestGlobGroup": 15.339333333333334, "TestImporter": 6.437333333333332, "TestLoadBCPackages": 3.292666666666667, "TestMangling": 10.832666666666666, "TestMisc": 11.701666666666666, "TestPackageFX": 7.685, "TestPackageScript": 31.349333333333334, "TestRepackage": 1.6336666666666666, "TestResources": 4.209, "TestSaveLoad": 12.228666666666669}, "test_per_overload_api": {"TestPerOverloadAPI": 0.9913333333333334}, "test_prims": {"TestDecompCPU": 0.025333333333333333, "TestPrimsBasic": 0.46466666666666673, "TestPrimsCPU": 0.5446666666666666, "TestRefsCPU": 0.23933333333333331}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.4603333333333333, "TestGenericProxyTensorFake": 12.920333333333332, "TestGenericProxyTensorReal": 15.149, "TestGenericProxyTensorSymbolic": 27.667666666666666, "TestProxyTensorOpInfoCPU": 34.758666666667466, "TestRealProxyTensor": 0.02033333333333333, "TestSymbolicTracing": 10.787666666666667}, "test_pruning_op": {"PruningOpTest": 0.24833333333333332}, "test_public_bindings": {"TestPublicBindings": 0.746}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.355, "TestPythonDispatch": 5.254999999999998, "TestPythonDispatcher": 0.11533333333333333, "TestPythonRegistration": 2.4613333333333336, "TestWrapperSubclassAliasingCPU": 0.6146666666666668}, "test_pytree": {"TestCxxPytree": 1.4153333333333336, "TestGenericPytree": 4.056, "TestPythonPytree": 3.685666666666666}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.09900000000000002, "TestAOMigrationNNQuantized": 0.16666666666666674, "TestAOMigrationQuantization": 0.12966666666666668, "TestAOMigrationQuantizationFx": 0.12466666666666669, "TestBackendConfig": 3.252333333333333, "TestBiasCorrectionEager": 1.9156666666666666, "TestBitsCPU": 0.5373333333333333, "TestComparatorOps": 2.6010000000000004, "TestDeprecatedJitQuantized": 4.625, "TestDistributed": 0.6813333333333335, "TestDuplicateDQPass": 9.084666666666665, "TestDynamicQuantizedModule": 65.0, "TestDynamicQuantizedOps": 35.736333333333334, "TestEqualizeEager": 2.1413333333333333, "TestEqualizeFx": 47.285, "TestFXGraphMatcher": 5.555666666666667, "TestFXGraphMatcherModels": 6.596333333333334, "TestFXNumericSuiteCoreAPIs": 67.10199999999999, "TestFXNumericSuiteCoreAPIsModels": 35.788000000000004, "TestFXNumericSuiteNShadows": 50.99966666666666, "TestFakeQuantize": 4.589666666666667, "TestFakeQuantizeOps": 17.96, "TestFloat8DtypeCPU": 4.137999999999999, "TestFloat8DtypeCPUOnlyCPU": 0.42533333333333334, "TestFuseEager": 14.430666666666667, "TestFuseFx": 8.254333333333333, "TestFusedObsFakeQuant": 1.5763333333333334, "TestFusedObsFakeQuantModule": 1.5893333333333333, "TestFusionPasses": 0.05166666666666667, "TestFxDetectInputWeightEqualization": 2.2729999999999997, "TestFxDetectOutliers": 3.8983333333333334, "TestFxModelReportClass": 8.202666666666666, "TestFxModelReportDetectDynamicStatic": 0.9553333333333334, "TestFxModelReportDetector": 3.674666666666667, "TestFxModelReportObserver": 3.3929999999999993, "TestFxModelReportVisualizer": 6.902333333333334, "TestGenerateNumericDebugHandle": 0.5906666666666666, "TestGraphUtils": 1.7966666666666669, "TestHistogramObserver": 33.936, "TestMetaDataPorting": 13.111333333333333, "TestModelNumericsEager": 2.7543333333333333, "TestNumericSuiteEager": 37.022, "TestObserver": 6.119666666666667, "TestPT2ERepresentation": 2.1846666666666663, "TestPadding": 14.052999999999999, "TestQNNPackOps": 8.040666666666667, "TestQuantizationDocs": 0.067, "TestQuantizeDynamicJitOps": 1.7806666666666666, "TestQuantizeDynamicJitPasses": 5.978999999999999, "TestQuantizeEagerOps": 8.400666666666666, "TestQuantizeEagerPTQDynamic": 16.856666666666666, "TestQuantizeEagerPTQStatic": 40.71366666666666, "TestQuantizeEagerQAT": 37.69366666666667, "TestQuantizeEagerQATNumerics": 38.104000000000006, "TestQuantizeFx": 128.9826666666667, "TestQuantizeFxModels": 22.990333333333336, "TestQuantizeFxOps": 280.926, "TestQuantizeJit": 27.52, "TestQuantizeJitOps": 228.36266666666666, "TestQuantizeJitPasses": 10.860666666666667, "TestQuantizePT2E": 48.47066666666666, "TestQuantizePT2EQATModels": 2.2786666666666666, "TestQuantizePT2EQAT_ConvBn1d": 52.785000000000004, "TestQuantizePT2EQAT_ConvBn2d": 44.70733333333334, "TestQuantizePT2EX86Inductor": 92.80433333333333, "TestQuantizedConv": 84.16, "TestQuantizedEmbeddingOps": 9.515333333333333, "TestQuantizedFunctionalOps": 3.606666666666667, "TestQuantizedLinear": 27.836333333333332, "TestQuantizedOps": 172.89499999999998, "TestQuantizedTensor": 59.586333333333336, "TestRecordHistogramObserver": 0.142, "TestReferenceQuantizedModule": 1.1423333333333332, "TestSerialization": 7.803999999999999, "TestStaticQuantizedModule": 143.5416666666667, "TestSubgraphRewriter": 2.607666666666667, "TestUtils": 1.353, "TestXNNPACKQuantizer": 27.71366666666667, "TestXNNPACKQuantizerModels": 2.5340000000000003}, "test_reductions": {"TestReductionsCPU": 513.3746666667045}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 128.91766666666663}, "test_schema_check": {"TestSchemaCheck": 0.44266666666666693, "TestSchemaCheckModeOpInfoCPU": 57.714000000001505}, "test_segment_reductions": {"TestSegmentReductionsCPU": 27.759666666666664}, "test_serialization": {"TestBothSerializationCPU": 0.25633333333333336, "TestOldSerialization": 38.81066666666666, "TestSerialization": 25.498000000000005, "TestSubclassSerialization": 0.4503333333333334}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.26966666666666667}, "test_shape_ops": {"TestShapeOpsCPU": 14.65933333333333}, "test_show_pickle": {"TestShowPickle": 0.2753333333333334}, "test_sort_and_select": {"TestSortAndSelectCPU": 41.96}, "test_sparse": {"TestSparseAnyCPU": 411.6216666666657, "TestSparseCPU": 486.3089999999999, "TestSparseLegacyAndDeprecation": 0.129, "TestSparseMaskedReductionsCPU": 0.3990000000000001, "TestSparseMeta": 49.82, "TestSparseOneOff": 0.12433333333333334, "TestSparseUnaryUfuncsCPU": 13.227333333333357}, "test_sparse_csr": {"TestSparseCSRCPU": 198.8013333333208, "TestSparseCSRSampler": 0.818, "TestSparseCompressedCPU": 178.8576666666671, "TestSparseCompressedTritonKernelsCPU": 0.08433333333333333}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.21600000000000005}, "test_spectral_ops": {"TestFFTCPU": 29.24000000000009, "TestFFTDocExamplesCPU": 0.47133333333333355}, "test_stateless": {"TestPythonOptimizeMode": 3.4266666666666663, "TestStatelessDeprecation": 1.6450000000000002, "TestStatelessFunctionalAPI": 10.615}, "test_subclass": {"TestSubclass": 3.771999999999998}, "test_sympy_utils": {"TestNumbers": 0.361, "TestSingletonInt": 0.03366666666666667, "TestSympyInterp": 33.983, "TestSympySolve": 1.4026666666666667, "TestValueRanges": 6.441333333333333}, "test_tensor_creation_ops": {"TestAsArrayCPU": 81.95133333333337, "TestBufferProtocolCPU": 40.70900000000001, "TestLikeTensorCreationCPU": 0.2906666666666667, "TestRandomTensorCreationCPU": 23.426999999999996, "TestTensorCreationCPU": 56.64600000000002}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.55, "TestTensorBoardFigure": 0.017, "TestTensorBoardNumpy": 0.06266666666666666, "TestTensorBoardPyTorchNumpy": 0.5363333333333333, "TestTensorBoardPytorchGraph": 32.547, "TestTensorBoardSummary": 2.1246666666666667, "TestTensorBoardSummaryWriter": 0.06066666666666667, "TestTensorBoardUtils": 0.5423333333333332, "TestTensorBoardWriter": 0.7306666666666667, "TestTensorProtoSummary": 0.30833333333333335}, "test_tensorexpr": {"TestTensorExprFuser": 0.002}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.10000000000000002, "TestTensorExprPyBind": 3.616}, "test_testing": {"TestAssertClose": 2.116333333333333, "TestAssertCloseContainer": 0.1703333333333333, "TestAssertCloseErrorMessage": 0.6836666666666668, "TestAssertCloseQuantized": 0.18966666666666665, "TestAssertCloseSparseBSC": 0.14033333333333334, "TestAssertCloseSparseBSR": 0.16933333333333334, "TestAssertCloseSparseCOO": 0.8636666666666667, "TestAssertCloseSparseCSC": 0.129, "TestAssertCloseSparseCSR": 0.158, "TestFrameworkUtils": 10.314333333333332, "TestImports": 14.274999999999999, "TestMakeTensorCPU": 57.650000000000055, "TestOpInfoSampleFunctionsCPU": 12.46699999999998, "TestOpInfos": 0.024999999999999998, "TestTestParametrization": 0.17800000000000005, "TestTestParametrizationDeviceTypeCPU": 3.7573333333333316, "TestTestingCPU": 1.5116666666666667}, "test_torch": {"TestBasicVitalSigns": 0.29466666666666663, "TestTorch": 37.322666666666684, "TestTorchDeviceTypeCPU": 211.41299999999958, "TestVitalSignsCudaCPU": 0.01}, "test_transformers": {"TestAttnBiasCPU": 15.962666666666665, "TestSDPACPU": 730.4329999999995, "TestSDPAFailureModesCPU": 0.5026666666666667, "TestTransformersCPU": 141.73933333333335}, "test_type_hints": {"TestTypeHints": 0.251}, "test_type_info": {"TestDTypeInfo": 0.3146666666666667}, "test_type_promotion": {"TestTypePromotionCPU": 59.26466666666668}, "test_typing": {"TestTyping": 79.03499999999998}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 251.55233333321974}, "test_utils": {"TestAssert": 0.09600000000000002, "TestBottleneck": 7.682333333333333, "TestCheckpoint": 2.6809999999999996, "TestCollectEnv": 0.9636666666666667, "TestCppExtensionUtils": 0.13733333333333334, "TestDataLoaderUtils": 4.401666666666666, "TestDeviceUtilsCPU": 53.62766666666848, "TestExtensionUtils": 0.10266666666666668, "TestHipify": 0.007, "TestHipifyTrie": 0.10933333333333332, "TestONNXUtils": 0.017, "TestRenderUtils": 0.08966666666666667, "TestStandaloneCPPJIT": 1.6353333333333333, "TestTraceback": 0.04466666666666667}, "test_view_ops": {"TestOldViewOpsCPU": 26.182666666666663, "TestViewOpsCPU": 20.863, "TestViewOpsLAZY": 5.204999999999996}, "test_vulkan": {"TestVulkanRewritePass": 0.0006666666666666666}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.152, "WeakKeyDictionaryTestCase": 0.31833333333333336, "WeakTest": 5.368666666666667}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 30.711666666666662, "TestXNNPACKOps": 8.702999999999998, "TestXNNPACKRewritePass": 1.8136666666666665, "TestXNNPACKSerDes": 4.948666666666667}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.8783333333333339}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.7563333333333336, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.025666666666666667, "TestMisc": 0.03566666666666667, "TestPickling": 0.3063333333333335, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 26.189000000000004, "TestEinsumPath": 0.0, "TestMisc": 0.105}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.29233333333333333, "TestHalf": 0.0, "TestIinfo": 0.08366666666666667, "TestMisc": 0.03666666666666667, "TestPythonFloat": 0.0006666666666666666, "TestRepr": 0.024333333333333335, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.062, "TestBooleanIndexing": 0.12866666666666668, "TestBroadcastedAssignments": 0.26233333333333336, "TestFancyIndexingCast": 0.155, "TestFloatNonIntegerArgument": 0.13066666666666668, "TestIndexing": 2.334666666666667, "TestMultiIndexingAutomated": 0.11433333333333333, "TestMultipleEllipsisError": 0.03466666666666667, "TestNonIntegerArrayLike": 0.008333333333333333}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.4656666666666667, "TestArgwhere": 0.7133333333333334, "TestArrayComparisons": 2.2896666666666667, "TestBaseRepr": 0.20633333333333334, "TestBinaryRepr": 0.26466666666666666, "TestBoolArray": 5.151666666666667, "TestBoolCmp": 3.408333333333333, "TestBoolScalar": 0.8409999999999999, "TestBroadcast": 0.5066666666666667, "TestClip": 2.7353333333333327, "TestConvolve": 0.21566666666666667, "TestCorrelate": 0.544, "TestCreationFuncs": 4.75, "TestCross": 0.9396666666666665, "TestDtypePositional": 0.017333333333333336, "TestFloatExceptions": 0.41566666666666663, "TestFromiter": 0.0, "TestIndex": 0.17833333333333334, "TestIndices": 0.441, "TestIsclose": 1.146, "TestIsscalar": 0.068, "TestLikeFuncs": 0.0006666666666666666, "TestMoveaxis": 0.07133333333333332, "TestNonarrayArgs": 1.217666666666667, "TestNonzeroAndCountNonzero": 1.4653333333333334, "TestOuterMisc": 0.055, "TestRequire": 0.04966666666666667, "TestResize": 0.5376666666666666, "TestRoll": 0.8706666666666667, "TestRollaxis": 0.06766666666666667, "TestSeterr": 0.268, "TestStdVar": 5.754999999999999, "TestStdVarComplex": 0.07233333333333335, "TestStringFunction": 0.20766666666666667, "TestTensordot": 0.08800000000000001, "TestTypes": 0.48233333333333334}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.026999999999999996, "TestCommonType": 0.41666666666666674, "TestDocStrings": 0.0, "TestIsSubDType": 0.11299999999999999, "TestScalarTypeNames": 0.1953333333333334}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 1.1783333333333337, "TestFromInt": 0.042333333333333334, "TestFromString": 0.4763333333333333}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.21, "TestIsInteger": 0.0016666666666666668}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 1.6540000000000001, "TestBaseMath": 0.34366666666666673, "TestBitShifts": 0.521666666666667, "TestComplexDivision": 0.029666666666666664, "TestConversion": 0.13566666666666666, "TestHash": 0.0, "TestModulus": 0.521, "TestMultiply": 0.0, "TestNegative": 0.03366666666666667, "TestPower": 0.09000000000000001, "TestRepr": 0.02766666666666667, "TestScalarOpsMisc": 1.825333333333333, "TestScalarSubclassingMisc": 0.6613333333333338, "TestSubtract": 0.03666666666666666, "TestTypes": 0.311}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.41866666666666674, "TestAtleast2d": 0.13, "TestAtleast3d": 0.11866666666666666, "TestBlock": 0.2903333333333334, "TestConcatenate": 2.5376666666666665, "TestHstack": 0.1996666666666667, "TestStackMisc": 1.1916666666666669, "TestVstack": 0.20833333333333334}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.008, "TestFFTShift": 0.7543333333333333, "TestIRFFTN": 0.028, "TestRFFTFreq": 0.007666666666666666}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 80.11666666666666, "TestFFTShift": 0.2853333333333334, "TestFFTThreadSafe": 0.9606666666666666}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.6316666666666667}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0023333333333333335, "TestUnique": 3.9053333333333335}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.03, "TestAmax": 0.053, "TestAmin": 0.05399999999999999, "TestAngle": 0.1406666666666667, "TestAny": 0.09900000000000002, "TestAverage": 0.466, "TestBincount": 0.48766666666666664, "TestCheckFinite": 0.07466666666666667, "TestCopy": 0.06733333333333334, "TestCorrCoef": 0.39466666666666667, "TestCov": 0.7920000000000001, "TestCumprod": 0.017666666666666667, "TestCumsum": 0.02, "TestDelete": 1.458, "TestDiff": 0.9739999999999999, "TestDigitize": 0.5766666666666667, "TestExtins": 0.26333333333333336, "TestFilterwindows": 3.179, "TestFlip": 0.20733333333333334, "TestGradient": 1.3706666666666667, "TestInsert": 2.4446666666666665, "TestInterp": 11.387333333333332, "TestKaiser": 0.10099999999999999, "TestMedian": 4.070666666666667, "TestMeshgrid": 0.6353333333333335, "TestMsort": 0.0, "TestPercentile": 4.395333333333334, "TestPiecewise": 0.08, "TestProd": 0.018000000000000002, "TestPtp": 0.09866666666666667, "TestQuantile": 0.8603333333333335, "TestRot90": 0.46900000000000003, "TestSelect": 0.07333333333333332, "TestSinc": 0.07400000000000001, "TestSortComplex": 0.266, "TestTrapz": 0.5966666666666668, "TestTrimZeros": 0.18366666666666664, "TestUnique": 0.104, "Test_I0": 0.163}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 3.1446666666666663, "TestHistogramOptimBinNums": 1.3236666666666665, "TestHistogramdd": 1.9420000000000002}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.030333333333333334, "TestConcatenator": 0.056666666666666664, "TestDiagIndices": 0.051666666666666666, "TestDiagIndicesFrom": 0.07100000000000001, "TestFillDiagonal": 0.18966666666666665, "TestGrid": 0.09933333333333332, "TestIndexExpression": 0.15866666666666665, "TestIx_": 0.14700000000000002, "TestNdIndex": 0.009333333333333332, "TestNdenumerate": 0.010333333333333333, "TestRavelUnravelIndex": 1.1440000000000001}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.5970000000000001, "TestApplyOverAxes": 0.010666666666666666, "TestArraySplit": 1.313, "TestColumnStack": 0.08900000000000001, "TestDsplit": 0.09466666666666666, "TestDstack": 0.1396666666666667, "TestExpandDims": 0.059666666666666666, "TestHsplit": 0.09166666666666667, "TestKron": 0.4280000000000001, "TestMayShareMemory": 0.078, "TestPutAlongAxis": 0.09433333333333334, "TestSplit": 0.04866666666666667, "TestSqueeze": 0.4990000000000001, "TestTakeAlongAxis": 0.4200000000000001, "TestTile": 0.25266666666666665, "TestVsplit": 0.07}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.527, "TestEye": 0.658, "TestFliplr": 0.013666666666666667, "TestFlipud": 0.042333333333333334, "TestHistogram2d": 0.616, "TestTri": 0.2783333333333333, "TestTrilIndicesFrom": 0.018, "TestTriuIndices": 0.08033333333333334, "TestTriuIndicesFrom": 0.017, "TestVander": 0.124}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.008333333333333333, "TestCommonType": 0.5790000000000001, "TestImag": 0.161, "TestIscomplex": 0.04933333333333333, "TestIscomplexobj": 0.12666666666666668, "TestIsfinite": 0.3103333333333333, "TestIsinf": 0.25033333333333335, "TestIsnan": 0.2926666666666667, "TestIsneginf": 0.06366666666666666, "TestIsposinf": 0.06433333333333334, "TestIsreal": 0.06433333333333334, "TestIsrealobj": 0.049999999999999996, "TestIsscalar": 0.11666666666666665, "TestMintypecode": 0.044333333333333336, "TestNanToNum": 0.4323333333333334, "TestReal": 0.168, "TestRealIfClose": 0.2893333333333334}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 1.893666666666667, "TestCond": 2.369666666666667, "TestDet": 0.3256666666666667, "TestEig": 0.436, "TestEigh": 0.283, "TestEighCases": 0.0, "TestEigvals": 0.5380000000000001, "TestEigvalsh": 0.29633333333333334, "TestEigvalshCases": 0.0, "TestInv": 0.48466666666666675, "TestLstsq": 3.7870000000000004, "TestMatrixRank": 0.45599999999999996, "TestMisc": 0.21266666666666664, "TestMisc2": 0.03333333333333333, "TestMultiDot": 0.4630000000000001, "TestNormDouble": 1.859333333333333, "TestNormInt64": 1.7543333333333333, "TestNormSingle": 1.8549999999999998, "TestNorm_NonSystematic": 0.02366666666666667, "TestPinv": 1.1703333333333334, "TestPinvHermitian": 0.31466666666666665, "TestQR": 4.680333333333334, "TestSVD": 0.5446666666666667, "TestSVDHermitian": 0.4313333333333334, "TestSolve": 0.9436666666666667, "TestTensorinv": 0.1643333333333333, "TestTensorsolve": 0.13066666666666668}, "torch_np/test_basic": {"TestArrayToSequence": 0.10333333333333335, "TestCopyTo": 0.128, "TestCtorNested": 0.03166666666666667, "TestDefaultDtype": 0.04766666666666667, "TestDivmod": 0.209, "TestExport": 0.4483333333333333, "TestMisc": 0.038, "TestNormalizations": 0.09366666666666668, "TestOneArr": 4.800333333333315, "TestOneArrAndAxesTuple": 0.25666666666666665, "TestOneArrAndAxis": 2.735666666666662, "TestOneArrAndShape": 0.4856666666666667, "TestOneArrToScalar": 0.257, "TestPythonArgsToArray": 0.14100000000000001, "TestSequenceOfArrays": 0.37566666666666676, "TestSequenceOfArraysToSingle": 0.20033333333333334, "TestShapeLikeToArray": 0.06566666666666666, "TestSmokeNotImpl": 0.014333333333333332}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 1.4960000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.9563333333333338}, "torch_np/test_function_base": {"TestAppend": 0.321}, "torch_np/test_ndarray_methods": {"TestAmax": 0.08800000000000001, "TestAmin": 0.08266666666666667, "TestArgmax": 6.994333333333333, "TestArgmaxArgminCommon": 10.744333333333335, "TestArgmin": 1.5796666666666666, "TestContains": 0.019666666666666666, "TestIndexing": 0.2916666666666667, "TestIter": 0.03833333333333333, "TestNoExtraMethods": 0.09400000000000001, "TestNonzero": 0.3413333333333333, "TestRavel": 0.018, "TestReshape": 0.019, "TestTranspose": 0.018333333333333333}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 25.91866666666647, "TestNEP50Table": 0.6050000000000003}, "torch_np/test_random": {"TestChoice": 0.05466666666666667, "TestNumpyGlobal": 0.023333333333333334, "TestScalarReturn": 0.6803333333333338, "TestShuffle": 0.22299999999999998}, "torch_np/test_reductions": {"TestAll": 0.1456666666666667, "TestAny": 0.11466666666666665, "TestFlatnonzero": 0.18933333333333335, "TestGenericCumSumProd": 0.20566666666666666, "TestGenericReductions": 12.022666666666574, "TestMean": 0.129, "TestSum": 1.0206666666666668}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.6123333333333335, "TestIsScalar": 0.35400000000000015}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 15.200000000000003, "TestNdarrayDunderVsUfunc": 2.5189999999999997, "TestUfuncDtypeKwd": 0.049666666666666665, "TestUnaryUfuncs": 0.9516666666666671}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 1.5146666666666666}}}, "linux-focal-py3.8-clang10": {"crossref": {"backends/xeon/test_launch": {"TestTorchrun": 2.1199999999999997}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.9526666666666663}, "distributions/test_constraints": {"test_constraints": 0.07400000000000005}, "distributions/test_distributions": {"TestAgainstScipy": 1.131, "TestConstraints": 0.1613333333333333, "TestDistributionShapes": 0.15466666666666676, "TestDistributions": 36.14000000000001, "TestFunctors": 0.013, "TestJit": 20.068666666666665, "TestKL": 2.907999999999999, "TestLazyLogitsInitialization": 0.015, "TestNumericalStability": 0.07933333333333335, "TestRsample": 0.6876666666666668, "TestValidation": 0.4136666666666667}, "export/test_converter": {"TestConverter": 8.488999999999999}, "export/test_db": {"ExampleTests": 3.3783333333333334}, "export/test_export": {"TestDynamismExpression": 0.6046666666666667, "TestExport": 32.86333333333333, "TestExportCustomClass": 0.08333333333333333, "TestOneOffModelExportResult": 1.1840000000000002}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.33266666666666667}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.6993333333333335}, "export/test_hop": {"TestHOPCPU": 3.0613333333333337, "TestHOPGeneric": 0.0030000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.18033333333333335, "TestLiftUnlift": 0.011000000000000001}, "export/test_pass_infra": {"TestPassInfra": 0.9630000000000001}, "export/test_passes": {"TestPasses": 14.905666666666669}, "export/test_safeguard": {"TestSafeguard": 0.9716666666666667}, "export/test_schema": {"TestSchema": 0.44566666666666666}, "export/test_serialize": {"TestDeserialize": 7.639333333333334, "TestOpVersioning": 0.0048000000000000004, "TestSaveLoad": 0.29900000000000004, "TestSchemaVersioning": 0.031, "TestSerialize": 1.2933333333333337, "TestSerializeCustomClass": 0.08633333333333333}, "export/test_sparse": {"TestSparseProp": 91.73399999999997}, "export/test_tools": {"TestExportTools": 0.5113333333333334}, "export/test_torchbind": {"TestCompileTorchbind": 1.5353333333333332, "TestExportTorchbind": 2.148333333333333, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.3066666666666667}, "export/test_unflatten": {"TestUnflatten": 3.375}, "export/test_upgrade": {"TestUpgrade": 0.417}, "export/test_verifier": {"TestVerifier": 1.0919999999999999}, "functorch/test_aotdispatch": {"TestAOTAutograd": 15.007666666666667, "TestAOTAutogradWithDynamo": 17.453666666666663, "TestAOTDispatch": 0.781, "TestAOTExport": 2.6603333333333334, "TestAOTModuleSimplified": 0.8143333333333334, "TestEagerFusionModuleInfoCPU": 972.2030000000001, "TestEagerFusionOpInfoCPU": 2469.270666666663, "TestPartitioning": 1.2966666666666669, "TestPythonKeyCPU": 1.32}, "functorch/test_control_flow": {"TestControlFlow": 0.8193333333333334, "TestControlFlowTraced": 124.1326666666666}, "functorch/test_dims": {"TestMin": 18.111, "TestMinFunctorchOnly": 15.725666666666664}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.1216666666666667, "TestAutogradFunctionVmapAPICPU": 0.02266666666666667, "TestCompileTransformsCPU": 9.965000000000002, "TestComposabilityCPU": 1.746333333333333, "TestExamplesCorrectnessCPU": 5.017, "TestFunctionalizeCPU": 0.15200000000000002, "TestGradTransformCPU": 0.5436666666666669, "TestHelpersCPU": 0.010333333333333333, "TestHessianCPU": 0.042333333333333334, "TestHigherOrderOperatorInteractionCPU": 0.036333333333333336, "TestJacCPU": 0.6263333333333335, "TestJvpCPU": 0.06433333333333335, "TestLinearizeCPU": 0.22566666666666668, "TestMakeFunctional": 0.11233333333333335, "TestSliceArgnums": 0.018333333333333337, "TestVmapJvpInplaceViewCPU": 0.017, "TestVmapOfGradCPU": 0.4156666666666667}, "functorch/test_logging": {"TestAOTLogging": 0.30866666666666664}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.4363333333333334, "RandomOpTestCase": 0.07966666666666666, "ReduceTestCase": 0.07633333333333332, "TestMemoryEfficientOpAuthoring": 0.0006666666666666666}, "functorch/test_minifier": {"TestMinifier": 0.505}, "functorch/test_ops": {"TestOperatorsCPU": 3935.66133333329}, "functorch/test_parsing": {"TestAnonymousAxis": 0.3193333333333333, "TestParsedExpression": 0.006333333333333333, "TestParsingUtils": 0.005333333333333333, "TestValidateRearrangeExpressions": 0.005666666666666667}, "functorch/test_rearrange": {"TestRearrange": 0.35666666666666674}, "functorch/test_vmap": {"TestRandomnessCPU": 1.7796666666666674, "TestTransformFailureCPU": 0.12766666666666668, "TestVmapAPI": 0.33500000000000013, "TestVmapBatchedGradientCPU": 0.2776666666666667, "TestVmapDeviceTypeCPU": 0.034333333333333334, "TestVmapNestedTensorCPU": 0.06233333333333333, "TestVmapOperators": 3.899666666666665, "TestVmapOperatorsOpInfoCPU": 670.4146666666658}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.2583333333331956}, "higher_order_ops/test_with_effects": {"TestWithEffects": 9.691333333333333}, "inductor/test_fx_fusion": {"TestFxFusion": 0.21333333333333337}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.01900000000000001}, "lazy/test_debug_util": {"DebugUtilTest": 0.32066666666666666}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.3236666666666667}, "lazy/test_generator": {"LazyGeneratorTest": 0.3606666666666667}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.621}, "lazy/test_step_closures": {"ClosuresTest": 2.271333333333333}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.293, "TestLazyOpInfoCPU": 9.859999999999978, "TestLazyTensor": 0.08200000000000002}, "nn/test_convolution": {"TestConvolutionNN": 13.01066666666667, "TestConvolutionNNDeviceTypeCPU": 7.103999999999954}, "nn/test_dropout": {"TestDropoutNN": 0.12, "TestDropoutNNDeviceTypeCPU": 0.35566666666666663}, "nn/test_embedding": {"TestEmbeddingNN": 0.09633333333333338, "TestEmbeddingNNDeviceTypeCPU": 9.304666666666675}, "nn/test_init": {"TestNNInit": 4.375999999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.5956666666666669}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.1309999999999996, "TestLoadStateDictSwap": 0.0033333333333333335}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.028666666666666663, "TestModuleHookNN": 0.11166666666666669, "TestModuleHooks": 0.10066666666666668, "TestStateDictHooks": 0.036333333333333336}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 7.176666666666666, "TestMultiheadAttentionNNDeviceTypeCPU": 0.04466666666666667}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5800000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.5629999999999988, "TestNNParametrizationDeviceCPU": 0.03933333333333333}, "nn/test_pooling": {"TestAvgPool": 0.3256666666666667, "TestPoolingNN": 0.3486666666666667, "TestPoolingNNDeviceTypeCPU": 30.182666666666666}, "nn/test_pruning": {"TestPruningNN": 0.12366666666666672}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.10466666666666667}, "profiler/test_memory_profiler": {"TestDataFlow": 1.4549999999999998, "TestIdentifyGradients": 0.29733333333333334, "TestMemoryProfiler": 0.355, "TestMemoryProfilerE2E": 3.6893333333333334}, "profiler/test_profiler": {"TestExecutionTrace": 8.973, "TestExperimentalUtils": 4.5009999999999994, "TestProfiler": 17.746000000000006, "TestProfilerCUDA": 0.001, "TestProfilerITT": 0.004666666666666667, "TestRecordFunction": 0.05366666666666667, "TestTorchTidyProfiler": 6.233999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.36166666666666675}, "profiler/test_record_function": {"TestRecordFunction": 0.38933333333333336}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.480999999999999}, "test_ao_sparsity": {"TestActivationSparsifier": 0.09033333333333333, "TestBaseDataScheduler": 0.034333333333333334, "TestBaseDataSparsifier": 0.09000000000000001, "TestBaseSparsifier": 0.03333333333333333, "TestBaseStructuredSparsifier": 1.963666666666667, "TestComposability": 2.786, "TestCubicScheduler": 0.006333333333333333, "TestFPGMPruner": 0.03, "TestFakeSparsity": 0.114, "TestFxComposability": 2.18, "TestNearlyDiagonalSparsifier": 0.9583333333333334, "TestNormDataSparsifiers": 1.2009999999999998, "TestQuantizationUtils": 0.042666666666666665, "TestQuantizedSparseKernels": 0.3893333333333333, "TestQuantizedSparseLayers": 0.5503333333333332, "TestSaliencyPruner": 0.036666666666666674, "TestScheduler": 0.015999999999999997, "TestSparsityUtilFunctions": 0.08266666666666667, "TestWeightNormSparsifier": 0.8206666666666668}, "test_autocast": {"TestAutocastCPU": 0.8290000000000001, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.005666666666666667}, "test_autograd": {"TestAllowMutationOnSaved": 0.03933333333333334, "TestAutograd": 20.474999999999962, "TestAutogradComplex": 0.006333333333333333, "TestAutogradDeviceTypeCPU": 0.34300000000000014, "TestAutogradForwardMode": 0.14600000000000007, "TestAutogradForwardModeBatchedGrad": 0.019333333333333334, "TestAutogradFunctional": 10.671333333333331, "TestAutogradInferenceMode": 0.03800000000000001, "TestAutogradLogging": 0.015, "TestAutogradMultipleDispatchCPU": 0.024333333333333332, "TestMultithreadAutograd": 0.2266666666666667, "TestNestedCheckpoint": 0.41433333333333344, "TestSelectiveActivationCheckpoint": 0.038}, "test_autograd_fallback": {"TestAutogradFallback": 0.35700000000000004}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 158.38066666666273}, "test_bundled_inputs": {"TestBundledInputs": 1.1619999999999997}, "test_comparison_utils": {"TestComparisonUtils": 0.395}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.064}, "test_content_store": {"TestContentStoreCPU": 7.876}, "test_cpp_api_parity": {"TestCppApiParity": 3.7323333333333206}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.024333333333333342, "TestMAIATensor": 0.007666666666666666, "TestORTTensor": 0.012666666666666666, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.024666666666666674, "TestMAIATensor": 0.007666666666666666, "TestORTTensor": 0.012000000000000002, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 28.588000000000005}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.7223333333333333}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 8.228}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.7486666666666667}, "test_custom_backend": {"TestCustomBackend": 0.07466666666666666}, "test_custom_ops": {"MiniOpTest": 0.6913333333333336, "MiniOpTestOther": 0.06600000000000002, "TestCustomOp": 2.5679999999999974, "TestCustomOpAPI": 0.2166666666666667, "TestCustomOpTestingCPU": 1.9336666666666673, "TestCustomOperators": 0.25933333333333336, "TestGenerateOpcheckTests": 3.9963333333333337}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 35.29633333333334, "TestConcatDataset": 0.009000000000000001, "TestConvAfterFork": 0.07833333333333332, "TestCustomPinFn": 0.0016666666666666668, "TestDataLoader": 37.27733333333333, "TestDataLoaderDeviceTypeCPU": 0.0030000000000000005, "TestDataLoaderPersistentWorkers": 61.13933333333333, "TestDatasetRandomSplit": 0.028333333333333335, "TestDictDataLoader": 0.07766666666666668, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004, "TestSetAffinity": 0.07666666666666666, "TestStackDataset": 0.03266666666666668, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.02333333333333333}, "test_datapipe": {"TestCaptureDataFrame": 0.0006666666666666666, "TestCircularSerialization": 0.010999999999999998, "TestDataChunk": 0.007333333333333333, "TestDataFramesPipes": 0.004666666666666667, "TestFunctionalIterDataPipe": 5.210333333333332, "TestFunctionalMapDataPipe": 0.041666666666666664, "TestGraph": 0.017, "TestIterDataPipeCountSampleYielded": 0.010666666666666666, "TestIterDataPipeGraphFastForward": 0.053, "TestIterDataPipeSingletonConstraint": 0.026000000000000006, "TestIterableDataPipeBasic": 0.034333333333333334, "TestSerialization": 7.061, "TestSharding": 0.26200000000000007, "TestStreamWrapper": 0.312, "TestTyping": 0.008000000000000002}, "test_decomp": {"DecompOneOffTestsCPU": 0.02266666666666667, "HasDecompTest": 0.47600000000000015, "TestDecompCPU": 248.5956666666667}, "test_deploy": {"TestFreezer": 0.29833333333333334}, "test_dispatch": {"TestDispatch": 24.72066666666666, "TestPythonDispatcher": 0.014333333333333332}, "test_dlpack": {"TestTorchDlPackCPU": 0.24266666666666684}, "test_dynamic_shapes": {"TestDimConstraints": 1.7463333333333335, "TestFloorDiv": 0.012333333333333335, "TestGuardsExpressions": 0.02466666666666667, "TestPySymInt": 1.291333333333333, "TestSymNumberMagicMethods": 1.8469999999999953}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 2.8926666666666647, "TestExpandedWeightHelperFunctionCPU": 0.019333333333333338, "TestExpandedWeightModuleCPU": 7.480666666666668}, "test_fake_tensor": {"FakeTensorConstHandling": 0.054333333333333345, "FakeTensorConverterTest": 0.023000000000000003, "FakeTensorDispatchCache": 0.06433333333333334, "FakeTensorOpInfoTestCPU": 0.08966666666666667, "FakeTensorOperatorInvariants": 0.2773333333333334, "FakeTensorPropTest": 0.068, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.5156666666666668, "PropagateRealTensorsFakeTensorConstHandling": 0.08400000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.022333333333333334, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.06833333333333334, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.15600000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.04533333333333334, "PropagateRealTensorsFakeTensorTest": 0.22866666666666668}, "test_flop_counter": {"TestFlopCounter": 0.626}, "test_foreach": {"TestForeachCPU": 77.18599999999996}, "test_function_schema": {"TestFunctionSchema": 0.7113333333333333}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 39.916000000000004}, "test_functional_optim": {"TestFunctionalOptimParity": 0.5193333333333333}, "test_functionalization": {"TestCrossRefFunctionalization": 2.6916666666666664, "TestFunctionalization": 3.3006666666666646}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.022333333333333334}, "test_futures": {"TestFuture": 0.9216666666666667}, "test_fx": {"AnnotationsTest": 0.012333333333333337, "TestCSEPass": 0.24833333333333338, "TestCommonPass": 0.056333333333333326, "TestConstFold": 0.15800000000000006, "TestConstParamShapeInControlFlow": 0.042, "TestDCE": 0.02666666666666667, "TestFX": 2.64333333333333, "TestFXAPIBackwardCompatibility": 0.028666666666666663, "TestFunctionalTracing": 0.32400000000000023, "TestMatcher": 0.3266666666666667, "TestOperatorSignaturesCPU": 2.6956666666666504, "TestPassManager": 0.021, "TestSourceMatcher": 1.3419999999999999, "TestSubgraphRewriter": 0.26266666666666677, "TestVisionTracing": 220.08866666666657, "TypeCheckerTest": 1.5186666666666646}, "test_fx_experimental": {"TestFXExperimental": 17.590333333333334, "TestNormalizeOperatorsCPU": 56.50533333333334, "TestTranslationValidation": 0.19199999999999998}, "test_fx_passes": {"TestFXGraphPasses": 0.6486666666666668, "TestFXMatcherUtils": 0.09633333333333334}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5940000000000002}, "test_import_stats": {"TestImportTime": 3.389}, "test_indexing": {"NumpyTestsCPU": 0.05000000000000002, "TestIndexingCPU": 1.9863333333333315}, "test_itt": {"TestItt": 0.32666666666666666}, "test_jit": {"TestAliasAnalysis": 0.33066666666666666, "TestAsync": 0.4653333333333333, "TestAtenPow": 0.011333333333333334, "TestAutodiffJit": 0.076, "TestAutodiffSubgraphSlicing": 0.30666666666666675, "TestAwait": 0.21966666666666668, "TestBackends": 0.7060000000000001, "TestBackendsWithCompiler": 0.16, "TestBatchMM": 0.09300000000000001, "TestBuiltins": 0.051, "TestClassType": 0.9, "TestComplex": 0.8533333333333335, "TestCustomOperators": 0.05833333333333334, "TestDCE": 0.024333333333333332, "TestDataParallel": 0.004, "TestDataclasses": 4.636333333333333, "TestDeviceAnalysis": 4.008333333333333, "TestDict": 0.4543333333333335, "TestDtypeAnalysis": 0.17300000000000004, "TestDtypeCustomRulesCPU": 2.938999999999997, "TestEnum": 0.15866666666666668, "TestFreezing": 1.317666666666667, "TestFrontend": 0.059, "TestFrozenOptimizations": 14.093999999999996, "TestFunctionalBlocks": 0.008333333333333333, "TestFunctionalToInplaceActivation": 2.580666666666667, "TestGenerator": 0.076, "TestGetDefaultAttr": 0.024333333333333332, "TestGraphRewritePasses": 0.078, "TestHash": 0.07733333333333332, "TestHooks": 0.7723333333333336, "TestIgnorableArgs": 0.011000000000000001, "TestIgnoreContextManager": 0.03933333333333334, "TestInplaceToFunctionalActivation": 2.6520000000000006, "TestIsinstance": 0.25700000000000006, "TestJit": 5.524999999999998, "TestJitGeneratedModule": 12.509000000000055, "TestJitProfiler": 0.0016666666666666668, "TestJitUtils": 0.017333333333333336, "TestList": 1.4176666666666666, "TestLogging": 0.049999999999999996, "TestMKLDNNReinplacing": 0.004666666666666667, "TestMisc": 0.1636666666666667, "TestMixTracingScripting": 1.082, "TestModels": 2.2216666666666653, "TestModuleAPIs": 0.11866666666666666, "TestModuleContainers": 1.4103333333333332, "TestModuleInterface": 0.3646666666666667, "TestModules": 0.018333333333333333, "TestNamedTuple": 0.07966666666666668, "TestNnapiBackend": 13.44466666666667, "TestOpDecompositions": 0.018666666666666668, "TestOptimizeForMobilePreserveDebugInfo": 0.20766666666666667, "TestParametrization": 0.13799999999999998, "TestPeephole": 0.5080000000000001, "TestProducerVersion": 0.002, "TestProfiler": 0.532, "TestPythonBindings": 0.041, "TestPythonBuiltinOP": 0.4333333333333334, "TestPythonIr": 0.026666666666666672, "TestRecursiveScript": 0.6673333333333336, "TestRemoveMutation": 0.18433333333333335, "TestSaveLoad": 0.5136666666666667, "TestSaveLoadFlatbuffer": 0.2676666666666667, "TestSaveLoadForOpVersion": 2.452, "TestScript": 16.86799999999999, "TestScriptDict": 0.036333333333333336, "TestScriptList": 0.9193333333333328, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.14866666666666667, "TestScriptProfile": 0.39566666666666667, "TestSlice": 0.17866666666666672, "TestSparse": 0.07200000000000001, "TestStringFormatting": 0.1216666666666667, "TestSymbolicShapeAnalysis": 2.0033333333333325, "TestTensorBuiltins": 0.06899999999999999, "TestTensorCreationOps": 0.04666666666666667, "TestTensorMethods": 0.020666666666666667, "TestTorchbind": 0.1393333333333334, "TestTracer": 2.8483333333333305, "TestTypeSharing": 0.48133333333333345, "TestTypesAndAnnotation": 0.09333333333333334, "TestTyping": 0.34833333333333344, "TestUnion": 0.5113333333333335, "TestUnsupportedOps": 0.03166666666666667, "TestUpgraders": 0.07433333333333333, "TestWarn": 0.049666666666666665, "TestWith": 0.3263333333333333}, "test_jit_autocast": {"TestAutocast": 0.18400000000000002, "TestJitTraceAutocast": 18.428}, "test_jit_disabled": {"TestJitDisabled": 0.40433333333333327}, "test_jit_fuser_te": {"TestFuserCommon": 0.13999999999999999, "TestLoopnestRandomizationCPU": 0.04, "TestNNCOpInfoCPU": 45.68800000000025, "TestTEFuserDynamic": 125.9813333333334, "TestTEFuserStatic": 55.01599999999999}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.07433333333333335, "TestFusionPatternCPU": 5.452999999999999, "TestModel": 3.5873333333333335, "TestOpCPU": 37.165000000000006}, "test_legacy_vmap": {"TestVmapAPI": 1.1533333333333329, "TestVmapAPILegacy": 1.0373333333333326, "TestVmapBatchedGradientCPU": 0.08866666666666671, "TestVmapBatchedGradientLegacyCPU": 0.12166666666666671, "TestVmapOperators": 1.3073333333333332, "TestVmapOperatorsLegacy": 1.2349999999999999}, "test_license": {"TestLicense": 0.296}, "test_linalg": {"TestLinalgCPU": 158.87433333333283}, "test_logging": {"LoggingTest": 2.9553333333333334}, "test_masked": {"TestMaskedCPU": 21.528333333333293}, "test_maskedtensor": {"TestBasicsCPU": 0.124, "TestBinary": 0.38933333333333353, "TestOperatorsCPU": 5.800333333333246, "TestReductions": 0.07666666666666667, "TestUnary": 0.35900000000000026}, "test_meta": {"TestMetaCPU": 115.5196666666372, "TestMetaConverter": 0.08033333333333337}, "test_mkl_verbose": {"TestMKLVerbose": 4.387666666666667}, "test_mkldnn": {"TestMkldnnCPU": 117.49999999999996}, "test_mkldnn_fusion": {"TestMkldnnFusion": 59.07866666666666}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.7849999999999997}, "test_mobile_optimizer": {"TestOptimizer": 2.787333333333333}, "test_model_dump": {"TestModelDump": 1.2646666666666666}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.19133333333333336}, "test_module_init": {"TestModuleInitCPU": 2.055999999999991}, "test_module_tracker": {"TestModuleTracker": 0.3313333333333333}, "test_modules": {"TestModuleCPU": 648.6009999999902}, "test_monitor": {"TestMonitor": 0.295, "TestMonitorTensorboard": 0.20000000000000004}, "test_multiprocessing": {"TestMultiprocessing": 45.800000000000004}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.40599999999999997, "SpawnTest": 24.897333333333336}, "test_namedtensor": {"TestNamedTensor": 0.49733333333333346}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.8763333333333332}, "test_native_functions": {"TestNativeFunctions": 0.4283333333333334}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.2163333333333334}, "test_nestedtensor": {"TestNestedTensor": 0.2190000000000001, "TestNestedTensorAutogradCPU": 1.0773333333333333, "TestNestedTensorDeviceTypeCPU": 1.040666666666665, "TestNestedTensorSubclassCPU": 21.52333333333335}, "test_nn": {"TestAddRelu": 0.004, "TestConstantPadNd": 0.0036666666666666666, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.31833333333333336, "TestFusionUtils": 0.004, "TestNN": 34.46866666666662, "TestNNDeviceTypeCPU": 115.46433333333368, "TestUtils": 0.0030000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.005666666666666667}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.24100000000000008}, "test_openmp": {"TestOpenMP_ParallelFor": 8.751}, "test_ops": {"TestCommonCPU": 1530.7676666666314, "TestCompositeComplianceCPU": 887.1949999999943, "TestFakeTensorCPU": 320.3646666666679, "TestMathBitsCPU": 56.71966666666672, "TestRefsOpsInfoCPU": 1.5603333333333336, "TestSelfKwarg": 0.023000000000000003, "TestTagsCPU": 13.677666666666646}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 811.0239999999876}, "test_ops_gradients": {"TestBwdGradientsCPU": 1302.9629999999459}, "test_ops_jit": {"TestJitCPU": 1057.478666666664}, "test_optim": {"TestDifferentiableOptimizer": 0.243, "TestLRScheduler": 1.1746666666666663, "TestOptim": 66.275, "TestOptimRenewedCPU": 53.862666666666776, "TestSWAUtils": 0.2693333333333333}, "test_out_dtype_op": {"TestOutDtypeOp": 0.4033333333333333}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.002, "TestDisabledUserWarnings": 0.002, "TestEinsumOverride": 0.0033333333333333335, "TestGradCheckOverride": 0.02, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.008, "TestIterator": 0.0013333333333333333, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.0030000000000000005, "TestResolveName": 0.08966666666666667, "TestTorchFunctionMode": 0.0003333333333333333, "TestTorchFunctionOverride": 1.7576666666665872, "TestTorchFunctionWarning": 0.012333333333333335, "TestWrapTorchFunction": 0.0016666666666666668}, "test_package": {"DirectoryReaderTest": 0.04633333333333334, "ModelTest": 0.002, "TestAnalyze": 0.26366666666666666, "TestDependencyAPI": 0.09033333333333333, "TestDependencyHooks": 0.018666666666666668, "TestDiGraph": 0.023333333333333334, "TestGlobGroup": 0.02933333333333334, "TestImporter": 0.014, "TestLoadBCPackages": 0.07966666666666666, "TestMangling": 0.022000000000000002, "TestMisc": 0.08533333333333333, "TestPackageFX": 0.07233333333333332, "TestPackageScript": 2.020333333333333, "TestRepackage": 0.008666666666666666, "TestResources": 0.011333333333333334, "TestSaveLoad": 0.034}, "test_per_overload_api": {"TestPerOverloadAPI": 0.299}, "test_prims": {"TestDecompCPU": 0.08933333333333333, "TestPrimsBasic": 0.022999999999999996, "TestPrimsCPU": 0.12266666666666669, "TestRefsCPU": 0.012666666666666668}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.158, "TestGenericProxyTensorFake": 1.9893333333333334, "TestGenericProxyTensorReal": 2.4066666666666663, "TestGenericProxyTensorSymbolic": 19.074333333333335, "TestProxyTensorOpInfoCPU": 733.4843333333333, "TestRealProxyTensor": 0.018, "TestSymbolicTracing": 3.497333333333333}, "test_pruning_op": {"PruningOpTest": 0.602}, "test_public_bindings": {"TestPublicBindings": 6.581333333333333}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.017666666666666667, "TestPythonDispatch": 0.21566666666666676, "TestPythonDispatcher": 0.006000000000000001, "TestPythonRegistration": 0.309, "TestWrapperSubclassAliasingCPU": 0.09566666666666669}, "test_pytree": {"TestCxxPytree": 0.016666666666666673, "TestGenericPytree": 0.4673333333333334, "TestPythonPytree": 0.09200000000000004}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.017333333333333336, "TestAOMigrationNNQuantized": 0.06600000000000002, "TestAOMigrationQuantization": 0.021666666666666667, "TestAOMigrationQuantizationFx": 0.026666666666666672, "TestBackendConfig": 0.05766666666666668, "TestBiasCorrectionEager": 2.1803333333333335, "TestBits": 0.005, "TestBitsCPU": 0.06266666666666668, "TestComparatorOps": 2.0473333333333334, "TestDeprecatedJitQuantized": 4.571333333333333, "TestDistributed": 0.036, "TestDuplicateDQPass": 3.615, "TestDynamicQuantizedModule": 60.39366666666666, "TestDynamicQuantizedOps": 31.327333333333332, "TestEqualizeEager": 0.3036666666666667, "TestEqualizeFx": 6.433, "TestFXGraphMatcher": 1.9086666666666667, "TestFXGraphMatcherModels": 9.89, "TestFXNumericSuiteCoreAPIs": 32.873, "TestFXNumericSuiteCoreAPIsModels": 40.99966666666666, "TestFXNumericSuiteNShadows": 48.047666666666665, "TestFakeQuantize": 0.527, "TestFakeQuantizeOps": 2.7836666666666665, "TestFloat8DtypeCPU": 0.1296666666666667, "TestFloat8DtypeCPUOnlyCPU": 0.669, "TestFuseEager": 4.372333333333333, "TestFuseFx": 2.407666666666666, "TestFusedObsFakeQuant": 0.166, "TestFusedObsFakeQuantModule": 0.3163333333333334, "TestFusionPasses": 0.033, "TestFxDetectInputWeightEqualization": 0.2783333333333334, "TestFxDetectOutliers": 0.4779999999999999, "TestFxModelReportClass": 0.8570000000000001, "TestFxModelReportDetectDynamicStatic": 0.083, "TestFxModelReportDetector": 0.30233333333333334, "TestFxModelReportObserver": 0.31833333333333336, "TestFxModelReportVisualizer": 0.304, "TestGenerateNumericDebugHandle": 0.992, "TestGraphUtils": 1.6506666666666667, "TestHistogramObserver": 51.95466666666666, "TestMetaDataPorting": 9.222333333333333, "TestModelNumericsEager": 1.2856666666666665, "TestNumericSuiteEager": 14.374666666666664, "TestObserver": 5.0216666666666665, "TestPT2ERepresentation": 30.463666666666665, "TestPadding": 20.329333333333334, "TestQNNPackOps": 6.616333333333333, "TestQuantizationDocs": 0.005333333333333333, "TestQuantizeDynamicJitOps": 3.033333333333333, "TestQuantizeDynamicJitPasses": 5.847666666666666, "TestQuantizeEagerOps": 2.5803333333333334, "TestQuantizeEagerPTQDynamic": 10.200333333333333, "TestQuantizeEagerPTQStatic": 37.823, "TestQuantizeEagerQAT": 14.062333333333333, "TestQuantizeEagerQATNumerics": 2.7399999999999998, "TestQuantizeFx": 50.349999999999994, "TestQuantizeFxModels": 8.834333333333332, "TestQuantizeFxOps": 159.11500000000004, "TestQuantizeJit": 25.35066666666667, "TestQuantizeJitOps": 257.885, "TestQuantizeJitPasses": 6.674333333333332, "TestQuantizePT2E": 53.212333333333326, "TestQuantizePT2EQAT": 39.601, "TestQuantizePT2EQATModels": 26.363999999999994, "TestQuantizePT2EQAT_ConvBn1d": 300.06100000000004, "TestQuantizePT2EQAT_ConvBn2d": 303.32599999999996, "TestQuantizePT2EX86Inductor": 125.92999999999999, "TestQuantizedConv": 72.631, "TestQuantizedEmbeddingOps": 1.5093333333333334, "TestQuantizedFunctionalOps": 3.281, "TestQuantizedLinear": 26.26433333333333, "TestQuantizedOps": 158.18899999999996, "TestQuantizedTensor": 3.6453333333333315, "TestRecordHistogramObserver": 0.054, "TestReferenceQuantizedModule": 0.07233333333333335, "TestSerialization": 2.4273333333333333, "TestStaticQuantizedModule": 149.38133333333334, "TestSubgraphRewriter": 1.3466666666666667, "TestUtils": 0.029666666666666664, "TestXNNPACKQuantizer": 53.032999999999994, "TestXNNPACKQuantizerModels": 2.876}, "test_reductions": {"TestReductionsCPU": 199.60033333333345}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 5.716333333333332}, "test_schema_check": {"TestSchemaCheck": 0.16900000000000007, "TestSchemaCheckModeOpInfoCPU": 205.9949999999977}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.509333333333333}, "test_serialization": {"TestBothSerializationCPU": 0.28600000000000003, "TestOldSerialization": 27.352666666666668, "TestSerialization": 8.724333333333332, "TestSubclassSerialization": 0.05000000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.31566666666666665}, "test_shape_ops": {"TestShapeOpsCPU": 1.378666666666666}, "test_show_pickle": {"TestShowPickle": 0.26033333333333336}, "test_sort_and_select": {"TestSortAndSelectCPU": 2.3149999999999977}, "test_sparse": {"TestSparseAnyCPU": 414.26299999999924, "TestSparseCPU": 534.1769999999998, "TestSparseLegacyAndDeprecation": 0.08566666666666667, "TestSparseMaskedReductionsCPU": 1.6940000000000002, "TestSparseMeta": 4.571999999999999, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 7.8099999999999525}, "test_sparse_csr": {"TestSparseCSRCPU": 95.17199999999995, "TestSparseCSRSampler": 0.6960000000000001, "TestSparseCompressedCPU": 118.368333333333, "TestSparseCompressedTritonKernelsCPU": 0.0033333333333333335}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 6.580333333333321, "TestFFTDocExamplesCPU": 0.06500000000000003}, "test_stateless": {"TestPythonOptimizeMode": 4.458333333333333, "TestStatelessDeprecation": 1.957, "TestStatelessFunctionalAPI": 0.3216666666666667}, "test_subclass": {"TestSubclass": 0.43400000000000016}, "test_sympy_utils": {"TestNumbers": 0.044000000000000004, "TestSingletonInt": 0.006666666666666667, "TestSympyInterp": 10.855333333333334, "TestSympySolve": 0.2276666666666667, "TestValueRanges": 5.688666666666666}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.6083333333333337, "TestBufferProtocolCPU": 0.4093333333333336, "TestLikeTensorCreationCPU": 0.009666666666666669, "TestRandomTensorCreationCPU": 2.803333333333333, "TestTensorCreationCPU": 25.68399999999998}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.005666666666666667, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.0033333333333333335, "TestTensorBoardPyTorchNumpy": 0.20633333333333337, "TestTensorBoardPytorchGraph": 0.019, "TestTensorBoardSummary": 0.04300000000000001, "TestTensorBoardSummaryWriter": 0.007666666666666666, "TestTensorBoardUtils": 0.007333333333333333, "TestTensorBoardWriter": 0.0016666666666666668, "TestTensorProtoSummary": 0.017333333333333333}, "test_tensorexpr": {"TestTensorExprFuser": 46.70666666666665}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.008, "TestTensorExprPyBind": 0.8506666666666668}, "test_testing": {"TestAssertClose": 0.12533333333333338, "TestAssertCloseContainer": 0.007333333333333333, "TestAssertCloseErrorMessage": 0.07600000000000001, "TestAssertCloseQuantized": 0.016666666666666666, "TestAssertCloseSparseBSC": 0.028666666666666663, "TestAssertCloseSparseBSR": 0.027999999999999997, "TestAssertCloseSparseCOO": 0.03133333333333333, "TestAssertCloseSparseCSC": 0.02766666666666667, "TestAssertCloseSparseCSR": 0.026333333333333334, "TestFrameworkUtils": 11.727333333333334, "TestImports": 11.464666666666668, "TestMakeTensorCPU": 1.1506666666666676, "TestOpInfoSampleFunctionsCPU": 4.368666666666649, "TestOpInfos": 0.005333333333333333, "TestTestParametrization": 0.029666666666666678, "TestTestParametrizationDeviceTypeCPU": 3.3256666666666646, "TestTestingCPU": 0.19866666666666669}, "test_torch": {"TestBasicVitalSigns": 0.02866666666666667, "TestTorch": 3.809333333333324, "TestTorchDeviceTypeCPU": 16.62700000000001, "TestVitalSignsCudaCPU": 0.0016666666666666668}, "test_transformers": {"TestAttnBiasCPU": 21.017999999999997, "TestAttnMasksCPU": 18.500666666666664, "TestSDPACPU": 282.43999999999943, "TestSDPAFailureModesCPU": 0.032666666666666684, "TestTransformersCPU": 7.015333333333333}, "test_type_hints": {"TestTypeHints": 0.4246666666666667}, "test_type_info": {"TestDTypeInfo": 0.38233333333333336}, "test_type_promotion": {"TestTypePromotionCPU": 3.5350000000000006}, "test_typing": {"TestTyping": 80.81933333333335}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 452.54233333322594}, "test_utils": {"TestAssert": 0.053, "TestBottleneck": 8.003, "TestCheckpoint": 0.08566666666666667, "TestCollectEnv": 0.9943333333333332, "TestCppExtensionUtils": 0.14266666666666666, "TestDataLoaderUtils": 0.25166666666666665, "TestDeviceUtilsCPU": 26.604000000000593, "TestExtensionUtils": 0.004666666666666667, "TestHipify": 0.0013333333333333333, "TestHipifyTrie": 0.007, "TestONNXUtils": 0.004666666666666667, "TestRenderUtils": 0.013333333333333334, "TestStandaloneCPPJIT": 1.6623333333333334, "TestTraceback": 0.011000000000000001}, "test_view_ops": {"TestOldViewOpsCPU": 20.511666666666674, "TestViewOpsCPU": 0.9553333333333334, "TestViewOpsLAZY": 1.1676666666666657}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.02866666666666667, "WeakKeyDictionaryTestCase": 0.03233333333333334, "WeakTest": 4.9046666666666665}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 33.127, "TestXNNPACKOps": 4.883, "TestXNNPACKRewritePass": 1.7626666666666668, "TestXNNPACKSerDes": 5.249}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.004}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.3966666666666667, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0013333333333333333, "TestFromDTypeAttribute": 0.0023333333333333335, "TestMisc": 0.005, "TestPickling": 0.16100000000000003, "TestPromotion": 0.004}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 15.06866666666667, "TestEinsumPath": 0.002, "TestMisc": 0.007}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.002, "TestHalf": 0.0003333333333333333, "TestIinfo": 0.2933333333333334, "TestMisc": 0.004333333333333334, "TestPythonFloat": 0.001, "TestRepr": 0.0026666666666666666, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.005999999999999999, "TestBooleanIndexing": 0.013666666666666667, "TestBroadcastedAssignments": 0.024333333333333332, "TestFancyIndexingCast": 0.006333333333333333, "TestFloatNonIntegerArgument": 0.019333333333333338, "TestIndexing": 0.4926666666666668, "TestMultiIndexingAutomated": 0.015, "TestMultipleEllipsisError": 0.0026666666666666666, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.03566666666666667, "TestArgmax": 1.2766666666666673, "TestArgmaxArgminCommon": 0.17833333333333345, "TestArgmin": 1.3156666666666668, "TestArrayAttributeDeletion": 0.009, "TestArrayConstruction": 0.03933333333333334, "TestArrayCreationCopyArgument": 0.006666666666666668, "TestArrayInterface": 0.031666666666666655, "TestAssignment": 0.010000000000000002, "TestAttributes": 0.02366666666666667, "TestBinop": 0.019333333333333334, "TestBool": 28.603333333333335, "TestCequenceMethods": 0.0023333333333333335, "TestChoose": 0.026333333333333337, "TestClip": 0.008, "TestCompress": 0.006666666666666667, "TestConversion": 0.04766666666666667, "TestCreation": 0.00933333333333334, "TestDelMisc": 0.002, "TestDot": 0.1066666666666667, "TestDtypedescr": 0.0013333333333333333, "TestFancyIndexing": 0.03366666666666667, "TestFlag": 0.014000000000000004, "TestFormat": 0.006333333333333333, "TestFromBuffer": 0.02566666666666667, "TestHash": 0.22133333333333335, "TestHashing": 0.004, "TestIO": 0.011000000000000003, "TestInner": 0.261, "TestLexsort": 0.03400000000000001, "TestMatmul": 0.6830000000000002, "TestMatmulOperator": 0.39233333333333337, "TestMethods": 1.7399999999999995, "TestMinMax": 0.006000000000000001, "TestMinScalarType": 0.012333333333333335, "TestNewaxis": 0.004666666666666667, "TestPEP3118Dtype": 0.0013333333333333333, "TestPutmask": 0.02, "TestRepeat": 0.034333333333333334, "TestResize": 0.06500000000000002, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.019333333333333338, "TestSizeOf": 0.011333333333333334, "TestSortFloatMisc": 0.18466666666666667, "TestStats": 0.317, "TestSubscripting": 0.002, "TestTake": 0.056000000000000015, "TestVdot": 0.04133333333333334, "TestViewDtype": 0.009000000000000001, "TestWarnings": 0.0023333333333333335, "TestWhere": 0.4523333333333334, "TestWritebackIfCopy": 0.03666666666666667}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.019000000000000003, "TestArgwhere": 0.030666666666666665, "TestArrayComparisons": 0.013999999999999999, "TestBaseRepr": 0.008333333333333333, "TestBinaryRepr": 0.011000000000000001, "TestBoolArray": 2.8973333333333335, "TestBoolCmp": 0.19933333333333333, "TestBoolScalar": 0.01, "TestBroadcast": 0.008666666666666668, "TestClip": 0.2160000000000001, "TestConvolve": 0.024666666666666667, "TestCorrelate": 0.04533333333333334, "TestCreationFuncs": 1.0113333333333332, "TestCross": 0.06566666666666666, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.011666666666666667, "TestFromiter": 0.0013333333333333333, "TestIndex": 0.007666666666666666, "TestIndices": 0.04800000000000001, "TestIsclose": 0.07966666666666668, "TestIsscalar": 0.0023333333333333335, "TestLikeFuncs": 0.002, "TestMoveaxis": 0.009666666666666669, "TestNonarrayArgs": 0.1123333333333334, "TestNonzeroAndCountNonzero": 0.311, "TestOuterMisc": 0.005, "TestRequire": 0.008, "TestResize": 0.295, "TestRoll": 0.033, "TestRollaxis": 0.004666666666666667, "TestSeterr": 0.009333333333333334, "TestStdVar": 0.03, "TestStdVarComplex": 0.012333333333333335, "TestStringFunction": 0.002, "TestTensordot": 0.018000000000000002, "TestTypes": 0.01933333333333333}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0016666666666666668, "TestCommonType": 0.37566666666666665, "TestDocStrings": 0.0, "TestIsSubDType": 0.008333333333333333, "TestScalarTypeNames": 0.027666666666666683}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.08633333333333339, "TestFromInt": 0.007, "TestFromString": 0.3193333333333333}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.008666666666666668, "TestBitCount": 0.0016666666666666668, "TestClassGetItem": 0.004000000000000001, "TestClassGetitemMisc": 0.35200000000000004, "TestIsInteger": 0.010666666666666666}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0013333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.11966666666666666, "TestBaseMath": 9.197000000000001, "TestBitShifts": 0.10933333333333334, "TestComplexDivision": 0.07100000000000001, "TestConversion": 0.06566666666666666, "TestHash": 0.0006666666666666666, "TestModulus": 1.16, "TestMultiply": 0.0006666666666666666, "TestNegative": 0.022000000000000002, "TestPower": 0.12033333333333333, "TestRepr": 0.0016666666666666668, "TestScalarOpsMisc": 0.0646666666666667, "TestScalarSubclassingMisc": 0.04266666666666669, "TestSubtract": 0.021, "TestTypes": 15.419666666666666}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.3666666666666667, "TestAtleast2d": 0.025000000000000005, "TestAtleast3d": 0.02, "TestBlock": 0.03500000000000001, "TestConcatenate": 0.20333333333333345, "TestHstack": 0.02566666666666666, "TestStackMisc": 0.010000000000000004, "TestVstack": 0.028999999999999998}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.009333333333333332, "TestFFTShift": 5.872, "TestIRFFTN": 0.005666666666666667, "TestRFFTFreq": 0.009333333333333332}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.613333333333332, "TestFFTShift": 0.3196666666666667, "TestFFTThreadSafe": 1.668}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.39799999999999996}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.015000000000000001, "TestUnique": 0.5813333333333334}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.006666666666666667, "TestAmin": 0.006666666666666667, "TestAngle": 0.009333333333333334, "TestAny": 0.008666666666666668, "TestAverage": 0.036333333333333336, "TestBincount": 0.04966666666666667, "TestCheckFinite": 0.0026666666666666666, "TestCopy": 0.01, "TestCorrCoef": 0.036333333333333336, "TestCov": 0.06533333333333334, "TestCumprod": 0.036000000000000004, "TestCumsum": 0.04533333333333334, "TestDelete": 0.020000000000000004, "TestDiff": 0.09033333333333333, "TestDigitize": 0.019, "TestExtins": 0.005999999999999999, "TestFilterwindows": 0.7130000000000005, "TestFlip": 0.039666666666666676, "TestGradient": 0.17900000000000002, "TestInsert": 0.009666666666666667, "TestInterp": 0.0636666666666667, "TestKaiser": 0.011000000000000001, "TestMedian": 0.11066666666666669, "TestMeshgrid": 0.05666666666666668, "TestMsort": 0.0003333333333333333, "TestPercentile": 0.16400000000000012, "TestPiecewise": 0.011333333333333334, "TestProd": 0.03466666666666667, "TestPtp": 0.01, "TestQuantile": 0.025000000000000005, "TestRot90": 0.357, "TestSelect": 0.009, "TestSinc": 0.009, "TestSortComplex": 0.011333333333333334, "TestTrapz": 0.006000000000000001, "TestTrimZeros": 0.012000000000000002, "TestUnique": 0.004333333333333334, "Test_I0": 0.014666666666666666}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4043333333333335, "TestHistogramOptimBinNums": 0.03666666666666668, "TestHistogramdd": 0.17233333333333337}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.002, "TestConcatenator": 0.006999999999999999, "TestDiagIndices": 0.004666666666666667, "TestDiagIndicesFrom": 0.007333333333333333, "TestFillDiagonal": 0.023333333333333334, "TestGrid": 0.011000000000000001, "TestIndexExpression": 0.01, "TestIx_": 0.006333333333333334, "TestNdIndex": 0.001, "TestNdenumerate": 0.0016666666666666668, "TestRavelUnravelIndex": 0.31133333333333335}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.01966666666666667, "TestApplyOverAxes": 0.0023333333333333335, "TestArraySplit": 0.2086666666666667, "TestColumnStack": 0.012333333333333335, "TestDsplit": 0.014333333333333332, "TestDstack": 0.021, "TestExpandDims": 0.009333333333333334, "TestHsplit": 0.016666666666666666, "TestKron": 0.03400000000000001, "TestMayShareMemory": 0.0023333333333333335, "TestPutAlongAxis": 0.013666666666666666, "TestSplit": 0.008666666666666666, "TestSqueeze": 0.05166666666666667, "TestTakeAlongAxis": 0.3826666666666667, "TestTile": 0.12466666666666666, "TestVsplit": 0.011000000000000001}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.03333333333333333, "TestEye": 0.34466666666666673, "TestFliplr": 0.006000000000000001, "TestFlipud": 0.005666666666666667, "TestHistogram2d": 0.041, "TestTri": 0.09566666666666668, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.0030000000000000005, "TestTriuIndicesFrom": 0.002, "TestVander": 0.01933333333333333}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.002, "TestCommonType": 0.279, "TestImag": 0.014333333333333332, "TestIscomplex": 0.006000000000000001, "TestIscomplexobj": 0.006000000000000001, "TestIsfinite": 0.015, "TestIsinf": 0.012666666666666666, "TestIsnan": 0.015333333333333332, "TestIsneginf": 0.0026666666666666666, "TestIsposinf": 0.0026666666666666666, "TestIsreal": 0.009666666666666667, "TestIsrealobj": 0.002, "TestIsscalar": 0.0023333333333333335, "TestMintypecode": 0.005333333333333333, "TestNanToNum": 0.020333333333333335, "TestReal": 0.015666666666666666, "TestRealIfClose": 0.004666666666666667}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.19166666666666668, "TestCond": 0.2720000000000001, "TestDet": 0.20400000000000004, "TestEig": 0.05433333333333334, "TestEigh": 0.026333333333333344, "TestEighCases": 0.0, "TestEigvals": 0.07, "TestEigvalsh": 0.024666666666666674, "TestEigvalshCases": 0.0, "TestInv": 0.068, "TestLstsq": 0.215, "TestMatrixRank": 0.456, "TestMisc": 0.04466666666666667, "TestMisc2": 0.005, "TestMultiDot": 0.08666666666666667, "TestNormDouble": 0.8853333333333335, "TestNormInt64": 0.9333333333333332, "TestNormSingle": 0.9739999999999999, "TestNorm_NonSystematic": 0.0036666666666666666, "TestPinv": 0.13333333333333333, "TestPinvHermitian": 0.042666666666666665, "TestQR": 0.6863333333333334, "TestSVD": 0.08300000000000002, "TestSVDHermitian": 0.17133333333333334, "TestSolve": 0.42733333333333334, "TestTensorinv": 0.043333333333333335, "TestTensorsolve": 0.007666666666666666}, "torch_np/test_basic": {"TestArrayToSequence": 0.006999999999999999, "TestCopyTo": 0.008333333333333333, "TestCtorNested": 0.004666666666666667, "TestDefaultDtype": 0.010333333333333333, "TestDivmod": 0.021333333333333333, "TestExport": 0.0006666666666666666, "TestMisc": 0.0030000000000000005, "TestNormalizations": 0.006666666666666667, "TestOneArr": 0.33800000000000024, "TestOneArrAndAxesTuple": 0.010000000000000002, "TestOneArrAndAxis": 0.18600000000000014, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.011666666666666667, "TestPythonArgsToArray": 0.012333333333333335, "TestSequenceOfArrays": 0.017666666666666674, "TestSequenceOfArraysToSingle": 0.010333333333333333, "TestShapeLikeToArray": 0.004333333333333334, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.45133333333333353}, "torch_np/test_dtype": {"TestConvertDType": 0.31200000000000006}, "torch_np/test_function_base": {"TestAppend": 0.2876666666666667}, "torch_np/test_ndarray_methods": {"TestAmax": 0.008, "TestAmin": 0.008, "TestArgmax": 1.1653333333333333, "TestArgmaxArgminCommon": 0.12566666666666673, "TestArgmin": 1.2676666666666663, "TestContains": 0.0023333333333333335, "TestIndexing": 0.3453333333333333, "TestIter": 0.005, "TestNoExtraMethods": 0.008666666666666668, "TestNonzero": 0.17533333333333334, "TestRavel": 0.008333333333333333, "TestReshape": 0.006000000000000001, "TestTranspose": 0.011999999999999999}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.30033333333333356, "TestNEP50Table": 0.009333333333333338}, "torch_np/test_random": {"TestChoice": 0.011666666666666667, "TestNumpyGlobal": 0.005, "TestScalarReturn": 0.3046666666666667, "TestShuffle": 0.011000000000000003}, "torch_np/test_reductions": {"TestAll": 0.015666666666666666, "TestAny": 0.015666666666666666, "TestFlatnonzero": 0.24633333333333338, "TestGenericCumSumProd": 0.022000000000000002, "TestGenericReductions": 2.712666666666611, "TestMean": 0.03166666666666667, "TestSum": 0.2833333333333334}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.3016666666666667, "TestIsScalar": 0.02933333333333335}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.7150000000000004, "TestNdarrayDunderVsUfunc": 0.2216666666666668, "TestUfuncDtypeKwd": 0.010666666666666666, "TestUnaryUfuncs": 0.3333333333333333}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.46366666666666684}}, "default": {"backends/xeon/test_launch": {"TestTorchrun": 1.7353333333333332}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.5496666666666663}, "distributions/test_constraints": {"test_constraints": 0.07200000000000005}, "distributions/test_distributions": {"TestAgainstScipy": 1.1416666666666666, "TestConstraints": 0.13466666666666668, "TestDistributionShapes": 0.14766666666666675, "TestDistributions": 35.34066666666667, "TestFunctors": 0.012000000000000002, "TestJit": 19.323999999999998, "TestKL": 2.7593333333333327, "TestLazyLogitsInitialization": 0.012666666666666668, "TestNumericalStability": 0.07566666666666667, "TestRsample": 0.6709999999999999, "TestValidation": 0.32733333333333337}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.5976666666666667}, "dynamo/test_after_aot": {"TestAfterAot": 6.098333333333334}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.7776666666666667}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 12.211333333333336}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.26166666666666666, "AOTAutogradCacheTests": 17.776666666666667}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.946999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.035, "TestCustomBackendAPI": 1.7296666666666667, "TestExplainWithBackend": 10.76633333333333, "TestOptimizations": 2.254333333333333}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 13.220666666666666}, "dynamo/test_base_output": {"TestBaseOutput": 0.0033333333333333335}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.100666666666666}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 6.401666666666666, "BytecodeTests": 0.44133333333333336}, "dynamo/test_compile": {"InPlaceCompilationTests": 7.516666666666666, "PublicTorchCompilerTests": 0.0033333333333333335}, "dynamo/test_comptime": {"ComptimeTests": 0.6893333333333334}, "dynamo/test_config": {"ConfigTests": 0.543}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.405, "CppGuardManagerFuncTorchHigherOrderOpTests": 11.417666666666674, "CppGuardManagerFunctionTests": 24.60600000000001, "CppGuardManagerHigherOrderOpTests": 7.515666666666668, "CppGuardManagerMiscTests": 54.965333333333376, "CppGuardManagerReproTests": 36.06833333333332}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.3533333333333335}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.303}, "dynamo/test_decorators": {"DecoratorTests": 6.862333333333332}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0003333333333333333, "TestDeviceGuard": 0.016333333333333335}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 245.06900000000005, "DynamicShapesCtxManagerTests": 5.439666666666667, "DynamicShapesExportTests": 33.712333333333326, "DynamicShapesFuncTorchHigherOrderOpTests": 96.18833333333332, "DynamicShapesFunctionTests": 81.54033333333335, "DynamicShapesHigherOrderOpTests": 18.384666666666664, "DynamicShapesMiscTests": 100.30100000000014, "DynamicShapesNNModuleTests": 6.480333333333333, "DynamicShapesReproTests": 116.603, "DynamicShapesSubGraphTests": 13.437666666666667, "DynamicShapesTestSDPA": 0.37166666666666665}, "dynamo/test_exc": {"ExcTests": 1.9526666666666666}, "dynamo/test_exceptions": {"ExceptionTests": 0.5843333333333335}, "dynamo/test_export": {"ExportTests": 17.234333333333325}, "dynamo/test_export_mutations": {"MutationExportTests": 0.5406666666666667}, "dynamo/test_frame_init": {"FrameInitTests": 0.2876666666666667}, "dynamo/test_functions": {"DefaultsTests": 0.7603333333333334, "FunctionTests": 17.52066666666666}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.7776666666666667}, "dynamo/test_global": {"TestGlobals": 0.5026666666666667}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.3056666666666667}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.262, "FuncTorchHigherOrderOpTests": 12.392000000000005, "HigherOrderOpTests": 9.363, "HigherOrderOpVmapGuardTests": 4.413333333333333}, "dynamo/test_hooks": {"HooksTests": 27.215333333333337}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 8.76, "InlineInbuiltNNModulesExportTests": 19.169, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 10.622, "InlineInbuiltNNModulesFunctionTests": 22.42166666666669, "InlineInbuiltNNModulesHigherOrderOpTests": 7.628666666666667, "InlineInbuiltNNModulesMiscTests": 58.186666666666746, "InlineInbuiltNNModulesNNModuleTests": 4.333999999999999}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 8.994666666666667}, "dynamo/test_interop": {"InteropTests": 0.535}, "dynamo/test_logging": {"LoggingTests": 19.515000000000004}, "dynamo/test_minifier": {"MinifierTests": 1.3549999999999998}, "dynamo/test_misc": {"MiscTests": 61.10600000000003, "TestTracer": 0.05333333333333334}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0036666666666666666}, "dynamo/test_modules": {"NNModuleTests": 3.1429999999999976, "OptimizedModuleTest": 19.090666666666664}, "dynamo/test_nops": {"NopTests": 0.393}, "dynamo/test_optimizers": {"End2EndTests": 0.635, "OptimizerTests": 1.6300000000000001}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.5173333333333333}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.2913333333333334}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.7406666666666667}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.9433333333333334}, "dynamo/test_recompiles": {"RecompileTests": 0.8380000000000001}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.49633333333333335}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.8876666666666667}, "dynamo/test_repros": {"ReproTests": 54.603333333333374}, "dynamo/test_resume": {"ResumeFunctionTests": 0.39233333333333337}, "dynamo/test_sdpa": {"TestSDPA": 0.4746666666666666}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.6510000000000001}, "dynamo/test_sources": {"SourceTests": 0.47533333333333333}, "dynamo/test_structured_trace": {"StructuredTraceTest": 19.064333333333334}, "dynamo/test_subclasses": {"SubclassTests": 4.517333333333332, "TestNestedTensor": 11.282333333333334}, "dynamo/test_subgraphs": {"SubGraphTests": 2.2016666666666658}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.103, "TraceRuleTests": 1.2776666666666665}, "dynamo/test_triton_kernels": {"KernelTests": 0.054333333333333365, "MutationTests": 0.006000000000000001, "NoOptimizationKernelTests": 0.014666666666666673, "no_opt_test_class": 0.05200000000000004}, "dynamo/test_unspec": {"UnspecTests": 17.191333333333336}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.544}, "dynamo/test_view": {"ViewTests": 0.6013333333333333}, "export/test_converter": {"TestConverter": 7.1209999999999996}, "export/test_db": {"ExampleTests": 3.0843333333333334}, "export/test_experimental": {"TestExperiment": 1.0823333333333334}, "export/test_export": {"TestDynamismExpression": 0.566, "TestExport": 30.770000000000007, "TestExportCustomClass": 0.10666666666666667, "TestOneOffModelExportResult": 1.3066666666666669}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.4366666666666667, "NonStrictExportTestExport": 27.368333333333325}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.47300000000000003, "PreDispatchExportTestExport": 29.02133333333334}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.29533333333333334}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.7006666666666668}, "export/test_hop": {"TestHOPCPU": 2.733333333333333, "TestHOPGeneric": 0.0030000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.17233333333333334, "TestLiftUnlift": 0.011000000000000001}, "export/test_pass_infra": {"TestPassInfra": 0.891}, "export/test_passes": {"TestPasses": 12.863666666666665}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.882, "RetraceExportTestExport": 42.458999999999996}, "export/test_safeguard": {"TestSafeguard": 0.9183333333333334}, "export/test_schema": {"TestSchema": 0.32899999999999996}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.22499999999999998, "SerDesExportPreDispatchTestExport": 23.711749999999995, "SerDesExportTestDynamismExpression": 0.5306666666666667, "SerDesExportTestExport": 30.638999999999996}, "export/test_serialize": {"TestDeserialize": 7.335, "TestOpVersioning": 0.006, "TestSaveLoad": 0.2873333333333334, "TestSchemaVersioning": 0.03, "TestSerialize": 1.2283333333333335, "TestSerializeCustomClass": 0.08600000000000001}, "export/test_sparse": {"TestSparseProp": 80.42066666666665}, "export/test_tools": {"TestExportTools": 0.6196666666666667}, "export/test_torchbind": {"TestCompileTorchbind": 1.3063333333333336, "TestExportTorchbind": 1.8439999999999994, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.26133333333333336}, "export/test_unflatten": {"TestUnflatten": 3.102}, "export/test_upgrade": {"TestUpgrade": 0.497}, "export/test_verifier": {"TestVerifier": 1.0493333333333332}, "functorch/test_aotdispatch": {"TestAOTAutograd": 14.359333333333332, "TestAOTAutogradWithDynamo": 17.621, "TestAOTDispatch": 0.5193333333333333, "TestAOTExport": 2.3066666666666666, "TestAOTModuleSimplified": 0.6166666666666667, "TestEagerFusionModuleInfoCPU": 928.0633333333332, "TestEagerFusionOpInfoCPU": 2276.3299999999967, "TestPartitioning": 1.127, "TestPythonKeyCPU": 1.3419999999999999}, "functorch/test_control_flow": {"TestControlFlow": 0.6990000000000002, "TestControlFlowTraced": 103.94466666666665}, "functorch/test_dims": {"TestMin": 18.256666666666664, "TestMinFunctorchOnly": 16.423333333333332}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.11466666666666674, "TestAutogradFunctionVmapAPICPU": 0.021333333333333333, "TestCompileTransformsCPU": 9.489333333333333, "TestComposabilityCPU": 1.6809999999999994, "TestExamplesCorrectnessCPU": 4.827999999999999, "TestFunctionalizeCPU": 0.14200000000000002, "TestGradTransformCPU": 0.553, "TestHelpersCPU": 0.009666666666666667, "TestHessianCPU": 0.037, "TestHigherOrderOperatorInteractionCPU": 0.03766666666666667, "TestJacCPU": 0.5650000000000003, "TestJvpCPU": 0.060666666666666695, "TestLinearizeCPU": 0.229, "TestMakeFunctional": 0.09700000000000003, "TestSliceArgnums": 0.01566666666666667, "TestVmapJvpInplaceViewCPU": 0.014666666666666666, "TestVmapOfGradCPU": 0.3486666666666667}, "functorch/test_logging": {"TestAOTLogging": 0.298}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.4343333333333334, "RandomOpTestCase": 0.078, "ReduceTestCase": 0.07733333333333332, "TestMemoryEfficientOpAuthoring": 0.0003333333333333333}, "functorch/test_minifier": {"TestMinifier": 0.45999999999999996}, "functorch/test_ops": {"TestOperatorsCPU": 3275.5813333333226}, "functorch/test_parsing": {"TestAnonymousAxis": 0.2846666666666667, "TestParsedExpression": 0.006333333333333334, "TestParsingUtils": 0.005333333333333333, "TestValidateRearrangeExpressions": 0.005333333333333333}, "functorch/test_rearrange": {"TestRearrange": 0.3176666666666667}, "functorch/test_vmap": {"TestRandomnessCPU": 1.2569999999999995, "TestTransformFailureCPU": 0.09033333333333333, "TestVmapAPI": 0.34300000000000014, "TestVmapBatchedGradientCPU": 0.17133333333333342, "TestVmapDeviceTypeCPU": 0.023000000000000003, "TestVmapNestedTensorCPU": 0.05400000000000001, "TestVmapOperators": 3.8119999999999954, "TestVmapOperatorsOpInfoCPU": 558.5713333333312}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.735666666666503}, "higher_order_ops/test_with_effects": {"TestWithEffects": 8.615333333333334}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 8.626666666666665}, "inductor/test_binary_folding": {"FreezingCpuTests": 39.35333333333333}, "inductor/test_codecache": {"TestFxGraphCache": 38.78399999999999, "TestFxGraphCacheHashing": 0.8180000000000001, "TestUtils": 3.72, "test_codecache": 0.001}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.26533333333333337}, "inductor/test_compile_worker": {"TestCompileWorker": 13.333333333333334}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 233.21250000000038, "TestAutogradWithCompiledAutograd": 306.38600000000037, "TestCompiledAutograd": 185.56933333333333, "TestCustomOpWithCompiledAutograd": 1.6099999999999965}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 555.814, "CompiledOptimizerTests": 239.69900000000044}, "inductor/test_config": {"TestInductorConfig": 7.103333333333334}, "inductor/test_control_flow": {"CondTests": 0.007333333333333333, "WhileLoopTests": 0.004}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 479.54, "TestCppWrapper": 497.3620000000001}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1477.0089999999998, "TestCppWrapper": 1539.5233333333333}, "inductor/test_cpu_repro": {"CPUReproTests": 744.7283333333331}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 1669.428, "TestSelectAlgorithmDynamicShapesCPU": 1715.1526666666668}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0030000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 11.344}, "inductor/test_debug_trace": {"TestDebugTrace": 3.3663333333333334}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0023333333333333335}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 35.28966666666667}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 77.67866666666667}, "inductor/test_extension_backend": {"ExtensionBackendTests": 19.48866666666667}, "inductor/test_flex_attention": {"TestFlexAttention": 0.015000000000000006, "TestTemplatedSDPA": 0.014000000000000005}, "inductor/test_foreach": {"ForeachTests": 17.808333333333387}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 90.97666666666667, "SDPAPatternRewriterCpuTests": 88.10266666666666}, "inductor/test_fx_fusion": {"TestFxFusion": 0.2753333333333334}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.016}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.20233333333333334, "TestGroupBatchFusion": 0.002, "TestPostGradBatchLinearFusion": 0.0003333333333333333}, "inductor/test_indexing": {"ExprPrinterTests": 0.062000000000000006, "TestIndexingSimplification": 0.5870000000000001}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 55.69133333333334}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_metrics": {"TestMetrics": 0.258}, "inductor/test_minifier": {"MinifierTests": 24.665000000000003}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 48.742333333333335}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 181.30066666666667, "TestPatternMatcher": 594.6456666666667}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.014333333333333339}, "inductor/test_profiler": {"DynamoProfilerTests": 0.005666666666666667}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 17.022000000000002}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.008}, "inductor/test_torchbind": {"TestTorchbind": 9.748666666666667}, "inductor/test_torchinductor": {"CpuTests": 1552.9283333333333, "SweepInputsCpuTest": 123.67299999999996, "TestFull": 11.047666666666666}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1587.7473333333326}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1765.7580000000005, "TestInductorDynamicCPU": 0.04566666666666669}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 26854.45466666667}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 1.8066666666666666}, "inductor/test_triton_kernels": {"KernelTests": 0.1003333333333334, "MutationTests": 0.009000000000000003, "NoOptimizationKernelTests": 0.011000000000000003, "no_opt_test_class": 0.019333333333333345}, "inductor/test_utils": {"TestUtils": 0.31833333333333336}, "lazy/test_debug_util": {"DebugUtilTest": 0.35366666666666663}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.3036666666666667}, "lazy/test_generator": {"LazyGeneratorTest": 0.37233333333333335}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.5576666666666666}, "lazy/test_step_closures": {"ClosuresTest": 2.248666666666667}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.2856666666666667, "TestLazyOpInfoCPU": 7.394666666666655, "TestLazyTensor": 0.081}, "nn/test_convolution": {"TestConvolutionNN": 12.631000000000002, "TestConvolutionNNDeviceTypeCPU": 6.029666666666631}, "nn/test_dropout": {"TestDropoutNN": 0.13366666666666668, "TestDropoutNNDeviceTypeCPU": 0.276}, "nn/test_embedding": {"TestEmbeddingNN": 0.06933333333333336, "TestEmbeddingNNDeviceTypeCPU": 7.328666666666664}, "nn/test_init": {"TestNNInit": 4.191333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 0.47333333333333355}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.8433333333333334, "TestLoadStateDictSwap": 0.05466666666666666}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.02033333333333333, "TestModuleHookNN": 0.08233333333333336, "TestModuleHooks": 0.07500000000000001, "TestStateDictHooks": 0.02933333333333334}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 5.748333333333334, "TestMultiheadAttentionNNDeviceTypeCPU": 0.02666666666666667}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.4543333333333334}, "nn/test_parametrization": {"TestNNParametrization": 0.9023333333333335, "TestNNParametrizationDeviceCPU": 0.02266666666666667}, "nn/test_pooling": {"TestAvgPool": 0.2123333333333333, "TestPoolingNN": 0.25033333333333335, "TestPoolingNNDeviceTypeCPU": 29.116000000000003}, "nn/test_pruning": {"TestPruningNN": 0.11800000000000005}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.107}, "profiler/test_memory_profiler": {"TestDataFlow": 1.2733333333333332, "TestIdentifyGradients": 0.232, "TestMemoryProfiler": 0.2826666666666667, "TestMemoryProfilerE2E": 2.8830000000000005}, "profiler/test_profiler": {"TestExecutionTrace": 8.155333333333333, "TestExperimentalUtils": 3.857999999999999, "TestProfiler": 17.537666666666663, "TestProfilerCUDA": 0.0006666666666666666, "TestProfilerITT": 0.004, "TestRecordFunction": 0.04133333333333333, "TestTorchTidyProfiler": 5.848999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.3303333333333334}, "profiler/test_record_function": {"TestRecordFunction": 0.30000000000000004}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.437666666666666}, "test_ao_sparsity": {"TestActivationSparsifier": 0.09100000000000001, "TestBaseDataScheduler": 0.034333333333333334, "TestBaseDataSparsifier": 0.07633333333333332, "TestBaseSparsifier": 0.03266666666666667, "TestBaseStructuredSparsifier": 1.774333333333333, "TestComposability": 1.7236666666666665, "TestCubicScheduler": 0.005333333333333333, "TestFPGMPruner": 0.027999999999999997, "TestFakeSparsity": 0.09466666666666668, "TestFxComposability": 1.3736666666666666, "TestNearlyDiagonalSparsifier": 0.6063333333333334, "TestNormDataSparsifiers": 0.7043333333333335, "TestQuantizationUtils": 0.024000000000000004, "TestQuantizedSparseKernels": 0.31866666666666665, "TestQuantizedSparseLayers": 0.35133333333333333, "TestSaliencyPruner": 0.034999999999999996, "TestScheduler": 0.020666666666666667, "TestSparsityUtilFunctions": 0.03933333333333333, "TestWeightNormSparsifier": 0.418}, "test_autocast": {"TestAutocastCPU": 0.8026666666666668, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.005333333333333333}, "test_autograd": {"TestAllowMutationOnSaved": 0.042666666666666665, "TestAutograd": 18.139666666666695, "TestAutogradComplex": 0.005, "TestAutogradDeviceTypeCPU": 0.2776666666666668, "TestAutogradForwardMode": 0.12266666666666674, "TestAutogradForwardModeBatchedGrad": 0.017333333333333336, "TestAutogradFunctional": 9.342999999999998, "TestAutogradInferenceMode": 0.04366666666666669, "TestAutogradLogging": 0.012333333333333333, "TestAutogradMultipleDispatchCPU": 0.020666666666666667, "TestMultithreadAutograd": 0.18433333333333335, "TestNestedCheckpoint": 0.37200000000000005, "TestSelectiveActivationCheckpoint": 0.031}, "test_autograd_fallback": {"TestAutogradFallback": 0.3700000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 126.723333333333}, "test_bundled_inputs": {"TestBundledInputs": 1.2519999999999998}, "test_comparison_utils": {"TestComparisonUtils": 0.299}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0006666666666666666}, "test_complex": {"TestComplexTensorCPU": 0.05666666666666668}, "test_content_store": {"TestContentStoreCPU": 5.855666666666667}, "test_cpp_api_parity": {"TestCppApiParity": 3.723999999999986}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.022666666666666672, "TestMAIATensor": 0.007666666666666666, "TestORTTensor": 0.012000000000000002, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.023666666666666673, "TestMAIATensor": 0.007666666666666666, "TestORTTensor": 0.012000000000000002, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 27.947666666666667}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.7276666666666666}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 8.065}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.7443333333333332}, "test_custom_backend": {"TestCustomBackend": 0.07133333333333332}, "test_custom_ops": {"MiniOpTest": 0.5570000000000003, "MiniOpTestOther": 0.06000000000000002, "TestCustomOp": 1.5266666666666644, "TestCustomOpAPI": 0.1466666666666667, "TestCustomOpTestingCPU": 1.5910000000000002, "TestCustomOperators": 0.25533333333333336, "TestGenerateOpcheckTests": 2.918333333333333}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 41.085, "TestConcatDataset": 0.011333333333333334, "TestConvAfterFork": 0.08333333333333333, "TestCustomPinFn": 0.0016666666666666668, "TestDataLoader": 37.29733333333334, "TestDataLoaderDeviceTypeCPU": 0.0026666666666666666, "TestDataLoaderPersistentWorkers": 56.60299999999999, "TestDatasetRandomSplit": 0.026, "TestDictDataLoader": 0.07366666666666667, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.004333333333333334, "TestSetAffinity": 0.07933333333333333, "TestStackDataset": 0.027000000000000007, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.017}, "test_datapipe": {"TestCaptureDataFrame": 0.0006666666666666666, "TestCircularSerialization": 0.008666666666666666, "TestDataChunk": 0.007666666666666666, "TestDataFramesPipes": 0.004666666666666667, "TestFunctionalIterDataPipe": 5.188666666666665, "TestFunctionalMapDataPipe": 0.03333333333333333, "TestGraph": 0.015, "TestIterDataPipeCountSampleYielded": 0.010333333333333333, "TestIterDataPipeGraphFastForward": 0.043333333333333335, "TestIterDataPipeSingletonConstraint": 0.022000000000000002, "TestIterableDataPipeBasic": 0.03233333333333333, "TestSerialization": 6.241, "TestSharding": 0.23600000000000007, "TestStreamWrapper": 0.3376666666666666, "TestTyping": 0.006666666666666667}, "test_decomp": {"DecompOneOffTestsCPU": 0.8166666666666668, "HasDecompTest": 0.137, "TestDecompCPU": 5154.479666666672}, "test_deploy": {"TestFreezer": 0.25433333333333336}, "test_dispatch": {"TestDispatch": 24.35766666666666, "TestPythonDispatcher": 0.013000000000000003}, "test_dlpack": {"TestTorchDlPackCPU": 0.23500000000000018}, "test_dynamic_shapes": {"TestDimConstraints": 1.805, "TestFloorDiv": 0.012333333333333335, "TestGuardsExpressions": 0.029666666666666664, "TestPySymInt": 1.362333333333333, "TestSymNumberMagicMethods": 1.8063333333333293}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 1.9303333333333317, "TestExpandedWeightHelperFunctionCPU": 0.018666666666666668, "TestExpandedWeightModuleCPU": 6.188}, "test_fake_tensor": {"FakeTensorConstHandling": 0.05033333333333335, "FakeTensorConverterTest": 0.021666666666666667, "FakeTensorDispatchCache": 0.06133333333333333, "FakeTensorOpInfoTestCPU": 0.09533333333333334, "FakeTensorOperatorInvariants": 0.274, "FakeTensorPropTest": 0.06266666666666666, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.5133333333333333, "PropagateRealTensorsFakeTensorConstHandling": 0.07900000000000001, "PropagateRealTensorsFakeTensorConverterTest": 0.01966666666666667, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.06733333333333334, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.15700000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.042333333333333334, "PropagateRealTensorsFakeTensorTest": 0.23200000000000007}, "test_flop_counter": {"TestFlopCounter": 0.4563333333333333}, "test_foreach": {"TestForeachCPU": 48.245666666666864}, "test_function_schema": {"TestFunctionSchema": 0.7816666666666667}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 38.788333333333334}, "test_functional_optim": {"TestFunctionalOptimParity": 0.5293333333333333}, "test_functionalization": {"TestCrossRefFunctionalization": 2.2019999999999995, "TestFunctionalization": 3.1143333333333314}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.016333333333333335}, "test_futures": {"TestFuture": 0.9686666666666667}, "test_fx": {"AnnotationsTest": 0.012333333333333337, "TestCSEPass": 0.23700000000000007, "TestCommonPass": 0.05466666666666666, "TestConstFold": 0.1393333333333334, "TestConstParamShapeInControlFlow": 0.039, "TestDCE": 0.026333333333333334, "TestFX": 2.63733333333333, "TestFXAPIBackwardCompatibility": 0.028333333333333332, "TestFunctionalTracing": 0.31066666666666687, "TestMatcher": 0.32100000000000006, "TestOperatorSignaturesCPU": 2.472333333333314, "TestPassManager": 0.020333333333333335, "TestSourceMatcher": 1.274333333333333, "TestSubgraphRewriter": 0.2553333333333334, "TestVisionTracing": 213.9186666666666, "TypeCheckerTest": 1.4913333333333314}, "test_fx_experimental": {"TestFXExperimental": 16.53466666666667, "TestNormalizeOperatorsCPU": 51.436000000000014, "TestTranslationValidation": 0.22599999999999998}, "test_fx_passes": {"TestFXGraphPasses": 0.6676666666666669, "TestFXMatcherUtils": 0.08233333333333336}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.42666666666666675}, "test_import_stats": {"TestImportTime": 3.6503333333333337}, "test_indexing": {"NumpyTestsCPU": 0.06200000000000003, "TestIndexingCPU": 1.9449999999999992}, "test_itt": {"TestItt": 0.30233333333333334}, "test_jit": {"TestAliasAnalysis": 0.3960000000000001, "TestAsync": 0.3046666666666667, "TestAtenPow": 0.010333333333333332, "TestAutodiffJit": 0.06899999999999999, "TestAutodiffSubgraphSlicing": 0.2830000000000001, "TestAwait": 0.139, "TestBackends": 0.5483333333333333, "TestBackendsWithCompiler": 0.153, "TestBatchMM": 0.078, "TestBuiltins": 0.063, "TestClassType": 0.8133333333333336, "TestComplex": 0.7386666666666667, "TestCustomOperators": 0.04500000000000001, "TestDCE": 0.018333333333333333, "TestDataParallel": 0.0013333333333333333, "TestDataclasses": 4.122333333333333, "TestDeviceAnalysis": 3.979999999999999, "TestDict": 0.3783333333333336, "TestDtypeAnalysis": 0.16166666666666668, "TestDtypeCustomRulesCPU": 2.7549999999999972, "TestEnum": 0.13133333333333333, "TestFreezing": 1.0490000000000006, "TestFrontend": 0.06166666666666667, "TestFrozenOptimizations": 12.464999999999998, "TestFunctionalBlocks": 0.007666666666666666, "TestFunctionalToInplaceActivation": 2.6606666666666667, "TestGenerator": 0.054666666666666676, "TestGetDefaultAttr": 0.02033333333333333, "TestGraphRewritePasses": 0.042666666666666665, "TestHash": 0.07066666666666667, "TestHooks": 0.7020000000000003, "TestIgnorableArgs": 0.010333333333333333, "TestIgnoreContextManager": 0.04633333333333334, "TestInplaceToFunctionalActivation": 2.5803333333333334, "TestIsinstance": 0.2270000000000001, "TestJit": 5.473999999999997, "TestJitGeneratedModule": 11.283666666666678, "TestJitProfiler": 0.0013333333333333333, "TestJitUtils": 0.017333333333333336, "TestList": 1.171666666666667, "TestLogging": 0.042666666666666665, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.15400000000000003, "TestMixTracingScripting": 0.9646666666666669, "TestModels": 1.7899999999999991, "TestModuleAPIs": 0.15966666666666665, "TestModuleContainers": 1.3846666666666667, "TestModuleInterface": 0.4403333333333334, "TestModules": 0.014666666666666666, "TestNamedTuple": 0.06100000000000002, "TestNnapiBackend": 11.847333333333331, "TestOpDecompositions": 0.018, "TestOptimizeForMobilePreserveDebugInfo": 0.18666666666666668, "TestParametrization": 0.11499999999999999, "TestPeephole": 0.46566666666666684, "TestProducerVersion": 0.002, "TestProfiler": 0.5516666666666667, "TestPythonBindings": 0.035666666666666666, "TestPythonBuiltinOP": 0.32433333333333336, "TestPythonIr": 0.026, "TestRecursiveScript": 0.6140000000000002, "TestRemoveMutation": 0.14333333333333334, "TestSaveLoad": 0.4483333333333334, "TestSaveLoadFlatbuffer": 0.22033333333333335, "TestSaveLoadForOpVersion": 2.265, "TestScript": 16.02566666666665, "TestScriptDict": 0.025333333333333336, "TestScriptList": 0.7296666666666667, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.136, "TestScriptProfile": 0.36733333333333335, "TestSlice": 0.1423333333333334, "TestSparse": 0.05366666666666667, "TestStringFormatting": 0.09966666666666668, "TestSymbolicShapeAnalysis": 1.674666666666666, "TestTensorBuiltins": 0.075, "TestTensorCreationOps": 0.04699999999999999, "TestTensorMethods": 0.012666666666666666, "TestTorchbind": 0.12100000000000004, "TestTracer": 3.0246666666666635, "TestTypeSharing": 0.41800000000000015, "TestTypesAndAnnotation": 0.083, "TestTyping": 0.3400000000000001, "TestUnion": 0.46533333333333354, "TestUnsupportedOps": 0.03166666666666667, "TestUpgraders": 0.07166666666666667, "TestWarn": 0.049999999999999996, "TestWith": 0.319}, "test_jit_autocast": {"TestAutocast": 0.14933333333333335, "TestJitTraceAutocast": 17.74}, "test_jit_disabled": {"TestJitDisabled": 0.3996666666666666}, "test_jit_fuser_te": {"TestFuserCommon": 0.13, "TestLoopnestRandomizationCPU": 0.041666666666666664, "TestNNCOpInfoCPU": 47.99933333333333, "TestTEFuserDynamic": 113.5816666666667, "TestTEFuserStatic": 45.60866666666667}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.07566666666666666, "TestFusionPatternCPU": 5.522333333333333, "TestModel": 3.5896666666666674, "TestOpCPU": 34.87066666666667}, "test_legacy_vmap": {"TestVmapAPI": 1.016333333333333, "TestVmapAPILegacy": 1.0893333333333326, "TestVmapBatchedGradientCPU": 0.07900000000000003, "TestVmapBatchedGradientLegacyCPU": 0.13300000000000006, "TestVmapOperators": 0.9350000000000002, "TestVmapOperatorsLegacy": 1.0873333333333333}, "test_license": {"TestLicense": 0.24933333333333332}, "test_linalg": {"TestLinalgCPU": 138.61266666666606}, "test_logging": {"LoggingTest": 2.363}, "test_masked": {"TestMaskedCPU": 15.958666666666652}, "test_maskedtensor": {"TestBasicsCPU": 0.154, "TestBinary": 0.35833333333333356, "TestOperatorsCPU": 5.6709999999999745, "TestReductions": 0.08333333333333336, "TestUnary": 0.41233333333333366}, "test_meta": {"TestMetaCPU": 1511.5583333332695, "TestMetaConverter": 0.08566666666666667}, "test_mkl_verbose": {"TestMKLVerbose": 3.72}, "test_mkldnn": {"TestMkldnnCPU": 100.72899999999997}, "test_mkldnn_fusion": {"TestMkldnnFusion": 57.92666666666667}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.4163333333333337}, "test_mobile_optimizer": {"TestOptimizer": 2.593}, "test_model_dump": {"TestModelDump": 1.0096666666666667}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.18466666666666665}, "test_module_init": {"TestModuleInitCPU": 1.9919999999999956}, "test_module_tracker": {"TestModuleTracker": 0.25666666666666665}, "test_modules": {"TestModuleCPU": 428.3153333333277}, "test_monitor": {"TestMonitor": 0.3466666666666667, "TestMonitorTensorboard": 0.15166666666666667}, "test_multiprocessing": {"TestMultiprocessing": 45.64233333333334}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.4303333333333334, "SpawnTest": 24.564999999999998}, "test_namedtensor": {"TestNamedTensor": 0.45500000000000024}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.8786666666666667}, "test_native_functions": {"TestNativeFunctions": 0.36800000000000005}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.18400000000000008}, "test_nestedtensor": {"TestNestedTensor": 0.1600000000000001, "TestNestedTensorAutogradCPU": 0.8720000000000002, "TestNestedTensorDeviceTypeCPU": 1.0299999999999996, "TestNestedTensorSubclassCPU": 20.231333333333353}, "test_nn": {"TestAddRelu": 0.0033333333333333335, "TestConstantPadNd": 0.0036666666666666666, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.304, "TestFusionUtils": 0.004666666666666667, "TestNN": 32.194333333333276, "TestNNDeviceTypeCPU": 104.38366666666741, "TestUtils": 0.0033333333333333335}, "test_numba_integration": {"TestNumbaIntegration": 0.007333333333333334}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.19466666666666677}, "test_openmp": {"TestOpenMP_ParallelFor": 5.982666666666667}, "test_ops": {"TestCommonCPU": 1282.6353333333266, "TestCompositeComplianceCPU": 782.3896666666609, "TestFakeTensorCPU": 276.73400000000066, "TestMathBitsCPU": 39.316333333333304, "TestRefsOpsInfoCPU": 1.2749999999999968, "TestSelfKwarg": 0.022333333333333334, "TestTagsCPU": 10.335666666666626}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 589.6403333333318}, "test_ops_gradients": {"TestBwdGradientsCPU": 1040.0426666666283}, "test_ops_jit": {"TestJitCPU": 862.316999999999}, "test_optim": {"TestDifferentiableOptimizer": 0.18733333333333335, "TestLRScheduler": 1.0986666666666667, "TestOptim": 46.241, "TestOptimRenewedCPU": 37.68466666666672, "TestSWAUtils": 0.19166666666666665}, "test_out_dtype_op": {"TestOutDtypeOp": 0.36833333333333335}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.0016666666666666668, "TestDisabledUserWarnings": 0.0013333333333333333, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.016, "TestGradNewOnesOverride": 0.0016666666666666668, "TestIndexing": 0.005666666666666667, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.0030000000000000005, "TestResolveName": 0.08800000000000001, "TestTorchFunctionMode": 0.031000000000000017, "TestTorchFunctionOverride": 1.7389999999999226, "TestTorchFunctionWarning": 0.011333333333333334, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.035333333333333335, "ModelTest": 0.001, "TestAnalyze": 0.18566666666666665, "TestDependencyAPI": 0.049666666666666685, "TestDependencyHooks": 0.009000000000000001, "TestDiGraph": 0.018000000000000006, "TestGlobGroup": 0.021000000000000008, "TestImporter": 0.010333333333333335, "TestLoadBCPackages": 0.067, "TestMangling": 0.017333333333333336, "TestMisc": 0.05533333333333334, "TestPackageFX": 0.062, "TestPackageScript": 1.5686666666666662, "TestRepackage": 0.010666666666666666, "TestResources": 0.012333333333333335, "TestSaveLoad": 0.030333333333333334}, "test_per_overload_api": {"TestPerOverloadAPI": 0.261}, "test_prims": {"TestDecompCPU": 0.09366666666666668, "TestPrimsBasic": 0.03133333333333333, "TestPrimsCPU": 0.06666666666666667, "TestRefsCPU": 0.015666666666666666}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.09700000000000002, "TestGenericProxyTensorFake": 1.8343333333333334, "TestGenericProxyTensorReal": 2.92, "TestGenericProxyTensorSymbolic": 17.759333333333334, "TestProxyTensorOpInfoCPU": 654.2093333333329, "TestRealProxyTensor": 0.014333333333333332, "TestSymbolicTracing": 3.2696666666666663}, "test_pruning_op": {"PruningOpTest": 0.528}, "test_public_bindings": {"TestPublicBindings": 6.773333333333333}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.024000000000000004, "TestPythonDispatch": 0.20866666666666678, "TestPythonDispatcher": 0.006000000000000001, "TestPythonRegistration": 0.28400000000000003, "TestWrapperSubclassAliasingCPU": 0.09266666666666672}, "test_pytree": {"TestCxxPytree": 0.02200000000000001, "TestGenericPytree": 0.37266666666666676, "TestPythonPytree": 0.0776666666666667}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.01666666666666667, "TestAOMigrationNNQuantized": 0.06266666666666666, "TestAOMigrationQuantization": 0.030666666666666672, "TestAOMigrationQuantizationFx": 0.02166666666666667, "TestBackendConfig": 0.05733333333333335, "TestBiasCorrectionEager": 1.4843333333333335, "TestBits": 0.005333333333333333, "TestBitsCPU": 0.057, "TestComparatorOps": 1.281, "TestDeprecatedJitQuantized": 4.104333333333333, "TestDistributed": 0.027, "TestDuplicateDQPass": 2.6156666666666664, "TestDynamicQuantizedModule": 46.065666666666665, "TestDynamicQuantizedOps": 24.609666666666666, "TestEqualizeEager": 0.128, "TestEqualizeFx": 5.572666666666667, "TestFXGraphMatcher": 1.6873333333333331, "TestFXGraphMatcherModels": 9.073666666666666, "TestFXNumericSuiteCoreAPIs": 25.649666666666665, "TestFXNumericSuiteCoreAPIsModels": 33.339333333333336, "TestFXNumericSuiteNShadows": 36.36066666666667, "TestFakeQuantize": 0.38000000000000006, "TestFakeQuantizeOps": 2.0996666666666663, "TestFloat8DtypeCPU": 0.10433333333333338, "TestFloat8DtypeCPUOnlyCPU": 0.7053333333333334, "TestFuseEager": 2.530666666666667, "TestFuseFx": 2.5256666666666665, "TestFusedObsFakeQuant": 0.15366666666666667, "TestFusedObsFakeQuantModule": 0.22933333333333336, "TestFusionPasses": 0.023000000000000003, "TestFxDetectInputWeightEqualization": 0.18200000000000002, "TestFxDetectOutliers": 0.3526666666666667, "TestFxModelReportClass": 0.5763333333333334, "TestFxModelReportDetectDynamicStatic": 0.05366666666666667, "TestFxModelReportDetector": 0.239, "TestFxModelReportObserver": 0.168, "TestFxModelReportVisualizer": 0.36533333333333334, "TestGenerateNumericDebugHandle": 0.6890000000000001, "TestGraphUtils": 1.6656666666666666, "TestHistogramObserver": 28.55, "TestMetaDataPorting": 4.992333333333334, "TestModelNumericsEager": 1.314, "TestNumericSuiteEager": 8.638333333333332, "TestObserver": 3.609, "TestPT2ERepresentation": 24.703, "TestPadding": 21.80633333333333, "TestQNNPackOps": 6.028, "TestQuantizationDocs": 0.005666666666666667, "TestQuantizeDynamicJitOps": 2.619666666666667, "TestQuantizeDynamicJitPasses": 5.453, "TestQuantizeEagerOps": 1.6313333333333333, "TestQuantizeEagerPTQDynamic": 9.203666666666667, "TestQuantizeEagerPTQStatic": 25.962333333333333, "TestQuantizeEagerQAT": 10.949666666666666, "TestQuantizeEagerQATNumerics": 1.995333333333333, "TestQuantizeFx": 46.642, "TestQuantizeFxModels": 7.347666666666666, "TestQuantizeFxOps": 114.59233333333334, "TestQuantizeJit": 20.330333333333332, "TestQuantizeJitOps": 227.68399999999997, "TestQuantizeJitPasses": 6.028000000000001, "TestQuantizePT2E": 46.00899999999999, "TestQuantizePT2EQAT": 37.343333333333334, "TestQuantizePT2EQATModels": 26.319000000000003, "TestQuantizePT2EQAT_ConvBn1d": 277.1166666666666, "TestQuantizePT2EQAT_ConvBn2d": 275.1423333333333, "TestQuantizePT2EX86Inductor": 121.10766666666665, "TestQuantizedConv": 54.10133333333332, "TestQuantizedEmbeddingOps": 1.228, "TestQuantizedFunctionalOps": 2.707333333333333, "TestQuantizedLinear": 19.617, "TestQuantizedOps": 128.79333333333332, "TestQuantizedTensor": 2.1879999999999993, "TestRecordHistogramObserver": 0.05000000000000001, "TestReferenceQuantizedModule": 0.064, "TestSerialization": 2.030666666666667, "TestStaticQuantizedModule": 126.16933333333334, "TestSubgraphRewriter": 1.4143333333333334, "TestUtils": 0.02266666666666667, "TestXNNPACKQuantizer": 36.41366666666667, "TestXNNPACKQuantizerModels": 2.9789999999999996}, "test_reductions": {"TestReductionsCPU": 193.99433333333502}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 3.8750000000000004}, "test_schema_check": {"TestSchemaCheck": 0.12766666666666673, "TestSchemaCheckModeOpInfoCPU": 172.46833333333063}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.0230000000000004}, "test_serialization": {"TestBothSerializationCPU": 0.1466666666666667, "TestOldSerialization": 26.11966666666667, "TestSerialization": 8.411666666666664, "TestSubclassSerialization": 0.04066666666666668}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.259}, "test_shape_ops": {"TestShapeOpsCPU": 1.2063333333333326}, "test_show_pickle": {"TestShowPickle": 0.25533333333333336}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.968333333333331}, "test_sparse": {"TestSparseAnyCPU": 395.617666666665, "TestSparseCPU": 21.291999999999998, "TestSparseLegacyAndDeprecation": 0.07200000000000001, "TestSparseMaskedReductionsCPU": 0.9306666666666671, "TestSparseMeta": 4.026, "TestSparseOneOff": 0.0023333333333333335, "TestSparseUnaryUfuncsCPU": 6.996999999999898}, "test_sparse_csr": {"TestSparseCSRCPU": 70.80266666666701, "TestSparseCSRSampler": 0.555, "TestSparseCompressedCPU": 88.8159999999998, "TestSparseCompressedTritonKernelsCPU": 0.007666666666666668}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 5.968333333333323, "TestFFTDocExamplesCPU": 0.0716666666666667}, "test_stateless": {"TestPythonOptimizeMode": 4.152333333333334, "TestStatelessDeprecation": 1.5716666666666665, "TestStatelessFunctionalAPI": 0.2673333333333334}, "test_subclass": {"TestSubclass": 0.5110000000000001}, "test_sympy_utils": {"TestNumbers": 0.05433333333333334, "TestSingletonInt": 0.006999999999999999, "TestSympyInterp": 10.662333333333335, "TestSympySolve": 0.2986666666666667, "TestValueRanges": 6.2683333333333335}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.5260000000000004, "TestBufferProtocolCPU": 0.33500000000000024, "TestLikeTensorCreationCPU": 0.009666666666666669, "TestRandomTensorCreationCPU": 2.771666666666666, "TestTensorCreationCPU": 18.240666666666694}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.02266666666666667, "TestTensorBoardFigure": 0.0016666666666666668, "TestTensorBoardNumpy": 0.0033333333333333335, "TestTensorBoardPyTorchNumpy": 0.18733333333333335, "TestTensorBoardPytorchGraph": 29.136, "TestTensorBoardSummary": 0.05133333333333335, "TestTensorBoardSummaryWriter": 0.008333333333333333, "TestTensorBoardUtils": 0.15000000000000002, "TestTensorBoardWriter": 0.10499999999999998, "TestTensorProtoSummary": 0.012000000000000002}, "test_tensorexpr": {"TestTensorExprFuser": 45.75999999999999}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.007666666666666666, "TestTensorExprPyBind": 0.943}, "test_testing": {"TestAssertClose": 0.12900000000000006, "TestAssertCloseContainer": 0.009333333333333334, "TestAssertCloseErrorMessage": 0.07466666666666667, "TestAssertCloseQuantized": 0.013999999999999999, "TestAssertCloseSparseBSC": 0.02, "TestAssertCloseSparseBSR": 0.020333333333333335, "TestAssertCloseSparseCOO": 0.026333333333333337, "TestAssertCloseSparseCSC": 0.021333333333333333, "TestAssertCloseSparseCSR": 0.021333333333333333, "TestFrameworkUtils": 12.581666666666665, "TestImports": 12.006333333333336, "TestMakeTensorCPU": 1.3709999999999924, "TestOpInfoSampleFunctionsCPU": 4.783333333333311, "TestOpInfos": 0.006333333333333333, "TestTestParametrization": 0.03600000000000001, "TestTestParametrizationDeviceTypeCPU": 3.819333333333333, "TestTestingCPU": 0.2003333333333334}, "test_torch": {"TestBasicVitalSigns": 0.03, "TestTorch": 3.633333333333327, "TestTorchDeviceTypeCPU": 13.079000000000065, "TestVitalSignsCudaCPU": 0.002}, "test_transformers": {"TestAttnBiasCPU": 20.740000000000002, "TestAttnMasksCPU": 18.374999999999996, "TestSDPACPU": 259.14433333333255, "TestSDPAFailureModesCPU": 0.032333333333333346, "TestTransformersCPU": 7.123666666666666}, "test_type_hints": {"TestTypeHints": 0.36600000000000005}, "test_type_info": {"TestDTypeInfo": 0.31333333333333335}, "test_type_promotion": {"TestTypePromotionCPU": 2.9449999999999883}, "test_typing": {"TestTyping": 71.95133333333334}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 369.723333333276}, "test_utils": {"TestAssert": 0.052333333333333336, "TestBottleneck": 7.926666666666667, "TestCheckpoint": 0.07800000000000001, "TestCollectEnv": 1.0033333333333334, "TestCppExtensionUtils": 0.1413333333333333, "TestDataLoaderUtils": 0.25566666666666665, "TestDeviceUtilsCPU": 23.730000000000725, "TestExtensionUtils": 0.004666666666666667, "TestHipify": 0.0013333333333333333, "TestHipifyTrie": 0.007, "TestONNXUtils": 0.004666666666666667, "TestRenderUtils": 0.013, "TestStandaloneCPPJIT": 1.688, "TestTraceback": 0.010666666666666666}, "test_view_ops": {"TestOldViewOpsCPU": 12.86700000000001, "TestViewOpsCPU": 0.7656666666666672, "TestViewOpsLAZY": 1.0039999999999987}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.017666666666666667, "WeakKeyDictionaryTestCase": 0.026333333333333334, "WeakTest": 4.626333333333332}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 32.61533333333333, "TestXNNPACKOps": 4.689333333333334, "TestXNNPACKRewritePass": 1.8383333333333332, "TestXNNPACKSerDes": 5.209333333333334}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.015333333333333336}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.3526666666666667, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0006666666666666666, "TestFromDTypeAttribute": 0.0026666666666666666, "TestMisc": 0.006333333333333334, "TestPickling": 0.12500000000000003, "TestPromotion": 0.005666666666666668}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 12.712666666666669, "TestEinsumPath": 0.001, "TestMisc": 0.008}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0016666666666666668, "TestHalf": 0.0006666666666666666, "TestIinfo": 0.26533333333333337, "TestMisc": 0.0036666666666666666, "TestPythonFloat": 0.001, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0030000000000000005, "TestBooleanIndexing": 0.016333333333333335, "TestBroadcastedAssignments": 0.03133333333333333, "TestFancyIndexingCast": 0.008, "TestFloatNonIntegerArgument": 0.013, "TestIndexing": 0.5980000000000002, "TestMultiIndexingAutomated": 0.013333333333333336, "TestMultipleEllipsisError": 0.0030000000000000005, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.025333333333333336, "TestArgmax": 1.1000000000000003, "TestArgmaxArgminCommon": 0.11000000000000006, "TestArgmin": 1.116333333333334, "TestArrayAttributeDeletion": 0.009000000000000001, "TestArrayConstruction": 0.04366666666666668, "TestArrayCreationCopyArgument": 0.009000000000000001, "TestArrayInterface": 0.028666666666666663, "TestAssignment": 0.009333333333333334, "TestAttributes": 0.018333333333333337, "TestBinop": 0.017666666666666667, "TestBool": 19.907, "TestCequenceMethods": 0.0023333333333333335, "TestChoose": 0.022333333333333334, "TestClip": 0.006666666666666667, "TestCompress": 0.006000000000000001, "TestConversion": 0.04633333333333334, "TestCreation": 0.0016666666666666668, "TestDelMisc": 0.006000000000000001, "TestDot": 0.07733333333333335, "TestDtypedescr": 0.0013333333333333333, "TestFancyIndexing": 0.027999999999999997, "TestFlag": 0.013000000000000003, "TestFormat": 0.006333333333333333, "TestFromBuffer": 0.01666666666666667, "TestHash": 0.18533333333333335, "TestHashing": 0.004, "TestIO": 0.004, "TestInner": 0.19200000000000003, "TestLexsort": 0.02166666666666667, "TestMatmul": 0.3966666666666667, "TestMatmulOperator": 0.2896666666666667, "TestMethods": 1.368666666666667, "TestMinMax": 0.005666666666666667, "TestMinScalarType": 0.008666666666666668, "TestNewaxis": 0.004, "TestPEP3118Dtype": 0.0030000000000000005, "TestPutmask": 0.014, "TestRepeat": 0.015333333333333332, "TestResize": 0.04733333333333334, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.017666666666666667, "TestSizeOf": 0.010666666666666666, "TestSortFloatMisc": 0.16866666666666671, "TestStats": 0.25766666666666665, "TestSubscripting": 0.002, "TestTake": 0.036333333333333336, "TestVdot": 0.045000000000000005, "TestViewDtype": 0.006999999999999999, "TestWarnings": 0.002, "TestWhere": 0.38533333333333336, "TestWritebackIfCopy": 0.02866666666666667}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.023000000000000003, "TestArgwhere": 0.035333333333333335, "TestArrayComparisons": 0.015666666666666666, "TestBaseRepr": 0.008333333333333333, "TestBinaryRepr": 0.012333333333333335, "TestBoolArray": 3.078, "TestBoolCmp": 0.18933333333333335, "TestBoolScalar": 0.011666666666666667, "TestBroadcast": 0.009000000000000001, "TestClip": 0.2323333333333335, "TestConvolve": 0.022000000000000002, "TestCorrelate": 0.036333333333333336, "TestCreationFuncs": 1.0636666666666665, "TestCross": 0.05766666666666667, "TestDtypePositional": 0.0026666666666666666, "TestFloatExceptions": 0.010666666666666666, "TestFromiter": 0.002, "TestIndex": 0.007, "TestIndices": 0.050333333333333334, "TestIsclose": 0.09800000000000002, "TestIsscalar": 0.0023333333333333335, "TestLikeFuncs": 0.0023333333333333335, "TestMoveaxis": 0.013000000000000003, "TestNonarrayArgs": 0.11100000000000006, "TestNonzeroAndCountNonzero": 0.24899999999999997, "TestOuterMisc": 0.005666666666666667, "TestRequire": 0.008, "TestResize": 0.335, "TestRoll": 0.03833333333333333, "TestRollaxis": 0.006333333333333333, "TestSeterr": 0.008333333333333333, "TestStdVar": 0.030333333333333334, "TestStdVarComplex": 0.013999999999999999, "TestStringFunction": 0.0026666666666666666, "TestTensordot": 0.015333333333333332, "TestTypes": 0.014666666666666666}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0013333333333333333, "TestCommonType": 0.27133333333333337, "TestDocStrings": 0.0, "TestIsSubDType": 0.008666666666666668, "TestScalarTypeNames": 0.02833333333333335}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.1033333333333334, "TestFromInt": 0.011333333333333334, "TestFromString": 0.391}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0006666666666666666, "TestBitCount": 0.0, "TestClassGetItem": 0.0026666666666666666, "TestClassGetitemMisc": 0.2843333333333333, "TestIsInteger": 0.0030000000000000005}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.09699999999999999, "TestBaseMath": 7.862666666666667, "TestBitShifts": 0.08466666666666667, "TestComplexDivision": 0.054666666666666676, "TestConversion": 0.05000000000000001, "TestHash": 0.0003333333333333333, "TestModulus": 0.8816666666666665, "TestMultiply": 0.0, "TestNegative": 0.018, "TestPower": 0.11766666666666668, "TestRepr": 0.0016666666666666668, "TestScalarOpsMisc": 0.0636666666666667, "TestScalarSubclassingMisc": 0.04333333333333336, "TestSubtract": 0.017666666666666667, "TestTypes": 12.361666666666666}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.3263333333333333, "TestAtleast2d": 0.014666666666666668, "TestAtleast3d": 0.012000000000000002, "TestBlock": 0.040000000000000015, "TestConcatenate": 0.19733333333333344, "TestHstack": 0.015, "TestStackMisc": 0.016666666666666673, "TestVstack": 0.020000000000000004}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.010666666666666666, "TestFFTShift": 4.9830000000000005, "TestIRFFTN": 0.009, "TestRFFTFreq": 0.010333333333333333}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.994333333333332, "TestFFTShift": 0.267, "TestFFTThreadSafe": 1.577}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.38466666666666666}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.004666666666666667, "TestUnique": 0.37833333333333335}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.006333333333333333, "TestAmin": 0.006333333333333333, "TestAngle": 0.009333333333333332, "TestAny": 0.014, "TestAverage": 0.03266666666666667, "TestBincount": 0.042, "TestCheckFinite": 0.0023333333333333335, "TestCopy": 0.010666666666666666, "TestCorrCoef": 0.029333333333333333, "TestCov": 0.05200000000000001, "TestCumprod": 0.03, "TestCumsum": 0.04066666666666666, "TestDelete": 0.022333333333333334, "TestDiff": 0.112, "TestDigitize": 0.01566666666666667, "TestExtins": 0.006333333333333334, "TestFilterwindows": 0.500666666666667, "TestFlip": 0.04066666666666666, "TestGradient": 0.19166666666666668, "TestInsert": 0.011333333333333334, "TestInterp": 0.053666666666666696, "TestKaiser": 0.01, "TestMedian": 0.12033333333333333, "TestMeshgrid": 0.05266666666666667, "TestMsort": 0.0, "TestPercentile": 0.11400000000000006, "TestPiecewise": 0.012000000000000002, "TestProd": 0.029333333333333333, "TestPtp": 0.009666666666666665, "TestQuantile": 0.022666666666666672, "TestRot90": 0.38333333333333336, "TestSelect": 0.011666666666666667, "TestSinc": 0.007, "TestSortComplex": 0.019, "TestTrapz": 0.005, "TestTrimZeros": 0.012333333333333335, "TestUnique": 0.0036666666666666666, "Test_I0": 0.011333333333333334}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4216666666666668, "TestHistogramOptimBinNums": 0.041666666666666685, "TestHistogramdd": 0.18000000000000002}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0016666666666666668, "TestConcatenator": 0.008333333333333333, "TestDiagIndices": 0.008333333333333333, "TestDiagIndicesFrom": 0.011666666666666665, "TestFillDiagonal": 0.03500000000000001, "TestGrid": 0.012000000000000002, "TestIndexExpression": 0.014, "TestIx_": 0.015333333333333332, "TestNdIndex": 0.0016666666666666668, "TestNdenumerate": 0.0016666666666666668, "TestRavelUnravelIndex": 0.2966666666666667}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.012333333333333337, "TestApplyOverAxes": 0.0016666666666666668, "TestArraySplit": 0.12433333333333335, "TestColumnStack": 0.008, "TestDsplit": 0.009333333333333334, "TestDstack": 0.014, "TestExpandDims": 0.006666666666666667, "TestHsplit": 0.010666666666666666, "TestKron": 0.015, "TestMayShareMemory": 0.0023333333333333335, "TestPutAlongAxis": 0.008, "TestSplit": 0.005666666666666667, "TestSqueeze": 0.02466666666666667, "TestTakeAlongAxis": 0.32033333333333336, "TestTile": 0.08766666666666667, "TestVsplit": 0.008}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.035, "TestEye": 0.4240000000000001, "TestFliplr": 0.005999999999999999, "TestFlipud": 0.007333333333333333, "TestHistogram2d": 0.039666666666666676, "TestTri": 0.137, "TestTrilIndicesFrom": 0.004333333333333334, "TestTriuIndices": 0.0036666666666666666, "TestTriuIndicesFrom": 0.0023333333333333335, "TestVander": 0.03566666666666666}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0016666666666666668, "TestCommonType": 0.4136666666666667, "TestImag": 0.013333333333333334, "TestIscomplex": 0.006333333333333333, "TestIscomplexobj": 0.005, "TestIsfinite": 0.015, "TestIsinf": 0.013, "TestIsnan": 0.013, "TestIsneginf": 0.0026666666666666666, "TestIsposinf": 0.0026666666666666666, "TestIsreal": 0.009333333333333332, "TestIsrealobj": 0.002, "TestIsscalar": 0.0023333333333333335, "TestMintypecode": 0.005333333333333333, "TestNanToNum": 0.018666666666666668, "TestReal": 0.017333333333333336, "TestRealIfClose": 0.004333333333333334}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.19933333333333336, "TestCond": 0.224, "TestDet": 0.17333333333333334, "TestEig": 0.060000000000000005, "TestEigh": 0.027000000000000007, "TestEighCases": 0.0, "TestEigvals": 0.07600000000000001, "TestEigvalsh": 0.025333333333333336, "TestEigvalshCases": 0.0006666666666666666, "TestInv": 0.07066666666666667, "TestLstsq": 0.248, "TestMatrixRank": 0.4276666666666667, "TestMisc": 0.048666666666666664, "TestMisc2": 0.008666666666666668, "TestMultiDot": 0.08433333333333333, "TestNormDouble": 0.826, "TestNormInt64": 0.8093333333333333, "TestNormSingle": 1.0200000000000002, "TestNorm_NonSystematic": 0.0036666666666666666, "TestPinv": 0.144, "TestPinvHermitian": 0.04533333333333334, "TestQR": 0.7469999999999981, "TestSVD": 0.06466666666666666, "TestSVDHermitian": 0.10300000000000002, "TestSolve": 0.4626666666666667, "TestTensorinv": 0.03333333333333333, "TestTensorsolve": 0.013}, "torch_np/test_basic": {"TestArrayToSequence": 0.008333333333333333, "TestCopyTo": 0.006666666666666667, "TestCtorNested": 0.004, "TestDefaultDtype": 0.009333333333333334, "TestDivmod": 0.017333333333333336, "TestExport": 0.0003333333333333333, "TestMisc": 0.0026666666666666666, "TestNormalizations": 0.006000000000000001, "TestOneArr": 0.33933333333333354, "TestOneArrAndAxesTuple": 0.013000000000000003, "TestOneArrAndAxis": 0.16366666666666677, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.013333333333333336, "TestPythonArgsToArray": 0.014333333333333337, "TestSequenceOfArrays": 0.021000000000000008, "TestSequenceOfArraysToSingle": 0.011333333333333334, "TestShapeLikeToArray": 0.005666666666666667, "TestSmokeNotImpl": 0.0023333333333333335}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.4196666666666668}, "torch_np/test_dtype": {"TestConvertDType": 0.33466666666666667}, "torch_np/test_function_base": {"TestAppend": 0.325}, "torch_np/test_ndarray_methods": {"TestAmax": 0.008333333333333333, "TestAmin": 0.011999999999999999, "TestArgmax": 1.0486666666666673, "TestArgmaxArgminCommon": 0.11100000000000008, "TestArgmin": 1.095666666666667, "TestContains": 0.0023333333333333335, "TestIndexing": 0.2806666666666667, "TestIter": 0.013333333333333334, "TestNoExtraMethods": 0.016333333333333335, "TestNonzero": 0.11266666666666665, "TestRavel": 0.006000000000000001, "TestReshape": 0.004, "TestTranspose": 0.007333333333333333}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.048333333333333346, "TestNEP50Table": 0.002}, "torch_np/test_random": {"TestChoice": 0.012000000000000002, "TestNumpyGlobal": 0.004333333333333334, "TestScalarReturn": 0.3413333333333333, "TestShuffle": 0.013333333333333336}, "torch_np/test_reductions": {"TestAll": 0.014666666666666668, "TestAny": 0.014333333333333335, "TestFlatnonzero": 0.208, "TestGenericCumSumProd": 0.02033333333333333, "TestGenericReductions": 2.3459999999999472, "TestMean": 0.03233333333333334, "TestSum": 0.20433333333333334}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.4093333333333334, "TestIsScalar": 0.05666666666666668}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.5996666666666671, "TestNdarrayDunderVsUfunc": 0.18666666666666676, "TestUfuncDtypeKwd": 0.005333333333333333, "TestUnaryUfuncs": 0.2916666666666667}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.48366666666666686}}, "dynamo": {"backends/xeon/test_launch": {"TestTorchrun": 1.9903333333333333}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.7226666666666666}, "distributions/test_constraints": {"test_constraints": 0.08166666666666672}, "distributions/test_distributions": {"TestAgainstScipy": 0.0003333333333333333, "TestConstraints": 46.702666666666666, "TestDistributionShapes": 59.58366666666666, "TestDistributions": 0.0033333333333333335, "TestFunctors": 2.9233333333333333, "TestJit": 218.16033333333337, "TestKL": 0.0026666666666666666, "TestLazyLogitsInitialization": 46.97399999999999, "TestNumericalStability": 0.079, "TestRsample": 0.0, "TestValidation": 55.74333333333333}, "dynamo/test_after_aot": {"TestAfterAot": 8.0485}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 14.1495}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 1.5020000000000002}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.075, "TestCustomBackendAPI": 1.418, "TestExplainWithBackend": 11.322, "TestOptimizations": 0.95}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 12.5365}, "dynamo/test_base_output": {"TestBaseOutput": 0.04866666666666667}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 7.8065}, "dynamo/test_compile": {"InPlaceCompilationTests": 8.215, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.49800000000000005}, "dynamo/test_config": {"ConfigTests": 0.538}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.2870000000000001}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.18099999999999997}, "dynamo/test_decorators": {"DecoratorTests": 0.7003333333333335}, "dynamo/test_exc": {"ExcTests": 1.6204999999999998}, "dynamo/test_export_mutations": {"MutationExportTests": 0.4673333333333334}, "dynamo/test_frame_init": {"FrameInitTests": 0.22}, "dynamo/test_functions": {"DefaultsTests": 11.084499999999963, "FunctionTests": 15.342999999999998}, "dynamo/test_global": {"TestGlobals": 0.5986666666666668}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.07250000000000001, "FuncTorchHigherOrderOpTests": 1.9874999999999998, "HigherOrderOpTests": 6.654499999999998}, "dynamo/test_hooks": {"HooksTests": 23.791333333333338}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 9.232333333333333}, "dynamo/test_interop": {"InteropTests": 0.5916666666666667}, "dynamo/test_logging": {"LoggingTests": 11.678999999999995}, "dynamo/test_minifier": {"MinifierTests": 1.448}, "dynamo/test_misc": {"MiscTests": 34.37800000000003, "TestTracer": 0.0505}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0030000000000000005}, "dynamo/test_nops": {"NopTests": 0.397}, "dynamo/test_optimizers": {"End2EndTests": 0.245, "OptimizerTests": 1.7715}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.49250000000000005}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.9675}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.6910000000000001}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.0553333333333332}, "dynamo/test_recompiles": {"RecompileTests": 0.8570000000000001}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.0033333333333333335}, "dynamo/test_repros": {"ReproTests": 42.27000000000002}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.524}, "dynamo/test_subclasses": {"SubclassTests": 1.2599999999999998, "TestNestedTensor": 1.5760000000000003}, "dynamo/test_subgraphs": {"SubGraphTests": 2.9139999999999997}, "dynamo/test_unspec": {"UnspecTests": 10.131}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.5803333333333334}, "export/test_db": {"ExampleTests": 4.859666666666667}, "export/test_export": {"TestDynamismExpression": 0.6349999999999999, "TestExport": 24.617999999999995, "TestExportCustomClass": 0.11133333333333333, "TestOneOffModelExportResult": 0.08600000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 1.0119999999999998}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 2.0273333333333334}, "export/test_pass_infra": {"TestPassInfra": 1.534}, "export/test_passes": {"TestPasses": 5.653666666666667}, "export/test_safeguard": {"TestSafeguard": 1.6956666666666669}, "export/test_serialize": {"TestDeserialize": 11.168, "TestOpVersioning": 0.02733333333333333, "TestSaveLoad": 0.5566666666666666, "TestSchemaVersioning": 0.12666666666666668, "TestSerialize": 1.814, "TestSerializeCustomClass": 0.102}, "export/test_torchbind": {"TestExportTorchbind": 0.0}, "export/test_unflatten": {"TestUnflatten": 2.508666666666667}, "export/test_upgrade": {"TestUpgrade": 1.4166666666666667}, "export/test_verifier": {"TestVerifier": 1.6416666666666668}, "functorch/test_aotdispatch": {"TestAOTAutograd": 39.36966666666667, "TestAOTAutogradWithDynamo": 0.011333333333333336, "TestAOTDispatch": 6.171333333333333, "TestAOTExport": 4.521333333333334, "TestAOTModuleSimplified": 1.4160000000000001, "TestEagerFusionModuleInfoCPU": 2.4246666666666634, "TestEagerFusionOpInfoCPU": 14.484333333333096, "TestPartitioning": 5.466, "TestPythonKeyCPU": 14.221333333333334}, "functorch/test_control_flow": {"TestControlFlow": 7.073666666666665, "TestControlFlowTraced": 329.2293333333332}, "functorch/test_dims": {"TestMin": 0.0026666666666666666, "TestMinFunctorchOnly": 0.0013333333333333333}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 4.554666666666666, "TestAutogradFunctionVmapAPICPU": 1.0073333333333332, "TestCompileTransformsCPU": 11.587666666666665, "TestComposabilityCPU": 10.522333333333334, "TestExamplesCorrectnessCPU": 26.209666666666667, "TestFunctionalizeCPU": 3.108333333333333, "TestGradTransformCPU": 20.95266666666667, "TestHelpersCPU": 0.5850000000000001, "TestHessianCPU": 4.135666666666666, "TestHigherOrderOperatorInteractionCPU": 1.1050000000000002, "TestJacCPU": 55.08766666666667, "TestJvpCPU": 6.3180000000000005, "TestLinearizeCPU": 1.2673333333333332, "TestMakeFunctional": 1.292, "TestSliceArgnums": 0.25866666666666666, "TestVmapJvpInplaceViewCPU": 4.4526666666666666, "TestVmapOfGradCPU": 26.046666666666667}, "functorch/test_logging": {"TestAOTLogging": 1.024}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 1.1503333333333332, "RandomOpTestCase": 0.47000000000000003, "ReduceTestCase": 0.6186666666666667, "TestMemoryEfficientOpAuthoring": 0.0}, "functorch/test_minifier": {"TestMinifier": 2.337666666666667}, "functorch/test_ops": {"TestOperatorsCPU": 40.11500000000275}, "functorch/test_parsing": {"TestAnonymousAxis": 0.98, "TestParsedExpression": 0.02466666666666667, "TestParsingUtils": 0.030333333333333334, "TestValidateRearrangeExpressions": 0.03266666666666667}, "functorch/test_rearrange": {"TestRearrange": 4.653666666666667}, "functorch/test_vmap": {"TestRandomnessCPU": 125.10533333333335, "TestTransformFailureCPU": 0.061, "TestVmapAPI": 47.46266666666667, "TestVmapBatchedGradientCPU": 28.08033333333334, "TestVmapDeviceTypeCPU": 1.846, "TestVmapNestedTensorCPU": 2.921666666666667, "TestVmapOperators": 903.1479999999998, "TestVmapOperatorsOpInfoCPU": 28.18700000000005}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 13.274666666666583}, "higher_order_ops/test_with_effects": {"TestWithEffects": 8.607999999999999}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 18.726333333333333}, "inductor/test_binary_folding": {"FreezingCpuTests": 22.584500000000002}, "inductor/test_codecache": {"TestFxGraphCache": 19.49733333333333, "TestFxGraphCacheHashing": 0.6556666666666666, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.259}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 207.85500000000044, "TestCompiledAutograd": 32.334}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 185.22600000000017}, "inductor/test_config": {"TestInductorConfig": 3.8715}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 182.51399999999998, "TestCppWrapper": 183.64000000000004}, "inductor/test_cpu_repro": {"CPUReproTests": 308.44000000000005}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0026666666666666666}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 3.983333333333333}, "inductor/test_debug_trace": {"TestDebugTrace": 1.8966666666666667}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.001}, "inductor/test_extension_backend": {"ExtensionBackendTests": 3.310666666666666}, "inductor/test_foreach": {"ForeachTests": 11.49099999999999}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuTests": 41.594}, "inductor/test_fx_fusion": {"TestFxFusion": 1.4053333333333333}, "inductor/test_group_batch_fusion": {"TestGroupBatchFusion": 0.0, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.035, "TestIndexingSimplification": 0.5945}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 36.5525}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0003333333333333333}, "inductor/test_minifier": {"MinifierTests": 22.60766666666667}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 34.816}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 62.64000000000001, "TestPatternMatcher": 618.5070000000001}, "inductor/test_mmdecomp": {"TestDecompCPU": 27.706}, "inductor/test_profiler": {"DynamoProfilerTests": 0.002}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 7.108}, "inductor/test_torchinductor": {"CpuTests": 855.4629999999997, "SweepInputsCpuTest": 87.999, "TestFull": 9.3375}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 798.9309999999989}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 914.4166666666662, "TestInductorDynamicCPU": 21.616}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 2870.451999999997}, "lazy/test_debug_util": {"DebugUtilTest": 1.018}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 1.279}, "lazy/test_generator": {"LazyGeneratorTest": 1.0579999999999998}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 1.6299999999999997}, "lazy/test_step_closures": {"ClosuresTest": 3.0389999999999997}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.417, "TestLazyOpInfoCPU": 2.3196666666666617, "TestLazyTensor": 0.44166666666666665}, "nn/test_convolution": {"TestConvolutionNN": 20.407, "TestConvolutionNNDeviceTypeCPU": 116.09066666666666}, "nn/test_dropout": {"TestDropoutNN": 0.7703333333333333, "TestDropoutNNDeviceTypeCPU": 3.813333333333333}, "nn/test_embedding": {"TestEmbeddingNN": 3.640333333333333, "TestEmbeddingNNDeviceTypeCPU": 174.23899999999995}, "nn/test_init": {"TestNNInit": 1.7359999999999995}, "nn/test_lazy_modules": {"TestLazyModules": 9.746666666666664}, "nn/test_load_state_dict": {"TestLoadStateDict": 2.8593333333333333, "TestLoadStateDictSwap": 0.015333333333333332}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.39966666666666667, "TestModuleHookNN": 1.673, "TestModuleHooks": 10.534666666666666, "TestStateDictHooks": 1.1780000000000002}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 22.373, "TestMultiheadAttentionNNDeviceTypeCPU": 1.2866666666666666}, "nn/test_packed_sequence": {"PackedSequenceTest": 7.237666666666667}, "nn/test_parametrization": {"TestNNParametrization": 13.975666666666667, "TestNNParametrizationDeviceCPU": 0.07533333333333334}, "nn/test_pooling": {"TestAvgPool": 2.3496666666666663, "TestPoolingNN": 0.7253333333333334, "TestPoolingNNDeviceTypeCPU": 44.550000000000004}, "nn/test_pruning": {"TestPruningNN": 5.235666666666666}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.9783333333333334}, "profiler/test_memory_profiler": {"TestDataFlow": 0.0, "TestIdentifyGradients": 0.0003333333333333333, "TestMemoryProfiler": 0.001, "TestMemoryProfilerE2E": 0.001}, "profiler/test_profiler": {"TestExecutionTrace": 8.484666666666667, "TestExperimentalUtils": 36.94133333333333, "TestProfiler": 37.67166666666666, "TestProfilerCUDA": 0.0013333333333333333, "TestProfilerITT": 0.18433333333333332, "TestRecordFunction": 0.157, "TestTorchTidyProfiler": 11.886999999999995}, "profiler/test_profiler_tree": {"TestProfilerTree": 45.89066666666667}, "profiler/test_record_function": {"TestRecordFunction": 1.3296666666666666}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.843}, "test_ao_sparsity": {"TestActivationSparsifier": 0.010666666666666666, "TestBaseDataScheduler": 0.3793333333333333, "TestBaseDataSparsifier": 2.3396666666666666, "TestBaseSparsifier": 0.4376666666666667, "TestBaseStructuredSparsifier": 27.596, "TestComposability": 2.453333333333333, "TestCubicScheduler": 0.31866666666666665, "TestFPGMPruner": 0.7039999999999998, "TestFakeSparsity": 2.978666666666667, "TestFxComposability": 7.69, "TestNearlyDiagonalSparsifier": 15.453666666666665, "TestNormDataSparsifiers": 4.056666666666667, "TestQuantizationUtils": 0.22166666666666668, "TestQuantizedSparseKernels": 1.1123333333333334, "TestQuantizedSparseLayers": 0.021666666666666667, "TestSaliencyPruner": 0.29733333333333334, "TestScheduler": 0.5559999999999999, "TestSparsityUtilFunctions": 0.17733333333333334, "TestWeightNormSparsifier": 0.8093333333333333}, "test_autocast": {"TestAutocastCPU": 7.442333333333333, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.08833333333333333}, "test_autograd": {"TestAllowMutationOnSaved": 0.29000000000000004, "TestAutograd": 51.05933333333332, "TestAutogradComplex": 0.765, "TestAutogradDeviceTypeCPU": 6.768666666666667, "TestAutogradForwardMode": 1.8053333333333335, "TestAutogradForwardModeBatchedGrad": 0.367, "TestAutogradFunctional": 34.83899999999999, "TestAutogradInferenceMode": 0.6026666666666668, "TestAutogradLogging": 0.13933333333333334, "TestAutogradMultipleDispatchCPU": 0.7680000000000001, "TestMultithreadAutograd": 1.2106666666666666, "TestNestedCheckpoint": 2.064, "TestSelectiveActivationCheckpoint": 0.08733333333333336}, "test_autograd_fallback": {"TestAutogradFallback": 2.1426666666666656}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 527.0106666666582}, "test_bundled_inputs": {"TestBundledInputs": 2.7406666666666673}, "test_comparison_utils": {"TestComparisonUtils": 1.1376666666666668}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.6726666666666666}, "test_content_store": {"TestContentStoreCPU": 7.653333333333333}, "test_cpp_api_parity": {"TestCppApiParity": 86.16433333333362}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.5133333333333334, "TestMAIATensor": 0.3466666666666667, "TestORTTensor": 0.3183333333333334, "TestPybindTypeCasters": 0.067, "TestRNGExtension": 0.009, "TestTorchLibrary": 0.007333333333333333}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.5116666666666667, "TestMAIATensor": 0.34366666666666673, "TestORTTensor": 0.31900000000000006, "TestPybindTypeCasters": 0.06733333333333334, "TestRNGExtension": 0.008666666666666668, "TestTorchLibrary": 0.006999999999999999}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 28.948000000000004}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.3553333333333333}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 4.317666666666667}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.3483333333333334}, "test_custom_ops": {"MiniOpTest": 9.152666666666667, "MiniOpTestOther": 0.3956666666666668, "TestCustomOp": 10.834000000000001, "TestCustomOpAPI": 1.1980000000000002, "TestCustomOpTestingCPU": 2.6213333333333337, "TestGenerateOpcheckTests": 3.437333333333333}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 36.712666666666664, "TestConcatDataset": 0.17699999999999996, "TestConvAfterFork": 0.18566666666666667, "TestCustomPinFn": 0.018666666666666668, "TestDataLoader": 75.74900000000001, "TestDataLoaderDeviceTypeCPU": 0.03766666666666666, "TestDataLoaderPersistentWorkers": 106.457, "TestDatasetRandomSplit": 2.842333333333334, "TestDictDataLoader": 0.14933333333333335, "TestIndividualWorkerQueue": 0.009666666666666667, "TestNamedTupleDataLoader": 0.19433333333333336, "TestSetAffinity": 0.152, "TestStackDataset": 0.4973333333333334, "TestStringDataLoader": 0.008, "TestTensorDataset": 0.2973333333333334}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.04933333333333334, "TestDataChunk": 0.3133333333333334, "TestDataFramesPipes": 0.04033333333333333, "TestFunctionalIterDataPipe": 3.961, "TestFunctionalMapDataPipe": 1.0723333333333334, "TestGraph": 0.24233333333333332, "TestIterDataPipeCountSampleYielded": 0.050333333333333334, "TestIterDataPipeGraphFastForward": 1.2619999999999998, "TestIterDataPipeSingletonConstraint": 0.09733333333333333, "TestIterableDataPipeBasic": 0.4276666666666667, "TestSerialization": 6.695, "TestSharding": 0.44300000000000006, "TestStreamWrapper": 1.0856666666666666, "TestTyping": 0.062}, "test_decomp": {"DecompOneOffTestsCPU": 0.5273333333333333, "HasDecompTest": 0.24833333333333332, "TestDecompCPU": 16.307333333333926}, "test_deploy": {"TestFreezer": 0.93}, "test_dispatch": {"TestDispatch": 34.16166666666666, "TestPythonDispatcher": 0.07966666666666666}, "test_dlpack": {"TestTorchDlPackCPU": 6.503}, "test_dynamic_shapes": {"TestDimConstraints": 2.1853333333333333, "TestFloorDiv": 1.051, "TestGuardsExpressions": 0.25533333333333336, "TestPySymInt": 0.002, "TestSymNumberMagicMethods": 0.09333333333333334}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 7.062666666666669, "TestExpandedWeightHelperFunctionCPU": 0.773, "TestExpandedWeightModuleCPU": 17.05133333333333}, "test_fake_tensor": {"FakeTensorConstHandling": 0.24633333333333332, "FakeTensorConverterTest": 0.24000000000000007, "FakeTensorDispatchCache": 0.8119999999999999, "FakeTensorOpInfoTestCPU": 0.07833333333333335, "FakeTensorOperatorInvariants": 0.3233333333333334, "FakeTensorPropTest": 0.18366666666666664, "FakeTensorSerialization": 0.05000000000000001, "FakeTensorTest": 2.899999999999999, "PropagateRealTensorsFakeTensorConstHandling": 0.07, "PropagateRealTensorsFakeTensorConverterTest": 0.07266666666666667, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.07700000000000001, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.08966666666666669, "PropagateRealTensorsFakeTensorPropTest": 0.028999999999999998, "PropagateRealTensorsFakeTensorTest": 0.37133333333333357}, "test_flop_counter": {"TestFlopCounter": 0.006000000000000001}, "test_foreach": {"TestForeachCPU": 27.71699999999979}, "test_function_schema": {"TestFunctionSchema": 1.6323333333333332}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 34.845}, "test_functional_optim": {"TestFunctionalOptimParity": 2.007}, "test_functionalization": {"TestCrossRefFunctionalization": 0.0016666666666666668, "TestFunctionalization": 0.002}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.16066666666666665}, "test_futures": {"TestFuture": 3.2983333333333325}, "test_fx": {"AnnotationsTest": 0.05566666666666666, "TestCSEPass": 1.937, "TestCommonPass": 0.424, "TestConstFold": 1.5026666666666666, "TestConstParamShapeInControlFlow": 1.8660000000000003, "TestDCE": 0.27299999999999996, "TestFX": 129.71900000000002, "TestFXAPIBackwardCompatibility": 3.2433333333333327, "TestFunctionalTracing": 71.72433333333328, "TestMatcher": 0.7033333333333335, "TestOperatorSignaturesCPU": 13.629999999999905, "TestPassManager": 0.3016666666666667, "TestSourceMatcher": 1.418, "TestSubgraphRewriter": 1.0906666666666667, "TestVisionTracing": 0.0036666666666666666, "TypeCheckerTest": 5.233999999999999}, "test_fx_experimental": {"TestFXExperimental": 251.13400000000001, "TestNormalizeOperatorsCPU": 5.772999999999993, "TestTranslationValidation": 0.28400000000000003}, "test_fx_passes": {"TestFXGraphPasses": 6.420333333333332, "TestFXMatcherUtils": 0.2246666666666667}, "test_fx_reinplace_pass": {"TestReinplacePass": 2.4323333333333337}, "test_import_stats": {"TestImportTime": 4.657333333333333}, "test_indexing": {"NumpyTestsCPU": 1.2496666666666665, "TestIndexingCPU": 56.19733333333335}, "test_itt": {"TestItt": 1.044}, "test_jit": {"TestAliasAnalysis": 0.4143333333333333, "TestAsync": 1.7329999999999999, "TestAtenPow": 2.2883333333333336, "TestAutodiffJit": 0.04066666666666666, "TestAutodiffSubgraphSlicing": 1.765, "TestAwait": 1.7126666666666666, "TestBackends": 13.982666666666667, "TestBackendsWithCompiler": 6.354333333333333, "TestBatchMM": 0.8069999999999998, "TestBuiltins": 0.23766666666666666, "TestClassType": 1.9509999999999996, "TestComplex": 1.8696666666666666, "TestCustomOperators": 0.5516666666666666, "TestDCE": 0.04766666666666666, "TestDataParallel": 0.035666666666666666, "TestDataclasses": 9.491666666666665, "TestDeviceAnalysis": 6.009333333333333, "TestDict": 0.2303333333333335, "TestDtypeAnalysis": 4.5456666666666665, "TestDtypeCustomRulesCPU": 5.092999999999998, "TestEnum": 0.313, "TestFreezing": 0.4103333333333336, "TestFrontend": 0.11699999999999999, "TestFrozenOptimizations": 0.24400000000000013, "TestFunctionalBlocks": 0.23099999999999998, "TestFunctionalToInplaceActivation": 6.007666666666666, "TestGenerator": 0.4726666666666666, "TestGetDefaultAttr": 0.08, "TestGraphRewritePasses": 0.06, "TestHash": 0.3023333333333334, "TestHooks": 1.9100000000000001, "TestIgnorableArgs": 0.04733333333333334, "TestIgnoreContextManager": 0.12133333333333333, "TestInplaceToFunctionalActivation": 4.8020000000000005, "TestIsinstance": 0.9746666666666671, "TestJit": 15.515999999999991, "TestJitGeneratedModule": 37.89133333333331, "TestJitProfiler": 0.4106666666666667, "TestJitUtils": 0.272, "TestList": 5.660999999999998, "TestLogging": 0.256, "TestMKLDNNReinplacing": 0.028, "TestMisc": 1.3453333333333335, "TestMixTracingScripting": 0.15366666666666676, "TestModels": 3.914333333333333, "TestModuleAPIs": 0.17066666666666666, "TestModuleContainers": 2.845, "TestModuleInterface": 0.7503333333333334, "TestModules": 0.03, "TestNamedTuple": 0.2226666666666667, "TestNnapiBackend": 0.29833333333333345, "TestOpDecompositions": 0.2313333333333333, "TestOptimizeForMobilePreserveDebugInfo": 0.31300000000000006, "TestParametrization": 0.6, "TestPeephole": 4.368666666666666, "TestProducerVersion": 0.015, "TestProfiler": 0.08400000000000002, "TestPythonBindings": 0.7253333333333334, "TestPythonBuiltinOP": 3.628, "TestPythonIr": 0.26599999999999996, "TestRecursiveScript": 1.8233333333333333, "TestRemoveMutation": 2.2086666666666663, "TestSaveLoad": 0.5940000000000002, "TestSaveLoadFlatbuffer": 0.3623333333333334, "TestSaveLoadForOpVersion": 2.2176666666666662, "TestScript": 47.93266666666668, "TestScriptDict": 0.38899999999999996, "TestScriptList": 1.302, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.3703333333333334, "TestScriptProfile": 19.401, "TestSlice": 0.524, "TestSparse": 0.15733333333333333, "TestStringFormatting": 0.39600000000000013, "TestSymbolicShapeAnalysis": 19.617333333333338, "TestTensorBuiltins": 0.48000000000000004, "TestTensorCreationOps": 0.18533333333333335, "TestTensorMethods": 0.10099999999999999, "TestTorchbind": 0.2213333333333334, "TestTracer": 1.0420000000000003, "TestTypeSharing": 1.106666666666667, "TestTypesAndAnnotation": 0.48600000000000004, "TestTyping": 1.7049999999999998, "TestUnion": 2.0909999999999997, "TestUnsupportedOps": 0.1466666666666667, "TestUpgraders": 1.2453333333333336, "TestWarn": 0.2786666666666667, "TestWith": 0.6930000000000001}, "test_jit_autocast": {"TestAutocast": 0.005666666666666667, "TestJitTraceAutocast": 0.001}, "test_jit_disabled": {"TestJitDisabled": 1.0519999999999998}, "test_jit_fuser_te": {"TestFuserCommon": 0.224, "TestLoopnestRandomizationCPU": 0.8036666666666665, "TestNNCOpInfoCPU": 55.672333333336724, "TestTEFuserDynamic": 156.34233333333336, "TestTEFuserStatic": 114.11066666666669}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.9123333333333333, "TestFusionPatternCPU": 10.524333333333333, "TestModel": 5.482666666666668, "TestOpCPU": 34.168000000000006}, "test_legacy_vmap": {"TestVmapAPI": 1.1806666666666652, "TestVmapAPILegacy": 7.938666666666666, "TestVmapBatchedGradientCPU": 0.07800000000000003, "TestVmapBatchedGradientLegacyCPU": 14.985, "TestVmapOperators": 0.9663333333333335, "TestVmapOperatorsLegacy": 91.57400000000001}, "test_license": {"TestLicense": 0.9333333333333335}, "test_linalg": {"TestLinalgCPU": 1206.7619999999997}, "test_logging": {"LoggingTest": 2.8943333333333334}, "test_masked": {"TestMaskedCPU": 34.29600000000007}, "test_maskedtensor": {"TestBasicsCPU": 7.161666666666666, "TestBinary": 6.7860000000000005, "TestOperatorsCPU": 7.173999999999975, "TestReductions": 5.356000000000001, "TestUnary": 14.853666666666667}, "test_meta": {"TestMetaCPU": 77.45966666665485, "TestMetaConverter": 1.8523333333333334}, "test_mkl_verbose": {"TestMKLVerbose": 4.5393333333333326}, "test_mkldnn": {"TestMkldnnCPU": 122.18900000000001}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0013333333333333333}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.34}, "test_mobile_optimizer": {"TestOptimizer": 4.859666666666667}, "test_model_dump": {"TestModelDump": 3.0820000000000003}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.9329999999999999}, "test_module_init": {"TestModuleInitCPU": 449.2890000000004}, "test_module_tracker": {"TestModuleTracker": 1.265}, "test_modules": {"TestModuleCPU": 29.635666666667102}, "test_monitor": {"TestMonitor": 1.1300000000000001, "TestMonitorTensorboard": 0.0003333333333333333}, "test_multiprocessing": {"TestMultiprocessing": 25.036666666666672}, "test_multiprocessing_spawn": {"ErrorTest": 0.024333333333333335, "ForkTest": 0.8546666666666667, "SpawnTest": 26.457666666666665}, "test_namedtensor": {"TestNamedTensor": 6.349999999999999}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.895}, "test_native_functions": {"TestNativeFunctions": 1.995}, "test_native_mha": {"TestMHADeviceTypeCPU": 14.907333333333332}, "test_nestedtensor": {"TestNestedTensor": 2.396333333333333, "TestNestedTensorAutogradCPU": 4.283666666666666, "TestNestedTensorDeviceTypeCPU": 9.578000000000001, "TestNestedTensorSubclassCPU": 38.84666666666667}, "test_nn": {"TestAddRelu": 0.08533333333333333, "TestConstantPadNd": 0.08266666666666667, "TestFunctionalPickle": 0.016333333333333335, "TestFusionEval": 0.9359999999999999, "TestFusionUtils": 0.2976666666666667, "TestNN": 115.15166666666664, "TestNNDeviceTypeCPU": 442.887, "TestUtils": 0.020666666666666667}, "test_numba_integration": {"TestNumbaIntegration": 0.18866666666666673}, "test_numpy_interop": {"TestNumPyInteropCPU": 7.286999999999999}, "test_openmp": {"TestOpenMP_ParallelFor": 8.281333333333334}, "test_ops": {"TestCommonCPU": 41.78066666667233, "TestCompositeComplianceCPU": 6.001999999999668, "TestFakeTensorCPU": 3.302666666666418, "TestMathBitsCPU": 3.7336666666664677, "TestRefsOpsInfoCPU": 1.6533333333333198, "TestSelfKwarg": 0.16666666666666666, "TestTagsCPU": 1.753999999999988}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 6.17066666666636}, "test_ops_gradients": {"TestBwdGradientsCPU": 10.062333333333266}, "test_ops_jit": {"TestJitCPU": 2.0826666666666322}, "test_optim": {"TestDifferentiableOptimizer": 0.07166666666666667, "TestLRScheduler": 10.586999999999996, "TestOptim": 0.13199999999999995, "TestOptimRenewedCPU": 326.07433333333296, "TestSWAUtils": 4.276}, "test_out_dtype_op": {"TestOutDtypeOp": 0.8173333333333335}, "test_overrides": {"TestBroadcastAllOverride": 0.2833333333333334, "TestDisabledTorchFunction": 0.011333333333333334, "TestDisabledUserWarnings": 0.017666666666666667, "TestEinsumOverride": 0.4643333333333333, "TestGradCheckOverride": 0.36366666666666664, "TestGradNewOnesOverride": 0.009333333333333332, "TestIndexing": 0.06266666666666666, "TestIterator": 0.01, "TestNamedTuple": 0.009666666666666665, "TestPickle": 0.01, "TestRNN": 0.05366666666666667, "TestResolveName": 0.18866666666666668, "TestTorchFunctionMode": 0.32533333333333336, "TestTorchFunctionOverride": 261.2713333333291, "TestTorchFunctionWarning": 0.027, "TestWrapTorchFunction": 0.009666666666666665}, "test_package": {"DirectoryReaderTest": 4.558333333333333, "ModelTest": 0.021, "TestAnalyze": 1.079, "TestDependencyAPI": 11.053999999999997, "TestDependencyHooks": 3.1910000000000003, "TestDiGraph": 7.586333333333333, "TestGlobGroup": 9.421000000000001, "TestImporter": 4.119666666666666, "TestLoadBCPackages": 2.1183333333333336, "TestMangling": 6.962, "TestMisc": 7.579666666666667, "TestPackageFX": 4.653333333333333, "TestPackageScript": 22.87766666666667, "TestRepackage": 0.9646666666666667, "TestResources": 2.9473333333333334, "TestSaveLoad": 7.940666666666668}, "test_per_overload_api": {"TestPerOverloadAPI": 1.4509999999999998}, "test_prims": {"TestDecompCPU": 0.017333333333333336, "TestPrimsBasic": 0.41900000000000004, "TestPrimsCPU": 0.403, "TestRefsCPU": 0.20566666666666666}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.38199999999999995, "TestGenericProxyTensorFake": 11.058666666666667, "TestGenericProxyTensorReal": 12.757, "TestGenericProxyTensorSymbolic": 28.589000000000002, "TestProxyTensorOpInfoCPU": 27.65666666666642, "TestRealProxyTensor": 0.020666666666666667, "TestSymbolicTracing": 8.530333333333331}, "test_pruning_op": {"PruningOpTest": 1.0713333333333332}, "test_public_bindings": {"TestPublicBindings": 1.732}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.3156666666666667, "TestPythonDispatch": 4.445666666666664, "TestPythonDispatcher": 0.09933333333333334, "TestPythonRegistration": 2.1763333333333335, "TestWrapperSubclassAliasingCPU": 0.4786666666666668}, "test_pytree": {"TestCxxPytree": 1.0956666666666663, "TestGenericPytree": 4.129666666666666, "TestPythonPytree": 3.077}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.09466666666666668, "TestAOMigrationNNQuantized": 0.1626666666666667, "TestAOMigrationQuantization": 0.133, "TestAOMigrationQuantizationFx": 0.10533333333333332, "TestBackendConfig": 2.3286666666666664, "TestBiasCorrectionEager": 2.861666666666667, "TestBitsCPU": 0.23166666666666666, "TestComparatorOps": 3.095333333333333, "TestDeprecatedJitQuantized": 4.958333333333333, "TestDistributed": 0.7246666666666668, "TestDuplicateDQPass": 7.458000000000001, "TestDynamicQuantizedModule": 55.16233333333333, "TestDynamicQuantizedOps": 37.889, "TestEqualizeEager": 2.0256666666666665, "TestEqualizeFx": 33.69766666666667, "TestFXGraphMatcher": 4.160666666666667, "TestFXGraphMatcherModels": 6.691, "TestFXNumericSuiteCoreAPIs": 54.973000000000006, "TestFXNumericSuiteCoreAPIsModels": 31.627, "TestFXNumericSuiteNShadows": 42.239666666666665, "TestFakeQuantize": 4.709, "TestFakeQuantizeOps": 18.706999999999997, "TestFloat8DtypeCPU": 3.106333333333333, "TestFloat8DtypeCPUOnlyCPU": 0.35200000000000004, "TestFuseEager": 12.747333333333335, "TestFuseFx": 5.127666666666666, "TestFusedObsFakeQuant": 1.416666666666667, "TestFusedObsFakeQuantModule": 1.0646666666666667, "TestFusionPasses": 0.039, "TestFxDetectInputWeightEqualization": 1.461, "TestFxDetectOutliers": 2.2676666666666665, "TestFxModelReportClass": 4.888, "TestFxModelReportDetectDynamicStatic": 0.4206666666666667, "TestFxModelReportDetector": 2.4299999999999997, "TestFxModelReportObserver": 2.384333333333333, "TestFxModelReportVisualizer": 4.860333333333333, "TestGenerateNumericDebugHandle": 0.43566666666666665, "TestGraphUtils": 1.8136666666666665, "TestHistogramObserver": 26.982333333333333, "TestMetaDataPorting": 11.939666666666666, "TestModelNumericsEager": 2.355, "TestNumericSuiteEager": 35.683, "TestObserver": 4.630999999999999, "TestPT2ERepresentation": 1.5170000000000001, "TestPadding": 19.244666666666667, "TestQNNPackOps": 7.212666666666666, "TestQuantizationDocs": 0.05466666666666666, "TestQuantizeDynamicJitOps": 2.6696666666666666, "TestQuantizeDynamicJitPasses": 6.1610000000000005, "TestQuantizeEagerOps": 7.746333333333332, "TestQuantizeEagerPTQDynamic": 15.606666666666664, "TestQuantizeEagerPTQStatic": 39.06333333333333, "TestQuantizeEagerQAT": 35.690666666666665, "TestQuantizeEagerQATNumerics": 37.09733333333333, "TestQuantizeFx": 112.84900000000003, "TestQuantizeFxModels": 18.61466666666667, "TestQuantizeFxOps": 257.627, "TestQuantizeJit": 26.629999999999995, "TestQuantizeJitOps": 234.92566666666664, "TestQuantizeJitPasses": 11.148000000000001, "TestQuantizePT2E": 42.12766666666667, "TestQuantizePT2EQATModels": 2.457666666666667, "TestQuantizePT2EQAT_ConvBn1d": 41.833, "TestQuantizePT2EQAT_ConvBn2d": 41.81033333333333, "TestQuantizePT2EX86Inductor": 67.69366666666667, "TestQuantizedConv": 83.30733333333332, "TestQuantizedEmbeddingOps": 9.841333333333333, "TestQuantizedFunctionalOps": 3.4019999999999997, "TestQuantizedLinear": 35.083, "TestQuantizedOps": 184.16099999999997, "TestQuantizedTensor": 59.07033333333334, "TestRecordHistogramObserver": 0.12766666666666668, "TestReferenceQuantizedModule": 0.9086666666666666, "TestSerialization": 6.254666666666666, "TestStaticQuantizedModule": 150.84833333333333, "TestSubgraphRewriter": 1.968333333333333, "TestUtils": 0.9606666666666667, "TestXNNPACKQuantizer": 22.900333333333332, "TestXNNPACKQuantizerModels": 2.2923333333333336}, "test_reductions": {"TestReductionsCPU": 397.50000000001836}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 127.84033333333332}, "test_schema_check": {"TestSchemaCheck": 0.6353333333333335, "TestSchemaCheckModeOpInfoCPU": 52.55966666666825}, "test_segment_reductions": {"TestSegmentReductionsCPU": 20.90233333333333}, "test_serialization": {"TestBothSerializationCPU": 0.163, "TestOldSerialization": 31.25066666666667, "TestSerialization": 19.563666666666663, "TestSubclassSerialization": 0.37833333333333335}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.9466666666666667}, "test_shape_ops": {"TestShapeOpsCPU": 12.898666666666669}, "test_show_pickle": {"TestShowPickle": 0.9170000000000001}, "test_sort_and_select": {"TestSortAndSelectCPU": 31.36499999999999}, "test_sparse": {"TestSparseAnyCPU": 363.5536666666679, "TestSparseCPU": 438.338, "TestSparseLegacyAndDeprecation": 0.30433333333333334, "TestSparseMaskedReductionsCPU": 0.3536666666666668, "TestSparseMeta": 39.88766666666667, "TestSparseOneOff": 0.305, "TestSparseUnaryUfuncsCPU": 11.123666666666637}, "test_sparse_csr": {"TestSparseCSRCPU": 147.4610000000073, "TestSparseCSRSampler": 0.6073333333333334, "TestSparseCompressedCPU": 117.12766666666637, "TestSparseCompressedTritonKernelsCPU": 0.066}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.1536666666666667}, "test_spectral_ops": {"TestFFTCPU": 25.037333333333468, "TestFFTDocExamplesCPU": 0.39833333333333343}, "test_stateless": {"TestPythonOptimizeMode": 3.605, "TestStatelessDeprecation": 1.793, "TestStatelessFunctionalAPI": 8.299999999999999}, "test_subclass": {"TestSubclass": 3.6543333333333337}, "test_sympy_utils": {"TestNumbers": 0.29833333333333334, "TestSingletonInt": 0.022000000000000002, "TestSympyInterp": 27.69033333333334, "TestSympySolve": 0.7516666666666668, "TestValueRanges": 8.278666666666664}, "test_tensor_creation_ops": {"TestAsArrayCPU": 63.13366666666665, "TestBufferProtocolCPU": 32.254333333333335, "TestLikeTensorCreationCPU": 0.213, "TestRandomTensorCreationCPU": 13.329666666666663, "TestTensorCreationCPU": 43.232000000000006}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.39333333333333337, "TestTensorBoardFigure": 0.013999999999999999, "TestTensorBoardNumpy": 0.044333333333333336, "TestTensorBoardPyTorchNumpy": 1.053, "TestTensorBoardPytorchGraph": 28.086000000000002, "TestTensorBoardSummary": 1.418, "TestTensorBoardSummaryWriter": 0.03366666666666667, "TestTensorBoardUtils": 0.4403333333333333, "TestTensorBoardWriter": 0.40199999999999997, "TestTensorProtoSummary": 0.21533333333333335}, "test_tensorexpr": {"TestTensorExprFuser": 0.0026666666666666666}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.08, "TestTensorExprPyBind": 3.4126666666666665}, "test_testing": {"TestAssertClose": 1.2403333333333333, "TestAssertCloseContainer": 0.10633333333333335, "TestAssertCloseErrorMessage": 0.3203333333333334, "TestAssertCloseQuantized": 0.13333333333333333, "TestAssertCloseSparseBSC": 0.09600000000000002, "TestAssertCloseSparseBSR": 0.09766666666666668, "TestAssertCloseSparseCOO": 0.35033333333333333, "TestAssertCloseSparseCSC": 0.10999999999999999, "TestAssertCloseSparseCSR": 0.12966666666666668, "TestFrameworkUtils": 12.047666666666666, "TestImports": 15.089666666666666, "TestMakeTensorCPU": 48.20733333333328, "TestOpInfoSampleFunctionsCPU": 11.462999999999846, "TestOpInfos": 0.02666666666666667, "TestTestParametrization": 0.18166666666666673, "TestTestParametrizationDeviceTypeCPU": 4.151000000000001, "TestTestingCPU": 1.4330000000000005}, "test_torch": {"TestBasicVitalSigns": 0.19333333333333336, "TestTorch": 24.34800000000001, "TestTorchDeviceTypeCPU": 136.3813333333334, "TestVitalSignsCudaCPU": 0.008}, "test_transformers": {"TestAttnBiasCPU": 14.269666666666666, "TestAttnMasksCPU": 0.2043333333333334, "TestSDPACPU": 508.828, "TestSDPAFailureModesCPU": 0.4146666666666667, "TestTransformersCPU": 109.51166666666667}, "test_type_hints": {"TestTypeHints": 0.9546666666666667}, "test_type_info": {"TestDTypeInfo": 1.5546666666666666}, "test_type_promotion": {"TestTypePromotionCPU": 49.843000000000025}, "test_typing": {"TestTyping": 76.12466666666667}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 219.19600000002882}, "test_utils": {"TestAssert": 0.08700000000000001, "TestBottleneck": 8.062, "TestCheckpoint": 1.7449999999999999, "TestCollectEnv": 0.9713333333333333, "TestCppExtensionUtils": 0.18299999999999997, "TestDataLoaderUtils": 2.5606666666666666, "TestDeviceUtilsCPU": 41.859666666666676, "TestExtensionUtils": 0.07400000000000001, "TestHipify": 0.006333333333333334, "TestHipifyTrie": 0.09966666666666667, "TestONNXUtils": 0.017333333333333336, "TestRenderUtils": 0.06133333333333333, "TestStandaloneCPPJIT": 2.6940000000000004, "TestTraceback": 0.03933333333333333}, "test_view_ops": {"TestOldViewOpsCPU": 24.580333333333346, "TestViewOpsCPU": 16.029333333333327, "TestViewOpsLAZY": 3.7236666666666642}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.12566666666666668, "WeakKeyDictionaryTestCase": 0.19866666666666669, "WeakTest": 6.419666666666665}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 31.600333333333335, "TestXNNPACKOps": 9.297999999999996, "TestXNNPACKRewritePass": 1.8966666666666665, "TestXNNPACKSerDes": 5.251}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0023333333333333335}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 1.3243333333333311, "TestClassGetItem": 0.0016666666666666668, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.016666666666666666, "TestMisc": 0.030666666666666665, "TestPickling": 0.25766666666666677, "TestPromotion": 0.0013333333333333333}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 24.941999999999997, "TestEinsumPath": 0.0, "TestMisc": 0.07766666666666666}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.14600000000000002, "TestHalf": 0.0003333333333333333, "TestIinfo": 0.8936666666666667, "TestMisc": 0.029666666666666664, "TestPythonFloat": 0.001, "TestRepr": 0.021666666666666667, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.045000000000000005, "TestBooleanIndexing": 0.09633333333333334, "TestBroadcastedAssignments": 0.19933333333333336, "TestFancyIndexingCast": 0.10133333333333334, "TestFloatNonIntegerArgument": 0.11333333333333334, "TestIndexing": 2.6686666666666654, "TestMultiIndexingAutomated": 0.083, "TestMultipleEllipsisError": 0.029666666666666664, "TestNonIntegerArrayLike": 0.007}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.17133333333333334, "TestArgmax": 2.1046666666666662, "TestArgmaxArgminCommon": 1.5393333333333326, "TestArgmin": 1.9569999999999999, "TestArrayAttributeDeletion": 0.09566666666666668, "TestArrayConstruction": 0.5123333333333333, "TestArrayCreationCopyArgument": 0.18666666666666668, "TestArrayInterface": 0.015333333333333338, "TestAssignment": 0.12000000000000004, "TestAttributes": 0.30866666666666664, "TestBinop": 0.18233333333333332, "TestBool": 0.38900000000000007, "TestCequenceMethods": 0.015, "TestChoose": 0.2816666666666667, "TestClip": 0.10533333333333333, "TestCompress": 0.10266666666666667, "TestConversion": 0.045000000000000005, "TestCreation": 0.006666666666666668, "TestDelMisc": 0.009666666666666665, "TestDot": 0.7336666666666668, "TestDtypedescr": 0.013333333333333334, "TestFancyIndexing": 0.3463333333333333, "TestFlag": 0.37100000000000005, "TestFormat": 0.08033333333333333, "TestFromBuffer": 0.12, "TestHash": 0.8443333333333333, "TestHashing": 0.043666666666666666, "TestIO": 0.005, "TestInner": 0.09733333333333334, "TestLexsort": 0.548, "TestMatmul": 2.230333333333333, "TestMatmulOperator": 0.341, "TestMethods": 7.439333333333333, "TestMinMax": 0.025666666666666667, "TestMinScalarType": 0.063, "TestNewaxis": 0.03133333333333333, "TestPEP3118Dtype": 0.001, "TestPutmask": 0.49866666666666676, "TestRepeat": 0.16266666666666665, "TestResize": 0.267, "TestRichcompareScalar": 0.007666666666666666, "TestScalarIndexing": 0.296, "TestSizeOf": 0.13333333333333333, "TestSortFloatMisc": 3.7266666666666666, "TestStats": 1.705, "TestSubscripting": 0.043000000000000003, "TestTake": 0.4563333333333334, "TestVdot": 0.1386666666666667, "TestViewDtype": 0.05833333333333333, "TestWarnings": 0.031, "TestWhere": 0.4003333333333334, "TestWritebackIfCopy": 0.26333333333333336}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.45366666666666666, "TestArgwhere": 0.5790000000000001, "TestArrayComparisons": 1.4399999999999997, "TestBaseRepr": 0.143, "TestBinaryRepr": 0.19433333333333333, "TestBoolArray": 3.0110000000000006, "TestBoolCmp": 2.4556666666666667, "TestBoolScalar": 0.648, "TestBroadcast": 0.35433333333333333, "TestClip": 2.4163333333333328, "TestConvolve": 0.24833333333333338, "TestCorrelate": 0.4670000000000001, "TestCreationFuncs": 0.21966666666666668, "TestCross": 0.6189999999999999, "TestDtypePositional": 0.02033333333333333, "TestFloatExceptions": 0.25066666666666665, "TestFromiter": 0.0016666666666666668, "TestIndex": 0.16033333333333333, "TestIndices": 0.3416666666666666, "TestIsclose": 1.2283333333333335, "TestIsscalar": 0.042666666666666665, "TestLikeFuncs": 0.0013333333333333333, "TestMoveaxis": 0.057666666666666665, "TestNonarrayArgs": 0.9893333333333335, "TestNonzeroAndCountNonzero": 1.2369999999999999, "TestOuterMisc": 0.16033333333333333, "TestRequire": 0.04733333333333334, "TestResize": 1.446, "TestRoll": 0.576, "TestRollaxis": 0.051666666666666666, "TestSeterr": 0.17400000000000002, "TestStdVar": 3.608333333333333, "TestStdVarComplex": 0.07366666666666667, "TestStringFunction": 0.12766666666666668, "TestTensordot": 0.09499999999999999, "TestTypes": 0.5106666666666667}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.020666666666666667, "TestCommonType": 1.2049999999999998, "TestDocStrings": 0.0003333333333333333, "TestIsSubDType": 0.083, "TestScalarTypeNames": 0.31366666666666676}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 1.3103333333333331, "TestFromInt": 0.04766666666666667, "TestFromString": 1.1139999999999999}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0023333333333333335, "TestBitCount": 0.0013333333333333333, "TestClassGetItem": 0.001, "TestClassGetitemMisc": 1.1416666666666666, "TestIsInteger": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0016666666666666668}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 1.1313333333333333, "TestBaseMath": 0.3446666666666667, "TestBitShifts": 0.43233333333333346, "TestComplexDivision": 0.02666666666666666, "TestConversion": 0.10200000000000002, "TestHash": 0.0013333333333333333, "TestModulus": 0.47500000000000003, "TestMultiply": 0.0, "TestNegative": 0.031, "TestPower": 0.06766666666666667, "TestRepr": 0.024999999999999998, "TestScalarOpsMisc": 1.5683333333333325, "TestScalarSubclassingMisc": 0.5503333333333337, "TestSubtract": 0.033, "TestTypes": 1.083}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 1.1596666666666666, "TestAtleast2d": 0.12366666666666666, "TestAtleast3d": 0.121, "TestBlock": 0.16933333333333342, "TestConcatenate": 1.9649999999999999, "TestHstack": 0.271, "TestStackMisc": 0.14700000000000005, "TestVstack": 0.17700000000000005}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007666666666666666, "TestFFTShift": 1.514, "TestIRFFTN": 0.03166666666666667, "TestRFFTFreq": 0.007666666666666666}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 46.925333333333334, "TestFFTShift": 0.9939999999999999, "TestFFTThreadSafe": 1.1449999999999998}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 1.5103333333333335}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.007666666666666666, "TestUnique": 3.7513333333333336}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.024333333333333335, "TestAmax": 0.05566666666666667, "TestAmin": 0.056666666666666664, "TestAngle": 0.155, "TestAny": 0.09000000000000001, "TestAverage": 0.3423333333333334, "TestBincount": 0.5136666666666667, "TestCheckFinite": 0.06966666666666665, "TestCopy": 0.06166666666666667, "TestCorrCoef": 0.488, "TestCov": 0.6706666666666669, "TestCumprod": 0.020666666666666667, "TestCumsum": 0.028666666666666663, "TestDelete": 1.128, "TestDiff": 0.8193333333333334, "TestDigitize": 0.5623333333333332, "TestExtins": 0.26433333333333336, "TestFilterwindows": 3.61533333333333, "TestFlip": 0.19033333333333333, "TestGradient": 1.3266666666666664, "TestInsert": 1.6923333333333332, "TestInterp": 8.305333333333335, "TestKaiser": 0.08700000000000001, "TestMedian": 2.9619999999999997, "TestMeshgrid": 0.5783333333333333, "TestMsort": 0.0, "TestPercentile": 3.0473333333333286, "TestPiecewise": 0.08600000000000001, "TestProd": 0.021666666666666667, "TestPtp": 0.10566666666666667, "TestQuantile": 0.34666666666666673, "TestRot90": 1.167, "TestSelect": 0.06366666666666666, "TestSinc": 0.08733333333333333, "TestSortComplex": 0.2733333333333334, "TestTrapz": 0.7530000000000001, "TestTrimZeros": 0.15333333333333332, "TestUnique": 0.12266666666666666, "Test_I0": 0.12566666666666668}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 3.164333333333333, "TestHistogramOptimBinNums": 1.3023333333333331, "TestHistogramdd": 1.5383333333333333}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.028999999999999998, "TestConcatenator": 0.05200000000000001, "TestDiagIndices": 0.050333333333333334, "TestDiagIndicesFrom": 0.06066666666666667, "TestFillDiagonal": 0.18466666666666667, "TestGrid": 0.08900000000000001, "TestIndexExpression": 0.15100000000000002, "TestIx_": 0.052, "TestNdIndex": 0.008, "TestNdenumerate": 0.009666666666666665, "TestRavelUnravelIndex": 1.6666666666666667}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.4623333333333333, "TestApplyOverAxes": 0.009666666666666665, "TestArraySplit": 0.7953333333333336, "TestColumnStack": 0.07433333333333332, "TestDsplit": 0.082, "TestDstack": 0.13266666666666668, "TestExpandDims": 0.056, "TestHsplit": 0.083, "TestKron": 0.21033333333333337, "TestMayShareMemory": 0.17766666666666667, "TestPutAlongAxis": 0.09033333333333333, "TestSplit": 0.03866666666666666, "TestSqueeze": 0.3106666666666667, "TestTakeAlongAxis": 1.2579999999999998, "TestTile": 0.17200000000000001, "TestVsplit": 0.06433333333333334}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.506, "TestEye": 1.4493333333333334, "TestFliplr": 0.014, "TestFlipud": 0.041, "TestHistogram2d": 0.4716666666666667, "TestTri": 0.26066666666666666, "TestTrilIndicesFrom": 0.017333333333333336, "TestTriuIndices": 0.07466666666666666, "TestTriuIndicesFrom": 0.016, "TestVander": 0.11166666666666665}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.009666666666666665, "TestCommonType": 1.2700000000000002, "TestImag": 0.161, "TestIscomplex": 0.05566666666666666, "TestIscomplexobj": 0.133, "TestIsfinite": 0.3276666666666667, "TestIsinf": 0.296, "TestIsnan": 0.318, "TestIsneginf": 0.07633333333333332, "TestIsposinf": 0.07533333333333334, "TestIsreal": 0.07533333333333334, "TestIsrealobj": 0.051, "TestIsscalar": 0.07866666666666666, "TestMintypecode": 0.02866666666666667, "TestNanToNum": 0.37666666666666665, "TestReal": 0.145, "TestRealIfClose": 0.15433333333333335}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 1.7216666666666665, "TestCond": 2.2046666666666663, "TestDet": 0.3016666666666667, "TestEig": 0.4363333333333334, "TestEigh": 0.25866666666666666, "TestEighCases": 0.0, "TestEigvals": 0.48200000000000004, "TestEigvalsh": 0.27233333333333337, "TestEigvalshCases": 0.0, "TestInv": 0.47633333333333344, "TestLstsq": 3.2099999999999995, "TestMatrixRank": 0.371, "TestMisc": 0.14966666666666667, "TestMisc2": 0.046000000000000006, "TestMultiDot": 0.5363333333333334, "TestNormDouble": 1.4400000000000002, "TestNormInt64": 1.6026666666666667, "TestNormSingle": 1.7449999999999999, "TestNorm_NonSystematic": 0.02466666666666667, "TestPinv": 1.1673333333333333, "TestPinvHermitian": 0.27699999999999997, "TestQR": 0.6386666666666669, "TestSVD": 0.5273333333333334, "TestSVDHermitian": 0.47766666666666674, "TestSolve": 1.868666666666667, "TestTensorinv": 0.17466666666666666, "TestTensorsolve": 0.073}, "torch_np/test_basic": {"TestArrayToSequence": 0.10099999999999999, "TestCopyTo": 0.10066666666666667, "TestCtorNested": 0.029666666666666664, "TestDefaultDtype": 0.04766666666666667, "TestDivmod": 0.18333333333333335, "TestExport": 0.0003333333333333333, "TestMisc": 0.033, "TestNormalizations": 0.06533333333333334, "TestOneArr": 4.581333333333324, "TestOneArrAndAxesTuple": 0.213, "TestOneArrAndAxis": 2.88233333333333, "TestOneArrAndShape": 0.4050000000000001, "TestOneArrToScalar": 0.26299999999999996, "TestPythonArgsToArray": 0.15033333333333335, "TestSequenceOfArrays": 0.40566666666666684, "TestSequenceOfArraysToSingle": 0.20866666666666667, "TestShapeLikeToArray": 0.077, "TestSmokeNotImpl": 0.014666666666666666}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 2.1509999999999985}, "torch_np/test_dtype": {"TestConvertDType": 1.695999999999998}, "torch_np/test_function_base": {"TestAppend": 0.9569999999999999}, "torch_np/test_ndarray_methods": {"TestAmax": 0.066, "TestAmin": 0.067, "TestArgmax": 5.687, "TestArgmaxArgminCommon": 1.3673333333333322, "TestArgmin": 1.3083333333333333, "TestContains": 0.018666666666666665, "TestIndexing": 1.1553333333333333, "TestIter": 0.033, "TestNoExtraMethods": 0.07833333333333332, "TestNonzero": 0.2796666666666667, "TestRavel": 0.015333333333333332, "TestReshape": 0.016, "TestTranspose": 0.015666666666666666}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.2000000000000001, "TestNEP50Table": 0.0023333333333333335}, "torch_np/test_random": {"TestChoice": 0.06066666666666667, "TestNumpyGlobal": 0.024333333333333332, "TestScalarReturn": 1.9329999999999992, "TestShuffle": 0.2866666666666667}, "torch_np/test_reductions": {"TestAll": 0.13466666666666668, "TestAny": 0.114, "TestFlatnonzero": 0.985, "TestGenericCumSumProd": 0.19533333333333336, "TestGenericReductions": 10.009666666666655, "TestMean": 0.12733333333333333, "TestSum": 0.7753333333333333}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 1.3179999999999998, "TestIsScalar": 0.45900000000000013}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 13.539999999999994, "TestNdarrayDunderVsUfunc": 1.8649999999999995, "TestUfuncDtypeKwd": 0.039, "TestUnaryUfuncs": 1.7439999999999982}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 2.231999999999998}}, "slow": {"backends/xeon/test_launch": {"TestTorchrun": 2.3529999999999998}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 292.80499999999984}, "distributions/test_constraints": {"test_constraints": 0.08300000000000005}, "distributions/test_distributions": {"TestAgainstScipy": 0.004, "TestConstraints": 0.002, "TestDistributionShapes": 0.04300000000000003, "TestDistributions": 0.1370000000000001, "TestFunctors": 0.004, "TestJit": 0.008, "TestKL": 0.013000000000000005, "TestLazyLogitsInitialization": 0.002, "TestNumericalStability": 0.010000000000000002, "TestRsample": 0.007, "TestValidation": 0.004}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.30800000000000005}, "dynamo/test_after_aot": {"TestAfterAot": 0.253}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.234}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 0.394}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.263}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 0.29800000000000004}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.001, "TestCustomBackendAPI": 0.003, "TestExplainWithBackend": 0.001, "TestOptimizations": 0.319}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 0.266}, "dynamo/test_base_output": {"TestBaseOutput": 0.004}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 0.264}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 0.001, "BytecodeTests": 0.263}, "dynamo/test_compile": {"InPlaceCompilationTests": 0.262, "PublicTorchCompilerTests": 0.001}, "dynamo/test_comptime": {"ComptimeTests": 0.265}, "dynamo/test_config": {"ConfigTests": 0.266}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.003, "CppGuardManagerFuncTorchHigherOrderOpTests": 0.07500000000000005, "CppGuardManagerFunctionTests": 0.45100000000000023, "CppGuardManagerHigherOrderOpTests": 0.09800000000000007, "CppGuardManagerMiscTests": 0.46300000000000036, "CppGuardManagerReproTests": 0.21300000000000016}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.05100000000000003}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.374}, "dynamo/test_decorators": {"DecoratorTests": 0.269}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.013000000000000001}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 0.03900000000000003, "DynamicShapesCtxManagerTests": 0.04100000000000002, "DynamicShapesExportTests": 2660.720000000005, "DynamicShapesFuncTorchHigherOrderOpTests": 0.08300000000000006, "DynamicShapesFunctionTests": 0.3010000000000002, "DynamicShapesHigherOrderOpTests": 0.10400000000000008, "DynamicShapesMiscTests": 0.5170000000000003, "DynamicShapesNNModuleTests": 0.08400000000000006, "DynamicShapesReproTests": 0.24000000000000019, "DynamicShapesSubGraphTests": 0.04900000000000003, "DynamicShapesTestSDPA": 0.006}, "dynamo/test_exc": {"ExcTests": 0.011}, "dynamo/test_exceptions": {"ExceptionTests": 0.257}, "dynamo/test_export": {"ExportTests": 0.19600000000000015}, "dynamo/test_export_mutations": {"MutationExportTests": 0.388}, "dynamo/test_frame_init": {"FrameInitTests": 0.334}, "dynamo/test_functions": {"DefaultsTests": 0.02000000000000001, "FunctionTests": 0.6930000000000003}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.256}, "dynamo/test_global": {"TestGlobals": 0.34800000000000003}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.28}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.013000000000000001, "FuncTorchHigherOrderOpTests": 0.08100000000000006, "HigherOrderOpTests": 0.3930000000000001, "HigherOrderOpVmapGuardTests": 0.014000000000000002}, "dynamo/test_hooks": {"HooksTests": 0.28800000000000003}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 0.036000000000000025, "InlineInbuiltNNModulesExportTests": 0.18300000000000013, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 0.07600000000000005, "InlineInbuiltNNModulesFunctionTests": 0.3090000000000002, "InlineInbuiltNNModulesHigherOrderOpTests": 0.10400000000000008, "InlineInbuiltNNModulesMiscTests": 0.6510000000000004, "InlineInbuiltNNModulesNNModuleTests": 0.07600000000000005}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 0.264}, "dynamo/test_interop": {"InteropTests": 0.256}, "dynamo/test_logging": {"LoggingTests": 0.34600000000000003}, "dynamo/test_minifier": {"MinifierTests": 0.262}, "dynamo/test_misc": {"MiscTests": 0.46100000000000035, "TestTracer": 0.001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.003}, "dynamo/test_modules": {"NNModuleTests": 0.3630000000000001, "OptimizedModuleTest": 0.03800000000000003}, "dynamo/test_nops": {"NopTests": 0.26}, "dynamo/test_optimizers": {"End2EndTests": 0.295, "OptimizerTests": 0.17200000000000001}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.272}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.264}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.26}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.34800000000000003}, "dynamo/test_recompiles": {"RecompileTests": 0.257}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.264}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.1685}, "dynamo/test_repros": {"ReproTests": 0.2420000000000002}, "dynamo/test_resume": {"ResumeFunctionTests": 0.254}, "dynamo/test_sdpa": {"TestSDPA": 0.255}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.299}, "dynamo/test_sources": {"SourceTests": 0.264}, "dynamo/test_structured_trace": {"StructuredTraceTest": 0.296}, "dynamo/test_subclasses": {"SubclassTests": 0.31500000000000006, "TestNestedTensor": 0.027000000000000017}, "dynamo/test_subgraphs": {"SubGraphTests": 0.29700000000000004}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.001, "TraceRuleTests": 0.26}, "dynamo/test_triton_kernels": {"KernelTests": 0.015000000000000006, "MutationTests": 0.003, "NoOptimizationKernelTests": 0.012000000000000004, "no_opt_test_class": 0.015000000000000006}, "dynamo/test_unspec": {"UnspecTests": 0.29700000000000004}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.257}, "dynamo/test_view": {"ViewTests": 0.298}, "export/test_converter": {"TestConverter": 0.375}, "export/test_db": {"ExampleTests": 0.29400000000000004}, "export/test_experimental": {"TestExperiment": 0.279}, "export/test_export": {"TestDynamismExpression": 0.007, "TestExport": 0.1540000000000001, "TestExportCustomClass": 0.45899999999999996, "TestOneOffModelExportResult": 0.014000000000000005}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.008, "NonStrictExportTestExport": 0.16200000000000012}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.004, "PreDispatchExportTestExport": 0.1490000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.258}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.6976666666666667}, "export/test_hop": {"TestHOPCPU": 0.02000000000000001, "TestHOPGeneric": 0.001}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.014, "TestLift": 0.251, "TestLiftUnlift": 0.0105}, "export/test_pass_infra": {"TestPassInfra": 0.265}, "export/test_passes": {"TestPasses": 0.448}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.01, "RetraceExportTestExport": 0.17000000000000012}, "export/test_safeguard": {"TestSafeguard": 0.242}, "export/test_schema": {"TestSchema": 0.26}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.004, "SerDesExportPreDispatchTestExport": 0.1440000000000001, "SerDesExportTestDynamismExpression": 0.005, "SerDesExportTestExport": 0.1510000000000001}, "export/test_serialize": {"TestDeserialize": 0.058000000000000045, "TestOpVersioning": 0.003, "TestSaveLoad": 0.006, "TestSchemaVersioning": 0.001, "TestSerialize": 0.35500000000000004, "TestSerializeCustomClass": 0.003}, "export/test_sparse": {"TestSparseProp": 0.4430000000000001}, "export/test_tools": {"TestExportTools": 0.299}, "export/test_torchbind": {"TestCompileTorchbind": 1.0350000000000001, "TestExportTorchbind": 1.7349999999999992, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.287}, "export/test_unflatten": {"TestUnflatten": 0.275}, "export/test_upgrade": {"TestUpgrade": 0.244}, "export/test_verifier": {"TestVerifier": 0.266}, "functorch/test_aotdispatch": {"TestAOTAutograd": 0.11500000000000009, "TestAOTAutogradWithDynamo": 0.1210000000000001, "TestAOTDispatch": 0.009000000000000001, "TestAOTExport": 0.02900000000000002, "TestAOTModuleSimplified": 0.007, "TestEagerFusionModuleInfoCPU": 107.74100000000003, "TestEagerFusionOpInfoCPU": 1201.8989999999928, "TestPartitioning": 0.011000000000000003, "TestPythonKeyCPU": 0.014000000000000005}, "functorch/test_control_flow": {"TestControlFlow": 0.17900000000000002, "TestControlFlowTraced": 0.22000000000000017}, "functorch/test_dims": {"TestMin": 0.29400000000000004, "TestMinFunctorchOnly": 0.03400000000000002}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.02900000000000002, "TestAutogradFunctionVmapAPICPU": 0.009000000000000001, "TestCompileTransformsCPU": 0.002, "TestComposabilityCPU": 0.04500000000000003, "TestExamplesCorrectnessCPU": 0.02000000000000001, "TestFunctionalizeCPU": 0.01800000000000001, "TestGradTransformCPU": 0.06300000000000004, "TestHelpersCPU": 0.005, "TestHessianCPU": 0.004, "TestHigherOrderOperatorInteractionCPU": 0.009000000000000001, "TestJacCPU": 0.08300000000000006, "TestJvpCPU": 0.022000000000000013, "TestLinearizeCPU": 0.005, "TestMakeFunctional": 0.02000000000000001, "TestSliceArgnums": 0.009000000000000001, "TestVmapJvpInplaceViewCPU": 0.005, "TestVmapOfGradCPU": 0.007}, "functorch/test_logging": {"TestAOTLogging": 0.386}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.253, "RandomOpTestCase": 0.001, "ReduceTestCase": 0.009000000000000001, "TestMemoryEfficientOpAuthoring": 0.001}, "functorch/test_minifier": {"TestMinifier": 0.273}, "functorch/test_ops": {"TestOperatorsCPU": 144.5050000000079}, "functorch/test_parsing": {"TestAnonymousAxis": 0.264, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.271}, "functorch/test_vmap": {"TestRandomnessCPU": 0.2830000000000002, "TestTransformFailureCPU": 0.008, "TestVmapAPI": 0.07100000000000005, "TestVmapBatchedGradientCPU": 0.03300000000000002, "TestVmapDeviceTypeCPU": 0.005, "TestVmapNestedTensorCPU": 0.013000000000000005, "TestVmapOperators": 0.17700000000000013, "TestVmapOperatorsOpInfoCPU": 2.7729999999998785}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.148999999999894}, "higher_order_ops/test_with_effects": {"TestWithEffects": 6.238}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 14.276}, "inductor/test_binary_folding": {"FreezingCpuTests": 0.003}, "inductor/test_codecache": {"TestFxGraphCache": 0.03800000000000003, "TestFxGraphCacheHashing": 0.006, "TestUtils": 0.002, "test_codecache": 0.001}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.164}, "inductor/test_compile_worker": {"TestCompileWorker": 0.289}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 0.32600000000000023, "TestAutogradWithCompiledAutograd": 0.4140000000000003, "TestCompiledAutograd": 0.08500000000000005, "TestCustomOpWithCompiledAutograd": 0.2360000000000001}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 0.04400000000000001, "CompiledOptimizerTests": 1.0280000000000002}, "inductor/test_config": {"TestInductorConfig": 0.324}, "inductor/test_control_flow": {"CondTests": 0.127, "WhileLoopTests": 0.003}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 0.054000000000000034, "TestCppWrapper": 64.06350000000005}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 466.9989999999996, "TestCppWrapper": 1220.9379999999985}, "inductor/test_cpu_repro": {"CPUReproTests": 2231.700000000003}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 0.1390000000000001, "TestSelectAlgorithmDynamicShapesCPU": 0.1370000000000001}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 0.193}, "inductor/test_debug_trace": {"TestDebugTrace": 0.002}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.005}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 0.317}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 286.275}, "inductor/test_extension_backend": {"ExtensionBackendTests": 1.236}, "inductor/test_flex_attention": {"TestFlexAttention": 0.014000000000000005, "TestTemplatedSDPA": 0.011000000000000003}, "inductor/test_foreach": {"ForeachTests": 0.037000000000000026}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 0.01900000000000001, "SDPAPatternRewriterCpuTests": 0.031000000000000014}, "inductor/test_fx_fusion": {"TestFxFusion": 0.166}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.019}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.166, "TestGroupBatchFusion": 0.001, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.009000000000000001, "TestIndexingSimplification": 0.328}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 0.02700000000000001}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_minifier": {"MinifierTests": 0.289}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 0.401}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 0.010000000000000002, "TestPatternMatcher": 0.24400000000000008}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.025000000000000015}, "inductor/test_profiler": {"DynamoProfilerTests": 0.003}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 0.523}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.006}, "inductor/test_torchbind": {"TestTorchbind": 0.259}, "inductor/test_torchinductor": {"CpuTests": 257.1359999999924, "SweepInputsCpuTest": 0.06600000000000004, "TestFull": 0.001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 250.38900000000191}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 326.7179999999915, "TestInductorDynamicCPU": 0.009000000000000001}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 5.657000000000431}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.002}, "inductor/test_triton_kernels": {"KernelTests": 0.07300000000000005, "MutationTests": 0.013000000000000005, "NoOptimizationKernelTests": 0.010000000000000002, "no_opt_test_class": 0.02000000000000001}, "inductor/test_utils": {"TestUtils": 0.295}, "lazy/test_debug_util": {"DebugUtilTest": 0.256}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.355}, "lazy/test_generator": {"LazyGeneratorTest": 0.26}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.377}, "lazy/test_step_closures": {"ClosuresTest": 0.264}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.002, "TestLazyOpInfoCPU": 0.2640000000000002, "TestLazyTensor": 0.01}, "nn/test_convolution": {"TestConvolutionNN": 0.04000000000000003, "TestConvolutionNNDeviceTypeCPU": 0.5450000000000004}, "nn/test_dropout": {"TestDropoutNN": 0.004, "TestDropoutNNDeviceTypeCPU": 0.005}, "nn/test_embedding": {"TestEmbeddingNN": 0.022000000000000013, "TestEmbeddingNNDeviceTypeCPU": 0.1440000000000001}, "nn/test_init": {"TestNNInit": 0.44100000000000006}, "nn/test_lazy_modules": {"TestLazyModules": 0.07000000000000005}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.03700000000000002, "TestLoadStateDictSwap": 0.002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.01, "TestModuleHookNN": 0.02600000000000001, "TestModuleHooks": 0.02700000000000001, "TestStateDictHooks": 0.016}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 0.007, "TestMultiheadAttentionNNDeviceTypeCPU": 0.012000000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.27}, "nn/test_parametrization": {"TestNNParametrization": 0.05900000000000004, "TestNNParametrizationDeviceCPU": 0.002}, "nn/test_pooling": {"TestAvgPool": 0.007, "TestPoolingNN": 0.011000000000000003, "TestPoolingNNDeviceTypeCPU": 8.313999999999973}, "nn/test_pruning": {"TestPruningNN": 0.056000000000000036}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.022000000000000006}, "profiler/test_memory_profiler": {"TestDataFlow": 0.010000000000000002, "TestIdentifyGradients": 0.006, "TestMemoryProfiler": 0.357, "TestMemoryProfilerE2E": 0.017000000000000008}, "profiler/test_profiler": {"TestExecutionTrace": 0.007, "TestExperimentalUtils": 0.017000000000000008, "TestProfiler": 0.045000000000000026, "TestProfilerCUDA": 0.001, "TestProfilerITT": 0.001, "TestRecordFunction": 0.004, "TestTorchTidyProfiler": 0.022000000000000013}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.266}, "profiler/test_record_function": {"TestRecordFunction": 0.267}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 0.29100000000000004}, "test_ao_sparsity": {"TestActivationSparsifier": 0.002, "TestBaseDataScheduler": 0.005, "TestBaseDataSparsifier": 0.004, "TestBaseSparsifier": 0.009000000000000001, "TestBaseStructuredSparsifier": 0.01900000000000001, "TestComposability": 0.009000000000000001, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.002, "TestFakeSparsity": 0.004, "TestFxComposability": 0.006, "TestNearlyDiagonalSparsifier": 0.005, "TestNormDataSparsifiers": 0.003, "TestQuantizationUtils": 0.002, "TestQuantizedSparseKernels": 0.207, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.002, "TestScheduler": 0.004, "TestSparsityUtilFunctions": 0.008, "TestWeightNormSparsifier": 0.006}, "test_autocast": {"TestAutocastCPU": 0.259, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.012000000000000004, "TestAutograd": 6.899000000000083, "TestAutogradComplex": 0.002, "TestAutogradDeviceTypeCPU": 0.06300000000000004, "TestAutogradForwardMode": 0.02900000000000002, "TestAutogradForwardModeBatchedGrad": 0.005, "TestAutogradFunctional": 0.1220000000000001, "TestAutogradInferenceMode": 0.01900000000000001, "TestAutogradLogging": 0.003, "TestAutogradMultipleDispatchCPU": 0.008, "TestMultithreadAutograd": 0.011000000000000003, "TestNestedCheckpoint": 0.014000000000000005}, "test_autograd_fallback": {"TestAutogradFallback": 0.278}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 13.38499999999823}, "test_bundled_inputs": {"TestBundledInputs": 0.268}, "test_comparison_utils": {"TestComparisonUtils": 0.263}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.01900000000000001}, "test_content_store": {"TestContentStoreCPU": 0.004}, "test_cpp_api_parity": {"TestCppApiParity": 0.2910000000000002}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.016000000000000004, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.016000000000000004, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 0.028000000000000014}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.771}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 1.763999999999998}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.782}, "test_custom_backend": {"TestCustomBackend": 0.073}, "test_custom_ops": {"MiniOpTest": 0.06700000000000005, "MiniOpTestOther": 0.012000000000000004, "TestCustomOp": 0.09100000000000007, "TestCustomOpAPI": 0.16100000000000003, "TestCustomOpTestingCPU": 0.028000000000000018, "TestCustomOperators": 0.29000000000000004, "TestGenerateOpcheckTests": 0.010000000000000002}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 89.198, "TestConcatDataset": 0.006, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.001, "TestDataLoader": 107.1160000000001, "TestDataLoaderDeviceTypeCPU": 0.003, "TestDataLoaderPersistentWorkers": 91.10800000000012, "TestDatasetRandomSplit": 0.009000000000000001, "TestDictDataLoader": 0.002, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.001, "TestSetAffinity": 0.001, "TestStackDataset": 0.009000000000000001, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.005}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.002, "TestDataChunk": 0.007, "TestDataFramesPipes": 0.007, "TestFunctionalIterDataPipe": 0.01900000000000001, "TestFunctionalMapDataPipe": 0.009000000000000001, "TestGraph": 0.006, "TestIterDataPipeCountSampleYielded": 0.005, "TestIterDataPipeGraphFastForward": 0.005, "TestIterDataPipeSingletonConstraint": 0.005, "TestIterableDataPipeBasic": 0.034, "TestSerialization": 0.003, "TestSharding": 0.008, "TestStreamWrapper": 0.414, "TestTyping": 0.008}, "test_decomp": {"DecompOneOffTestsCPU": 0.011000000000000003, "HasDecompTest": 0.002, "TestDecompCPU": 2244.710000000333}, "test_deploy": {"TestFreezer": 0.262}, "test_dispatch": {"TestDispatch": 0.18700000000000003, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCPU": 0.12500000000000008}, "test_dynamic_shapes": {"TestDimConstraints": 0.004, "TestFloorDiv": 0.004, "TestPySymInt": 0.42900000000000005, "TestSymNumberMagicMethods": 0.22600000000000017}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 0.09500000000000007, "TestExpandedWeightHelperFunctionCPU": 0.008, "TestExpandedWeightModuleCPU": 0.08800000000000006}, "test_fake_tensor": {"FakeTensorConstHandling": 0.010000000000000002, "FakeTensorConverterTest": 0.010000000000000002, "FakeTensorDispatchCache": 0.01900000000000001, "FakeTensorOpInfoTestCPU": 0.011000000000000003, "FakeTensorOperatorInvariants": 0.010000000000000002, "FakeTensorPropTest": 0.004, "FakeTensorSerialization": 0.002, "FakeTensorTest": 0.036000000000000025, "PropagateRealTensorsFakeTensorConstHandling": 0.010000000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.010000000000000002, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.011000000000000003, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.011000000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.004, "PropagateRealTensorsFakeTensorTest": 0.035000000000000024}, "test_flop_counter": {"TestFlopCounter": 0.030000000000000013}, "test_foreach": {"TestForeachCPU": 3.429999999999743}, "test_function_schema": {"TestFunctionSchema": 0.313}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 149.101}, "test_functional_optim": {"TestFunctionalOptimParity": 0.291}, "test_functionalization": {"TestCrossRefFunctionalization": 0.057000000000000044, "TestFunctionalization": 0.31000000000000005}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.001}, "test_futures": {"TestFuture": 0.28800000000000003}, "test_fx": {"AnnotationsTest": 0.007, "TestCSEPass": 0.015000000000000006, "TestCommonPass": 0.008, "TestConstFold": 0.02000000000000001, "TestConstParamShapeInControlFlow": 0.006, "TestDCE": 0.007, "TestFX": 0.18800000000000014, "TestFXAPIBackwardCompatibility": 0.005, "TestFunctionalTracing": 0.12500000000000008, "TestMatcher": 0.008, "TestOperatorSignaturesCPU": 2.458999999999983, "TestPassManager": 0.006, "TestSourceMatcher": 0.005, "TestSubgraphRewriter": 0.027000000000000017, "TestVisionTracing": 220.2350000000001, "TypeCheckerTest": 0.03100000000000002}, "test_fx_experimental": {"TestFXExperimental": 0.04100000000000003, "TestNormalizeOperatorsCPU": 0.8620000000000005, "TestTranslationValidation": 0.004}, "test_fx_passes": {"TestFXGraphPasses": 0.30000000000000004, "TestFXMatcherUtils": 0.017000000000000005}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.35100000000000003}, "test_import_stats": {"TestImportTime": 0.257}, "test_indexing": {"NumpyTestsCPU": 0.02100000000000001, "TestIndexingCPU": 0.06900000000000005}, "test_itt": {"TestItt": 0.305}, "test_jit": {"TestAliasAnalysis": 0.004, "TestAsync": 0.023000000000000013, "TestAtenPow": 0.002, "TestAutodiffJit": 0.020000000000000004, "TestAutodiffSubgraphSlicing": 0.038000000000000006, "TestAwait": 0.04400000000000001, "TestBackends": 0.003, "TestBackendsWithCompiler": 0.003, "TestBatchMM": 0.011000000000000001, "TestBuiltins": 0.004, "TestClassType": 0.048000000000000036, "TestComplex": 0.014000000000000005, "TestCustomOperators": 0.04000000000000001, "TestDCE": 0.002, "TestDataParallel": 0.005, "TestDataclasses": 0.011000000000000001, "TestDeviceAnalysis": 0.034, "TestDict": 0.057000000000000016, "TestDtypeAnalysis": 0.608, "TestDtypeCustomRulesCPU": 4.422999999999996, "TestEnum": 0.05900000000000001, "TestFreezing": 0.08800000000000004, "TestFrontend": 0.002, "TestFrozenOptimizations": 0.03300000000000002, "TestFunctionalBlocks": 0.001, "TestFunctionalToInplaceActivation": 0.006, "TestGenerator": 0.005, "TestGetDefaultAttr": 0.003, "TestGraphRewritePasses": 0.001, "TestHash": 0.009000000000000001, "TestHooks": 0.027000000000000017, "TestIgnorableArgs": 0.002, "TestIgnoreContextManager": 0.003, "TestInplaceToFunctionalActivation": 0.002, "TestIsinstance": 0.04600000000000002, "TestJit": 2.220999999999993, "TestJitGeneratedModule": 11.298999999999968, "TestJitProfiler": 0.001, "TestJitUtils": 0.008, "TestList": 0.12300000000000008, "TestLogging": 0.007, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.02700000000000001, "TestMixTracingScripting": 0.039000000000000014, "TestModels": 12.085999999999997, "TestModuleAPIs": 0.004, "TestModuleContainers": 0.01900000000000001, "TestModuleInterface": 0.017000000000000008, "TestModules": 0.001, "TestNamedTuple": 0.016000000000000007, "TestNnapiBackend": 15.887999999999998, "TestOpDecompositions": 0.002, "TestOptimizeForMobilePreserveDebugInfo": 0.02600000000000001, "TestPDT": 0.019000000000000006, "TestParametrization": 0.017, "TestPeephole": 0.04100000000000003, "TestProducerVersion": 0.001, "TestProfiler": 0.6760000000000002, "TestPythonBindings": 0.020000000000000004, "TestPythonBuiltinOP": 0.055, "TestPythonIr": 0.041, "TestRecursiveScript": 0.03900000000000002, "TestRemoveMutation": 0.023, "TestSaveLoad": 0.04600000000000001, "TestSaveLoadFlatbuffer": 0.024000000000000007, "TestSaveLoadForOpVersion": 0.014000000000000002, "TestScript": 19.525000000000425, "TestScriptDict": 0.011000000000000003, "TestScriptList": 0.019000000000000006, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.017, "TestScriptProfile": 0.005, "TestSlice": 0.04400000000000001, "TestSparse": 0.004, "TestStringFormatting": 0.022000000000000013, "TestSymbolicShapeAnalysis": 0.028000000000000018, "TestTensorBuiltins": 0.007, "TestTensorCreationOps": 0.006, "TestTensorMethods": 0.002, "TestTorchbind": 0.18100000000000002, "TestTracer": 0.1670000000000001, "TestTypeSharing": 0.040000000000000015, "TestTypesAndAnnotation": 0.019000000000000003, "TestTyping": 0.07100000000000004, "TestUnion": 0.07400000000000004, "TestUnsupportedOps": 0.002, "TestUpgraders": 0.047, "TestWarn": 0.035, "TestWith": 0.006}, "test_jit_autocast": {"TestAutocast": 0.05100000000000003, "TestJitTraceAutocast": 0.009000000000000001}, "test_jit_disabled": {"TestJitDisabled": 0.254}, "test_jit_fuser_te": {"TestFuserCommon": 0.001, "TestLoopnestRandomizationCPU": 0.001, "TestNNCOpInfoCPU": 2209.9450000000215, "TestTEFuserDynamic": 42.69499999999982, "TestTEFuserStatic": 15.465999999999964}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCPU": 5.487000000000001, "TestModel": 3.803, "TestOpCPU": 37.748000000000005}, "test_legacy_vmap": {"TestVmapAPI": 0.404, "TestVmapAPILegacy": 0.047000000000000035, "TestVmapBatchedGradientCPU": 0.02900000000000002, "TestVmapBatchedGradientLegacyCPU": 0.03200000000000002, "TestVmapOperators": 0.05400000000000004, "TestVmapOperatorsLegacy": 0.05300000000000004}, "test_license": {"TestLicense": 0.259}, "test_linalg": {"TestLinalgCPU": 75.41200000000146}, "test_logging": {"LoggingTest": 0.258}, "test_masked": {"TestMaskedCPU": 0.21300000000000016}, "test_maskedtensor": {"TestBasicsCPU": 0.019000000000000003, "TestBinary": 0.06900000000000005, "TestOperatorsCPU": 0.7900000000000006, "TestReductions": 0.02100000000000001, "TestUnary": 0.1310000000000001}, "test_meta": {"TestMetaCPU": 47.5129999999817, "TestMetaConverter": 0.02000000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 0.265}, "test_mkldnn": {"TestMkldnnCPU": 0.09500000000000007}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.275}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 0.262}, "test_mobile_optimizer": {"TestOptimizer": 0.258}, "test_model_dump": {"TestModelDump": 0.307}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.261}, "test_module_init": {"TestModuleInitCPU": 0.3890000000000003}, "test_module_tracker": {"TestModuleTracker": 0.262}, "test_modules": {"TestModuleCPU": 5.6270000000000575}, "test_monitor": {"TestMonitor": 0.297, "TestMonitorTensorboard": 0.142}, "test_multiprocessing": {"TestMultiprocessing": 0.031000000000000017}, "test_multiprocessing_spawn": {"ErrorTest": 0.001, "ForkTest": 0.008, "SpawnTest": 0.254}, "test_namedtensor": {"TestNamedTensor": 0.08900000000000007}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 0.241}, "test_native_functions": {"TestNativeFunctions": 0.358}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.028000000000000018}, "test_nestedtensor": {"TestNestedTensor": 0.05200000000000004, "TestNestedTensorAutogradCPU": 0.06900000000000005, "TestNestedTensorDeviceTypeCPU": 0.16900000000000012, "TestNestedTensorSubclassCPU": 0.2470000000000002}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.001, "TestFusionUtils": 0.002, "TestNN": 1.0899999999999992, "TestNNDeviceTypeCPU": 1.1899999999999809, "TestUtils": 0.001}, "test_numba_integration": {"TestNumbaIntegration": 0.004}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.04200000000000003}, "test_openmp": {"TestOpenMP_ParallelFor": 0.556}, "test_ops": {"TestCommonCPU": 24.32600000000643, "TestCompositeComplianceCPU": 667.1479999999505, "TestFakeTensorCPU": 253.57000000000278, "TestMathBitsCPU": 2.454999999999873, "TestRefsOpsInfoCPU": 0.9180000000000007, "TestSelfKwarg": 0.001, "TestTagsCPU": 1.110999999999989}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 16.219999999998944}, "test_ops_gradients": {"TestBwdGradientsCPU": 771.1089999999352}, "test_ops_jit": {"TestJitCPU": 111.3230000000015}, "test_optim": {"TestDifferentiableOptimizer": 0.011000000000000003, "TestLRScheduler": 0.18200000000000013, "TestOptim": 0.68, "TestOptimRenewedCPU": 0.5140000000000003, "TestSWAUtils": 0.013000000000000005}, "test_out_dtype_op": {"TestOutDtypeOp": 0.02200000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.001, "TestGradCheckOverride": 0.001, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.001, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 1.7129999999999237, "TestTorchFunctionWarning": 0.001, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.007, "ModelTest": 0.001, "TestAnalyze": 0.256, "TestDependencyAPI": 0.017000000000000008, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.015000000000000006, "TestImporter": 0.006, "TestLoadBCPackages": 0.003, "TestMangling": 0.010000000000000002, "TestMisc": 0.011000000000000003, "TestPackageFX": 0.006, "TestPackageScript": 0.023000000000000013, "TestRepackage": 0.001, "TestResources": 0.004, "TestSaveLoad": 0.011000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.396}, "test_prims": {"TestDecompCPU": 0.002, "TestPrimsBasic": 0.003, "TestPrimsCPU": 0.012000000000000004, "TestRefsCPU": 0.005}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.006, "TestGenericProxyTensorFake": 0.03400000000000002, "TestGenericProxyTensorReal": 0.035000000000000024, "TestGenericProxyTensorSymbolic": 0.03400000000000002, "TestProxyTensorOpInfoCPU": 7.851000000000133, "TestRealProxyTensor": 0.001, "TestSymbolicTracing": 0.057000000000000044}, "test_pruning_op": {"PruningOpTest": 0.307}, "test_public_bindings": {"TestPublicBindings": 0.261}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.001, "TestPythonDispatch": 0.07400000000000005, "TestPythonDispatcher": 0.002, "TestPythonRegistration": 0.01800000000000001, "TestWrapperSubclassAliasingCPU": 0.01900000000000001}, "test_pytree": {"TestCxxPytree": 0.017000000000000008, "TestGenericPytree": 0.386, "TestPythonPytree": 0.032000000000000015}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.01800000000000001, "TestAOMigrationQuantization": 0.011000000000000003, "TestAOMigrationQuantizationFx": 0.012000000000000004, "TestBackendConfig": 0.023000000000000013, "TestBiasCorrectionEager": 0.002, "TestBits": 0.002, "TestBitsCPU": 0.003, "TestComparatorOps": 0.004, "TestDeprecatedJitQuantized": 0.004, "TestDistributed": 0.007, "TestDuplicateDQPass": 0.004, "TestDynamicQuantizedModule": 0.012000000000000002, "TestDynamicQuantizedOps": 0.017000000000000008, "TestEqualizeEager": 0.005, "TestEqualizeFx": 0.010000000000000002, "TestFXGraphMatcher": 0.014000000000000005, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 0.04500000000000003, "TestFXNumericSuiteCoreAPIsModels": 0.013000000000000005, "TestFXNumericSuiteNShadows": 0.024000000000000014, "TestFakeQuantize": 0.003, "TestFakeQuantizeOps": 0.028000000000000018, "TestFloat8DtypeCPU": 0.028000000000000018, "TestFloat8DtypeCPUOnlyCPU": 0.004, "TestFuseEager": 0.013000000000000001, "TestFuseFx": 0.01900000000000001, "TestFusedObsFakeQuant": 0.004, "TestFusedObsFakeQuantModule": 0.023000000000000007, "TestFusionPasses": 0.001, "TestFxDetectInputWeightEqualization": 0.003, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.008, "TestFxModelReportObserver": 0.004, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.003, "TestHistogramObserver": 0.013, "TestMetaDataPorting": 0.007, "TestModelNumericsEager": 0.005, "TestNumericSuiteEager": 0.023000000000000013, "TestObserver": 0.014000000000000005, "TestPT2ERepresentation": 0.008, "TestPadding": 0.004, "TestQNNPackOps": 0.012000000000000004, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 0.003, "TestQuantizeDynamicJitPasses": 0.010000000000000002, "TestQuantizeEagerOps": 0.015000000000000001, "TestQuantizeEagerPTQDynamic": 0.017, "TestQuantizeEagerPTQStatic": 0.02500000000000001, "TestQuantizeEagerQAT": 0.016000000000000004, "TestQuantizeEagerQATNumerics": 0.012000000000000002, "TestQuantizeFx": 0.3730000000000001, "TestQuantizeFxModels": 0.007, "TestQuantizeFxOps": 0.06500000000000004, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.02900000000000002, "TestQuantizeJitPasses": 0.03900000000000003, "TestQuantizePT2E": 0.04000000000000003, "TestQuantizePT2EQAT": 141.27900000000005, "TestQuantizePT2EQATModels": 77.497, "TestQuantizePT2EQAT_ConvBn1d": 304.754, "TestQuantizePT2EQAT_ConvBn2d": 318.35300000000007, "TestQuantizePT2EX86Inductor": 135.65, "TestQuantizedConv": 0.02900000000000002, "TestQuantizedEmbeddingOps": 0.009000000000000001, "TestQuantizedFunctionalOps": 0.005, "TestQuantizedLinear": 0.016000000000000007, "TestQuantizedOps": 85.53800000000021, "TestQuantizedTensor": 0.057000000000000044, "TestRecordHistogramObserver": 0.004, "TestReferenceQuantizedModule": 0.005, "TestSerialization": 0.01900000000000001, "TestStaticQuantizedModule": 118.49600000000002, "TestSubgraphRewriter": 0.014000000000000005, "TestUtils": 0.009000000000000001, "TestXNNPACKQuantizer": 0.025000000000000015, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCPU": 28.000999999999966}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 0.08500000000000006}, "test_schema_check": {"TestSchemaCheck": 0.037000000000000026, "TestSchemaCheckModeOpInfoCPU": 6.691000000000635}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.08100000000000006}, "test_serialization": {"TestBothSerializationCPU": 0.002, "TestOldSerialization": 0.04700000000000003, "TestSerialization": 0.07900000000000006, "TestSubclassSerialization": 0.008}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.486}, "test_shape_ops": {"TestShapeOpsCPU": 0.09700000000000007}, "test_show_pickle": {"TestShowPickle": 0.249}, "test_sort_and_select": {"TestSortAndSelectCPU": 27.520000000000085}, "test_sparse": {"TestSparseAnyCPU": 1.3509999999999682, "TestSparseCPU": 0.2790000000000002, "TestSparseLegacyAndDeprecation": 0.001, "TestSparseMaskedReductionsCPU": 0.04300000000000003, "TestSparseMeta": 0.04000000000000003, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 1.5099999999999456}, "test_sparse_csr": {"TestSparseCSRCPU": 2.122999999999906, "TestSparseCSRSampler": 0.001, "TestSparseCompressedCPU": 3.065999999999784, "TestSparseCompressedTritonKernelsCPU": 0.005}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.003}, "test_spectral_ops": {"TestFFTCPU": 0.2650000000000002, "TestFFTDocExamplesCPU": 0.01800000000000001}, "test_stateless": {"TestPythonOptimizeMode": 0.002, "TestStatelessDeprecation": 0.003, "TestStatelessFunctionalAPI": 0.06500000000000003}, "test_subclass": {"TestSubclass": 0.32500000000000007}, "test_sympy_utils": {"TestNumbers": 0.005, "TestSingletonInt": 0.001, "TestSympyInterp": 0.05900000000000004, "TestSympySolve": 0.03000000000000002, "TestValueRanges": 0.06800000000000005}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.1460000000000001, "TestBufferProtocolCPU": 0.12800000000000009, "TestLikeTensorCreationCPU": 0.006, "TestRandomTensorCreationCPU": 0.023000000000000013, "TestTensorCreationCPU": 2.276999999999967}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.002, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.166, "TestTensorBoardPytorchGraph": 0.006, "TestTensorBoardSummary": 0.01800000000000001, "TestTensorBoardSummaryWriter": 0.003, "TestTensorBoardUtils": 0.004, "TestTensorBoardWriter": 0.001, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 0.32800000000000007}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.001, "TestTensorExprPyBind": 0.277}, "test_testing": {"TestAssertClose": 0.035000000000000024, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.015000000000000005, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.004, "TestAssertCloseSparseBSR": 0.004, "TestAssertCloseSparseCOO": 0.007, "TestAssertCloseSparseCSC": 0.004, "TestAssertCloseSparseCSR": 0.005, "TestFrameworkUtils": 0.001, "TestImports": 0.006, "TestMakeTensorCPU": 0.7860000000000006, "TestOpInfoSampleFunctionsCPU": 1.6209999999999625, "TestOpInfos": 0.002, "TestTestParametrization": 0.02200000000000001, "TestTestParametrizationDeviceTypeCPU": 0.03000000000000002, "TestTestingCPU": 0.05200000000000003}, "test_torch": {"TestBasicVitalSigns": 0.003, "TestTorch": 0.22200000000000017, "TestTorchDeviceTypeCPU": 9.03699999999963, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 0.02100000000000001, "TestAttnMasksCPU": 0.013500000000000005, "TestSDPACPU": 1.4259999999999653, "TestSDPAFailureModesCPU": 0.05200000000000002, "TestTransformersCPU": 0.6220000000000001}, "test_type_hints": {"TestTypeHints": 0.354}, "test_type_info": {"TestDTypeInfo": 0.41100000000000003}, "test_type_promotion": {"TestTypePromotionCPU": 0.43700000000000033}, "test_typing": {"TestTyping": 70.76200000000006}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 26.53300000000852}, "test_utils": {"TestAssert": 0.002, "TestBottleneck": 0.002, "TestCheckpoint": 0.014000000000000005, "TestCollectEnv": 0.002, "TestCppExtensionUtils": 0.002, "TestDataLoaderUtils": 0.004, "TestDeviceUtilsCPU": 6.245000000000347, "TestExtensionUtils": 0.002, "TestHipify": 0.002, "TestHipifyTrie": 0.007, "TestONNXUtils": 0.002, "TestRenderUtils": 0.001, "TestStandaloneCPPJIT": 0.001, "TestTraceback": 0.005}, "test_view_ops": {"TestOldViewOpsCPU": 0.11600000000000009, "TestViewOpsCPU": 0.17100000000000012, "TestViewOpsLAZY": 0.16200000000000012}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.019, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 0.265}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 336.761, "TestXNNPACKOps": 0.317, "TestXNNPACKRewritePass": 0.002, "TestXNNPACKSerDes": 0.004}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.010000000000000002}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.37700000000000006, "TestClassGetItem": 0.019000000000000003, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.002, "TestMisc": 0.003, "TestPickling": 0.019000000000000006, "TestPromotion": 0.014000000000000002}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 0.30600000000000005, "TestEinsumPath": 0.002, "TestMisc": 0.002}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.002, "TestHalf": 0.001, "TestIinfo": 0.307, "TestMisc": 0.003, "TestPythonFloat": 0.001, "TestRepr": 0.002, "TestSingle": 0.001}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.003, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.001, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.30200000000000005, "TestMultiIndexingAutomated": 0.003, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.013000000000000005, "TestArgmax": 0.06400000000000004, "TestArgmaxArgminCommon": 0.027000000000000017, "TestArgmin": 0.06400000000000004, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.019000000000000003, "TestArrayCreationCopyArgument": 0.003, "TestArrayInterface": 0.011000000000000003, "TestAssignment": 0.006, "TestAttributes": 0.019000000000000003, "TestBinop": 0.001, "TestBool": 659.3, "TestCequenceMethods": 0.001, "TestChoose": 0.014000000000000002, "TestClip": 0.003, "TestCompress": 0.003, "TestConversion": 0.004, "TestCreation": 0.004, "TestDelMisc": 0.001, "TestDot": 0.07000000000000003, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.006, "TestFlag": 0.013000000000000003, "TestFormat": 0.004, "TestFromBuffer": 0.010000000000000002, "TestHash": 0.165, "TestHashing": 0.002, "TestIO": 0.002, "TestInner": 0.004, "TestLexsort": 0.012000000000000004, "TestMatmul": 0.3830000000000001, "TestMatmulOperator": 0.014000000000000005, "TestMethods": 0.1390000000000001, "TestMinMax": 0.002, "TestMinScalarType": 0.006, "TestNewaxis": 0.001, "TestPEP3118Dtype": 0.003, "TestPutmask": 0.008, "TestRepeat": 0.016, "TestResize": 0.008, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.028000000000000004, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.016000000000000007, "TestStats": 0.183, "TestSubscripting": 0.001, "TestTake": 0.008, "TestVdot": 0.006, "TestViewDtype": 0.006, "TestWarnings": 0.002, "TestWhere": 0.012000000000000002, "TestWritebackIfCopy": 0.01}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.007, "TestArgwhere": 0.007, "TestArrayComparisons": 0.005, "TestBaseRepr": 0.006, "TestBinaryRepr": 0.008, "TestBoolArray": 0.004, "TestBoolCmp": 0.003, "TestBoolScalar": 0.008, "TestBroadcast": 0.007, "TestClip": 0.06600000000000004, "TestConvolve": 0.006, "TestCorrelate": 0.007, "TestCreationFuncs": 0.007, "TestCross": 0.007, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.008, "TestFromiter": 0.003, "TestIndex": 0.003, "TestIndices": 0.01800000000000001, "TestIsclose": 0.01, "TestIsscalar": 0.002, "TestLikeFuncs": 0.003, "TestMoveaxis": 0.006, "TestNonarrayArgs": 0.044000000000000025, "TestNonzeroAndCountNonzero": 0.02700000000000001, "TestOuterMisc": 0.002, "TestRequire": 0.005, "TestResize": 0.333, "TestRoll": 0.004, "TestRollaxis": 0.003, "TestSeterr": 0.006, "TestStdVar": 0.006, "TestStdVarComplex": 0.003, "TestStringFunction": 0.002, "TestTensordot": 0.004, "TestTypes": 0.010000000000000002}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.261, "TestDocStrings": 0.001, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06200000000000005, "TestFromInt": 0.002, "TestFromString": 0.28300000000000003}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.001, "TestBitCount": 0.0, "TestClassGetItem": 0.002, "TestClassGetitemMisc": 0.256, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.007}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.010000000000000002, "TestBaseMath": 0.002, "TestBitShifts": 0.010000000000000002, "TestComplexDivision": 0.002, "TestConversion": 0.007, "TestHash": 0.001, "TestModulus": 43.647, "TestMultiply": 0.0, "TestNegative": 0.003, "TestPower": 0.005, "TestRepr": 0.001, "TestScalarOpsMisc": 0.027000000000000017, "TestScalarSubclassingMisc": 0.012000000000000004, "TestSubtract": 0.002, "TestTypes": 0.259}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.261, "TestAtleast2d": 0.005, "TestAtleast3d": 0.004, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.047000000000000035, "TestHstack": 0.007, "TestStackMisc": 0.004, "TestVstack": 0.008}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.001, "TestFFTShift": 0.258, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.08000000000000006, "TestFFTShift": 0.387, "TestFFTThreadSafe": 0.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.269}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.002, "TestUnique": 0.262}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.002, "TestAmax": 0.001, "TestAmin": 0.001, "TestAngle": 0.001, "TestAny": 0.002, "TestAverage": 0.005, "TestBincount": 0.015000000000000001, "TestCheckFinite": 0.002, "TestCopy": 0.002, "TestCorrCoef": 0.011000000000000003, "TestCov": 0.013000000000000005, "TestCumprod": 0.001, "TestCumsum": 0.001, "TestDelete": 0.016, "TestDiff": 0.006, "TestDigitize": 0.013000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.1360000000000001, "TestFlip": 0.008, "TestGradient": 0.01800000000000001, "TestInsert": 0.005, "TestInterp": 0.03200000000000002, "TestKaiser": 0.002, "TestMedian": 0.016000000000000007, "TestMeshgrid": 0.012000000000000004, "TestMsort": 0.0, "TestPercentile": 0.1240000000000001, "TestPiecewise": 0.009000000000000001, "TestProd": 0.001, "TestPtp": 0.001, "TestQuantile": 0.006, "TestRot90": 0.318, "TestSelect": 0.006, "TestSinc": 0.002, "TestSortComplex": 0.007, "TestTrapz": 0.002, "TestTrimZeros": 0.009000000000000001, "TestUnique": 0.002, "Test_I0": 0.002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.8210000000000001, "TestHistogramOptimBinNums": 0.01800000000000001, "TestHistogramdd": 0.017000000000000008}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.001, "TestDiagIndicesFrom": 0.003, "TestFillDiagonal": 0.007, "TestGrid": 0.008, "TestIndexExpression": 0.002, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.262}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.024000000000000007, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.022000000000000006, "TestColumnStack": 0.004, "TestDsplit": 0.005, "TestDstack": 0.022000000000000002, "TestExpandDims": 0.004, "TestHsplit": 0.004, "TestKron": 0.007, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.002, "TestSplit": 0.002, "TestSqueeze": 0.007, "TestTakeAlongAxis": 0.386, "TestTile": 0.004, "TestVsplit": 0.004}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.005, "TestEye": 0.34700000000000003, "TestFliplr": 0.001, "TestFlipud": 0.001, "TestHistogram2d": 0.008, "TestTri": 0.007, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.253, "TestImag": 0.002, "TestIscomplex": 0.002, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.003, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.004, "TestReal": 0.002, "TestRealIfClose": 0.001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.023000000000000007, "TestCond": 0.429, "TestDet": 0.259, "TestEig": 0.064, "TestEigh": 0.007, "TestEighCases": 0.0, "TestEigvals": 0.095, "TestEigvalsh": 0.007, "TestEigvalshCases": 0.0, "TestInv": 0.098, "TestLstsq": 0.013000000000000005, "TestMatrixRank": 0.003, "TestMisc": 0.502, "TestMisc2": 0.003, "TestMultiDot": 0.014000000000000004, "TestNormDouble": 0.04300000000000001, "TestNormInt64": 0.010000000000000002, "TestNormSingle": 0.011000000000000003, "TestNorm_NonSystematic": 0.001, "TestPinv": 0.281, "TestPinvHermitian": 0.07800000000000001, "TestQR": 0.06600000000000004, "TestSVD": 0.063, "TestSVDHermitian": 0.177, "TestSolve": 0.44000000000000006, "TestTensorinv": 0.008, "TestTensorsolve": 0.005}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.003, "TestCtorNested": 0.001, "TestDefaultDtype": 0.004, "TestDivmod": 0.005, "TestExport": 0.0, "TestMisc": 0.001, "TestNormalizations": 0.003, "TestOneArr": 0.23800000000000018, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1340000000000001, "TestOneArrAndShape": 0.03800000000000001, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.29100000000000004}, "torch_np/test_dtype": {"TestConvertDType": 0.29800000000000004}, "torch_np/test_function_base": {"TestAppend": 0.258}, "torch_np/test_ndarray_methods": {"TestAmax": 0.003, "TestAmin": 0.001, "TestArgmax": 0.09700000000000006, "TestArgmaxArgminCommon": 0.2670000000000001, "TestArgmin": 0.11800000000000006, "TestContains": 0.002, "TestIndexing": 0.352, "TestIter": 0.002, "TestNoExtraMethods": 0.007, "TestNonzero": 0.007, "TestRavel": 0.002, "TestReshape": 0.003, "TestTranspose": 0.004}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.026000000000000006, "TestNEP50Table": 0.002}, "torch_np/test_random": {"TestChoice": 0.002, "TestNumpyGlobal": 0.002, "TestScalarReturn": 0.37500000000000006, "TestShuffle": 0.006}, "torch_np/test_reductions": {"TestAll": 0.003, "TestAny": 0.003, "TestFlatnonzero": 0.253, "TestGenericCumSumProd": 0.115, "TestGenericReductions": 0.9560000000000007, "TestMean": 0.004, "TestSum": 0.011000000000000003}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.266, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3180000000000002, "TestNdarrayDunderVsUfunc": 0.03200000000000002, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.276}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.30000000000000004}}}, "linux-focal-py3.8-clang10-onnx": {"default": {"onnx/dynamo/test_dynamo_with_onnxruntime_backend": {"TestDynamoWithONNXRuntime": 30.188000000000002}, "onnx/dynamo/test_exporter_api": {"TestDynamoExportAPI": 61.75300000000001, "TestExportOptionsAPI": 0.535, "TestLargeProtobufExportOutputSerializerAPI": 30.419, "TestLargeProtobufONNXProgramSerializerAPI": 42.720333333333336, "TestONNXExportWithDynamo": 4.983, "TestProtobufExportOutputSerializerAPI": 20.287999999999997, "TestProtobufONNXProgramSerializerAPI": 48.61033333333333}, "onnx/dynamo/test_registry_dispatcher": {"TestDispatcher": 0.08066666666666666, "TestOpSchemaWrapper": 0.021000000000000008, "TestRegistration": 0.02}, "onnx/internal/test_beartype": {"TestBeartype": 0.06433333333333334}, "onnx/internal/test_diagnostics": {"TestDiagnosticsInfra": 0.03333333333333335, "TestDynamoOnnxDiagnostics": 0.11333333333333334, "TestTorchScriptOnnxDiagnostics": 0.03866666666666666}, "onnx/internal/test_registraion": {"TestGlobalHelpers": 0.08666666666666668, "TestOverrideDict": 0.008333333333333333, "TestRegistrationDecorators": 0.013000000000000003}, "onnx/test_autograd_funs": {"TestAutogradFuns": 0.09333333333333334}, "onnx/test_custom_ops": {"TestCustomAutogradFunction": 0.05266666666666666, "TestExportAsContribOps": 0.073}, "onnx/test_export_modes": {"TestExportModes": 0.12333333333333335}, "onnx/test_fx_op_consistency": {"TORCH_EXPORT_EXPORTEDPROGRAMCPU": 4947.014666666667, "TORCH_NN_MODULECPU": 4035.7103333333257, "TestOnnxModelOutputConsistency_opset18CPU": 973.4706666666658}, "onnx/test_fx_passes": {"TestFxPasses": 1.0526666666666666, "TestModularizePass": 1.184}, "onnx/test_fx_to_onnx": {"TestFxToOnnx": 50.69466666666668}, "onnx/test_fx_to_onnx_decomp_skip": {"TestDynamoExportDecompSkip": 3.104333333333333}, "onnx/test_fx_to_onnx_with_onnxruntime": {"TORCH_EXPORT_EXPORTEDPROGRAM": 357.931, "TORCH_NN_MODULE": 414.32733333333334, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_False_load_checkpoint_during_init_False_export_within_fake_mode_False": 14.609, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_False_load_checkpoint_during_init_False_export_within_fake_mode_True": 14.421, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_False_load_checkpoint_during_init_True_export_within_fake_mode_False": 14.123333333333333, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_False_load_checkpoint_during_init_True_export_within_fake_mode_True": 15.960999999999999, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_True_load_checkpoint_during_init_False_export_within_fake_mode_False": 21.151, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_True_load_checkpoint_during_init_False_export_within_fake_mode_True": 19.547666666666665, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_True_load_checkpoint_during_init_True_export_within_fake_mode_False": 19.642333333333337, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_False_dynamic_shapes_True_load_checkpoint_during_init_True_export_within_fake_mode_True": 20.311333333333334, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_False_load_checkpoint_during_init_False_export_within_fake_mode_False": 29.421000000000003, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_False_load_checkpoint_during_init_False_export_within_fake_mode_True": 28.698999999999998, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_False_load_checkpoint_during_init_True_export_within_fake_mode_False": 26.617333333333335, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_False_load_checkpoint_during_init_True_export_within_fake_mode_True": 28.522333333333332, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_True_load_checkpoint_during_init_False_export_within_fake_mode_False": 34.224333333333334, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_True_load_checkpoint_during_init_False_export_within_fake_mode_True": 32.459666666666664, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_True_load_checkpoint_during_init_True_export_within_fake_mode_False": 32.955666666666666, "TestFxToOnnxFakeTensorWithOnnxRuntime_op_level_debug_True_dynamic_shapes_True_load_checkpoint_during_init_True_export_within_fake_mode_True": 31.021333333333335, "TestFxToOnnxWithOnnxRuntime_op_level_debug_False_dynamic_shapes_False": 20.393500000000003, "TestFxToOnnxWithOnnxRuntime_op_level_debug_False_dynamic_shapes_True": 18.364500000000003, "TestFxToOnnxWithOnnxRuntime_op_level_debug_True_dynamic_shapes_False": 25.567, "TestFxToOnnxWithOnnxRuntime_op_level_debug_True_dynamic_shapes_True": 25.613499999999995}, "onnx/test_fx_type_promotion": {"TestGeneratedTypePromotionRuleSet": 0.05533333333333334}, "onnx/test_models_onnxruntime": {"TestModels": 131.51500000000001, "TestModelsONNXRuntime_is_script_False": 33.96, "TestModelsONNXRuntime_is_script_True": 0.011333333333333334, "TestModels_new_jit_API": 168.3306666666667}, "onnx/test_onnx_opset": {"TestONNXOpset": 0.779}, "onnx/test_onnxscript_runtime": {"TestONNXScriptRuntime": 0.09000000000000001}, "onnx/test_op_consistency": {"TestOnnxModelOutputConsistency_opset10CPU": 3.975666666666665, "TestOnnxModelOutputConsistency_opset11CPU": 4.484333333333332, "TestOnnxModelOutputConsistency_opset12CPU": 4.247333333333333, "TestOnnxModelOutputConsistency_opset13CPU": 7.047999999999998, "TestOnnxModelOutputConsistency_opset14CPU": 6.655333333333331, "TestOnnxModelOutputConsistency_opset15CPU": 7.3023333333333325, "TestOnnxModelOutputConsistency_opset16CPU": 7.491333333333333, "TestOnnxModelOutputConsistency_opset17CPU": 7.896666666666666, "TestOnnxModelOutputConsistency_opset18CPU": 7.416333333333333, "TestOnnxModelOutputConsistency_opset19CPU": 6.850666666666665, "TestOnnxModelOutputConsistency_opset20CPU": 6.681666666666665, "TestOnnxModelOutputConsistency_opset9CPU": 4.011666666666667}, "onnx/test_operators": {"TestOperators": 3.262666666666662}, "onnx/test_pytorch_jit_onnx": {"TestJITIRToONNX_opset14": 0.1206666666666667}, "onnx/test_pytorch_onnx_no_runtime": {"TestONNXExport": 1.1673333333333333, "TestQuantizeEagerONNXExport": 0.015}, "onnx/test_pytorch_onnx_onnxruntime": {"TestONNXRuntime_opset_version_10_is_script_False_keep_initializers_as_inputs_False": 33.54499999999994, "TestONNXRuntime_opset_version_10_is_script_False_keep_initializers_as_inputs_True": 31.58966666666662, "TestONNXRuntime_opset_version_10_is_script_True_keep_initializers_as_inputs_False": 28.126999999999942, "TestONNXRuntime_opset_version_10_is_script_True_keep_initializers_as_inputs_True": 28.777999999999906, "TestONNXRuntime_opset_version_11_is_script_False_keep_initializers_as_inputs_False": 35.21933333333333, "TestONNXRuntime_opset_version_11_is_script_False_keep_initializers_as_inputs_True": 34.85999999999999, "TestONNXRuntime_opset_version_11_is_script_True_keep_initializers_as_inputs_False": 32.57433333333322, "TestONNXRuntime_opset_version_11_is_script_True_keep_initializers_as_inputs_True": 34.780333333333274, "TestONNXRuntime_opset_version_12_is_script_False_keep_initializers_as_inputs_False": 35.400999999999975, "TestONNXRuntime_opset_version_12_is_script_False_keep_initializers_as_inputs_True": 36.41099999999998, "TestONNXRuntime_opset_version_12_is_script_True_keep_initializers_as_inputs_False": 34.93266666666659, "TestONNXRuntime_opset_version_12_is_script_True_keep_initializers_as_inputs_True": 34.16899999999995, "TestONNXRuntime_opset_version_13_is_script_False_keep_initializers_as_inputs_False": 37.37066666666666, "TestONNXRuntime_opset_version_13_is_script_False_keep_initializers_as_inputs_True": 36.939333333333316, "TestONNXRuntime_opset_version_13_is_script_True_keep_initializers_as_inputs_False": 33.309999999999924, "TestONNXRuntime_opset_version_13_is_script_True_keep_initializers_as_inputs_True": 33.79699999999993, "TestONNXRuntime_opset_version_14_is_script_False_keep_initializers_as_inputs_False": 35.83466666666667, "TestONNXRuntime_opset_version_14_is_script_False_keep_initializers_as_inputs_True": 36.79166666666663, "TestONNXRuntime_opset_version_14_is_script_True_keep_initializers_as_inputs_False": 34.074333333333264, "TestONNXRuntime_opset_version_14_is_script_True_keep_initializers_as_inputs_True": 34.83533333333324, "TestONNXRuntime_opset_version_15_is_script_False_keep_initializers_as_inputs_False": 35.96766666666667, "TestONNXRuntime_opset_version_15_is_script_False_keep_initializers_as_inputs_True": 36.88833333333334, "TestONNXRuntime_opset_version_15_is_script_True_keep_initializers_as_inputs_False": 36.878333333333266, "TestONNXRuntime_opset_version_15_is_script_True_keep_initializers_as_inputs_True": 34.91133333333324, "TestONNXRuntime_opset_version_16_is_script_False_keep_initializers_as_inputs_False": 36.789333333333325, "TestONNXRuntime_opset_version_16_is_script_False_keep_initializers_as_inputs_True": 37.509999999999984, "TestONNXRuntime_opset_version_16_is_script_True_keep_initializers_as_inputs_False": 35.73933333333324, "TestONNXRuntime_opset_version_16_is_script_True_keep_initializers_as_inputs_True": 37.239999999999924, "TestONNXRuntime_opset_version_17_is_script_False_keep_initializers_as_inputs_False": 36.16533333333334, "TestONNXRuntime_opset_version_17_is_script_False_keep_initializers_as_inputs_True": 37.71733333333335, "TestONNXRuntime_opset_version_17_is_script_True_keep_initializers_as_inputs_False": 35.50299999999993, "TestONNXRuntime_opset_version_17_is_script_True_keep_initializers_as_inputs_True": 35.72833333333323, "TestONNXRuntime_opset_version_18_is_script_False_keep_initializers_as_inputs_False": 37.018666666666675, "TestONNXRuntime_opset_version_18_is_script_False_keep_initializers_as_inputs_True": 37.150666666666666, "TestONNXRuntime_opset_version_18_is_script_True_keep_initializers_as_inputs_False": 35.69566666666654, "TestONNXRuntime_opset_version_18_is_script_True_keep_initializers_as_inputs_True": 36.14299999999988, "TestONNXRuntime_opset_version_19_is_script_False_keep_initializers_as_inputs_False": 39.11066666666667, "TestONNXRuntime_opset_version_19_is_script_False_keep_initializers_as_inputs_True": 39.131333333333345, "TestONNXRuntime_opset_version_19_is_script_True_keep_initializers_as_inputs_False": 37.60733333333331, "TestONNXRuntime_opset_version_19_is_script_True_keep_initializers_as_inputs_True": 38.87233333333332, "TestONNXRuntime_opset_version_20_is_script_False_keep_initializers_as_inputs_False": 39.65300000000001, "TestONNXRuntime_opset_version_20_is_script_False_keep_initializers_as_inputs_True": 41.95200000000003, "TestONNXRuntime_opset_version_20_is_script_True_keep_initializers_as_inputs_False": 37.84399999999996, "TestONNXRuntime_opset_version_20_is_script_True_keep_initializers_as_inputs_True": 38.05699999999996, "TestONNXRuntime_opset_version_7_is_script_False_keep_initializers_as_inputs_True": 15.621000000000038, "TestONNXRuntime_opset_version_7_is_script_True_keep_initializers_as_inputs_True": 19.38866666666675, "TestONNXRuntime_opset_version_8_is_script_False_keep_initializers_as_inputs_True": 15.493000000000059, "TestONNXRuntime_opset_version_8_is_script_True_keep_initializers_as_inputs_True": 20.681333333333377, "TestONNXRuntime_opset_version_9_is_script_False_keep_initializers_as_inputs_False": 26.9753333333333, "TestONNXRuntime_opset_version_9_is_script_False_keep_initializers_as_inputs_True": 28.15566666666665, "TestONNXRuntime_opset_version_9_is_script_True_keep_initializers_as_inputs_False": 27.7773333333332, "TestONNXRuntime_opset_version_9_is_script_True_keep_initializers_as_inputs_True": 28.46766666666657}, "onnx/test_pytorch_onnx_shape_inference": {"TestONNXCustomOpShapeInference": 0.2186666666666667, "TestONNXShapeInference": 0.06800000000000002}, "onnx/test_symbolic_helper": {"TestHelperFunctions": 0.08333333333333333}, "onnx/test_utility_funs": {"TestUnconvertibleOps": 0.08200000000000002, "TestUtilityFuns_opset_10": 0.991666666666667, "TestUtilityFuns_opset_11": 1.0090000000000003, "TestUtilityFuns_opset_12": 0.9816666666666669, "TestUtilityFuns_opset_13": 1.002666666666667, "TestUtilityFuns_opset_14": 0.9930000000000003, "TestUtilityFuns_opset_15": 1.1023333333333334, "TestUtilityFuns_opset_16": 1.092, "TestUtilityFuns_opset_17": 1.041666666666667, "TestUtilityFuns_opset_18": 1.0233333333333334, "TestUtilityFuns_opset_19": 1.0520000000000003, "TestUtilityFuns_opset_20": 1.0380000000000003, "TestUtilityFuns_opset_9": 2.426666666666664}, "onnx/test_verification": {"TestFindMismatch_ONNX_RUNTIME_CPU": 0.44, "TestVerification": 0.10233333333333335, "TestVerificationOnWrongExport": 0.020333333333333335}, "onnx/torch_export/test_torch_export_with_onnxruntime": {"TestFxToOnnxWithOnnxRuntime": 3.031333333333334}}}, "linux-focal-rocm5.6-py3.8": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 2.65}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.75}, "distributions/test_constraints": {"test_constraints": 1.2859999999999978}, "distributions/test_distributions": {"TestAgainstScipy": 1.028, "TestConstraints": 0.174, "TestDistributionShapes": 0.11300000000000004, "TestDistributions": 34.131, "TestFunctors": 0.007, "TestJit": 13.312, "TestKL": 3.3159999999999994, "TestLazyLogitsInitialization": 0.013000000000000001, "TestNumericalStability": 0.06200000000000001, "TestRsample": 0.79, "TestValidation": 0.38100000000000006}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 1.8849999999999987}, "dynamo/test_after_aot": {"TestAfterAot": 9.795}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 17.454}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.4490000000000003}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.063, "TestExplainWithBackend": 16.517, "TestOptimizations": 1.4579999999999997}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 21.869}, "dynamo/test_base_output": {"TestBaseOutput": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 1.3779999999999997}, "dynamo/test_config": {"ConfigTests": 1.4539999999999997}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.638999999999999}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.462}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.451}, "dynamo/test_decorators": {"DecoratorTests": 1.7799999999999996}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 44.150999999999996, "DynamicShapesCtxManagerTests": 9.610000000000001, "DynamicShapesExportTests": 94.85199999999998, "DynamicShapesFuncTorchHigherOrderOpTests": 10.225000000000001, "DynamicShapesFunctionTests": 154.932, "DynamicShapesHigherOrderOpTests": 17.835, "DynamicShapesMiscTests": 114.05000000000003, "DynamicShapesNNModuleTests": 8.704, "DynamicShapesReproTests": 105.94000000000003, "DynamicShapesSubGraphTests": 13.503}, "dynamo/test_exc": {"ExcTests": 2.406}, "dynamo/test_export": {"ExportTests": 15.722999999999995}, "dynamo/test_export_mutations": {"MutationExportTests": 1.4489999999999998}, "dynamo/test_functions": {"DefaultsTests": 50.42100000000008, "FunctionTests": 19.38700000000001}, "dynamo/test_global": {"TestGlobals": 1.3739999999999999}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 11.546999999999999, "FuncTorchHigherOrderOpTests": 3.328, "HigherOrderOpTests": 7.187999999999995}, "dynamo/test_hooks": {"HooksTests": 31.887000000000004}, "dynamo/test_interop": {"InteropTests": 1.4409999999999998}, "dynamo/test_logging": {"LoggingTests": 17.441999999999993}, "dynamo/test_minifier": {"MinifierTests": 5.137}, "dynamo/test_misc": {"MiscTests": 48.71200000000006, "TestTracer": 0.069}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0}, "dynamo/test_modules": {"NNModuleTests": 4.388999999999998, "OptimizedModuleTest": 10.440999999999997}, "dynamo/test_nops": {"NopTests": 0.509}, "dynamo/test_optimizers": {"End2EndTests": 0.325, "OptimizerTests": 3.1250000000000004}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 1.537}, "dynamo/test_profiler": {"DynamoProfilerTests": 2.226}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.94}, "dynamo/test_recompiles": {"RecompileTests": 1.944}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.002}, "dynamo/test_repros": {"ReproTests": 48.946000000000005}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 1.4339999999999997}, "dynamo/test_subclasses": {"SubclassTests": 1.2419999999999995, "TestNestedTensor": 2.0349999999999997}, "dynamo/test_subgraphs": {"SubGraphTests": 4.088}, "dynamo/test_trace_rules": {"TraceRuleTests": 2.218}, "dynamo/test_unspec": {"UnspecTests": 14.949}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 1.551}, "export/test_db": {"ExampleTests": 3.8149999999999995}, "export/test_export": {"TestDynamismExpression": 1.519, "TestExport": 7.830000000000003}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.425}, "export/test_pass_infra": {"TestPassInfra": 1.664}, "export/test_passes": {"TestPasses": 2.542}, "export/test_serialize": {"TestDeserialize": 3.1839999999999993, "TestOpVersioning": 0.003, "TestSaveLoad": 0.224, "TestSchemaVersioning": 0.024, "TestSerialize": 1.421, "TestSerializeCustomClass": 0.029}, "export/test_unflatten": {"TestUnflatten": 2.542}, "export/test_upgrade": {"TestUpgrade": 1.5479999999999998}, "export/test_verifier": {"TestVerifier": 1.8789999999999998}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.056, "TestAOTDispatch": 0.5900000000000001, "TestAOTExport": 0.37400000000000005, "TestAOTModuleSimplified": 0.612, "TestPartitioning": 89.12999999999998}, "functorch/test_control_flow": {"TestControlFlow": 2.2019999999999995, "TestControlFlowTraced": 81.06499999999998}, "functorch/test_dims": {"TestMin": 12.094000000000001, "TestMinFunctorchOnly": 11.163}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.2320000000000001, "TestAutogradFunctionVmapAPICUDA": 0.019000000000000003, "TestCompileTransformsCUDA": 0.967, "TestComposabilityCUDA": 0.27000000000000013, "TestExamplesCorrectnessCUDA": 5.212, "TestFunctionalizeCUDA": 0.13300000000000003, "TestGradTransformCUDA": 2.8829999999999982, "TestHelpersCUDA": 0.015000000000000001, "TestHessianCUDA": 0.125, "TestHigherOrderOperatorInteractionCUDA": 0.037000000000000005, "TestJacCUDA": 0.9740000000000004, "TestJvpCUDA": 0.07300000000000001, "TestLinearizeCUDA": 0.212, "TestMakeFunctional": 0.17600000000000005, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.022, "TestVmapOfGradCUDA": 0.992}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.031, "RandomOpTestCase": 0.112, "ReduceTestCase": 0.087, "TestMemoryEfficientOpAuthoring": 11.094}, "functorch/test_minifier": {"TestMinifier": 0.6830000000000002}, "functorch/test_ops": {"TestOperatorsCUDA": 9160.016000000058}, "functorch/test_parsing": {"TestAnonymousAxis": 0.278, "TestParsedExpression": 0.005, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.271}, "functorch/test_vmap": {"TestRandomnessCUDA": 1.9089999999999985, "TestTransformFailureCUDA": 0.07500000000000001, "TestVmapAPI": 0.8370000000000002, "TestVmapBatchedGradientCUDA": 0.3300000000000001, "TestVmapDeviceTypeCUDA": 0.163, "TestVmapNestedTensorCUDA": 0.10000000000000002, "TestVmapOperators": 3.253999999999996, "TestVmapOperatorsOpInfoCUDA": 490.9589999999992}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.1669999999998875}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 5.912, "BenchmarkFusionCudaTest": 54.355000000000004}, "inductor/test_binary_folding": {"FreezingCpuTests": 4.638, "FreezingCudaTests": 7.953}, "inductor/test_codecache": {"TestFxGraphCache": 88.743, "TestFxGraphCacheHashing": 0.8170000000000001, "test_codecache": 3.286}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.32}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 234.91300000000038, "TestCompiledAutograd": 47.083}, "inductor/test_config": {"TestInductorConfig": 7.025000000000001}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.36}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 983.096, "TestCppWrapper": 1116.6709999999998}, "inductor/test_cpu_repro": {"CPUReproTests": 581.3490000000002}, "inductor/test_cuda_repro": {"CudaReproTests": 126.85399999999998}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 65.05399999999999}, "inductor/test_custom_lowering": {"TestCustomLowering": 5.14}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 4.632}, "inductor/test_dependencies": {"TestDependencies": 0.246}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 160.504, "EfficientConvBNEvalCudaTests": 102.98}, "inductor/test_extension_backend": {"ExtensionBackendTests": 32.027}, "inductor/test_fp8": {"TestFP8Types": 0.007}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuTests": 51.290000000000006}, "inductor/test_fx_fusion": {"TestFxFusion": 0.36300000000000004}, "inductor/test_group_batch_fusion": {"TestGroupBatchFusion": 35.962999999999994}, "inductor/test_indexing": {"ExprPrinterTests": 0.034, "TestIndexingSimplification": 0.74}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 25.348, "FreezingCudaTests": 56.71199999999998}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 7.42}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 15.100999999999999}, "inductor/test_layout_optim": {"TestLayoutOptim": 13.019000000000002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 3.619}, "inductor/test_minifier": {"MinifierTests": 58.906}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 54.839}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 66.635, "TestPatternMatcher": 59.26199999999995}, "inductor/test_mmdecomp": {"TestDecompCUDA": 9.450999999999995}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 91.357}, "inductor/test_perf": {"FusionTests": 3.7049999999999996, "InplacingTests": 0.214, "MinCutPartitioningTests": 1.567, "NoopTests": 0.458, "NumBytesMetricTests": 2.6580000000000004, "SchedulerFusionTests": 0.196, "TilingTests": 0.158}, "inductor/test_smoke": {"SmokeTest": 6.348000000000001}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 2.0020000000000002, "MemoryBoundedTests": 0.188, "UnsupportedTests": 0.6}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 156.029}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 12.517000000000001}, "inductor/test_torchinductor": {"CpuTests": 1293.5729999999999, "CudaTests": 739.1869999999999, "NanCheckerTest": 0.66, "RNNTest": 0.87, "SweepInputsCpuTest": 159.094, "SweepInputsCudaTest": 80.54400000000001, "TestFull": 16.476, "TritonCodeGenTests": 19.881}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 763.4089999999995, "DynamicShapesCodegenCudaTests": 483.12199999999984}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1339.576, "DynamicShapesCudaTests": 1048.0659999999998, "TestInductorDynamicCUDA": 21.812}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1976.4399999999978}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.339}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 8.453}, "lazy/test_debug_util": {"DebugUtilTest": 0.417}, "lazy/test_generator": {"LazyGeneratorTest": 0.594}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.836}, "lazy/test_step_closures": {"ClosuresTest": 2.3129999999999997}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.179, "TestLazyTensor": 0.33299999999999996}, "nn/test_convolution": {"TestConvolutionNN": 30.602000000000007, "TestConvolutionNNDeviceTypeCUDA": 104.39499999999971}, "nn/test_dropout": {"TestDropoutNN": 0.14600000000000002, "TestDropoutNNDeviceTypeCUDA": 0.6910000000000001}, "nn/test_embedding": {"TestEmbeddingNN": 0.338, "TestEmbeddingNNDeviceTypeCUDA": 14.126999999999992}, "nn/test_lazy_modules": {"TestLazyModules": 1.027}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.086, "TestModuleHookNN": 0.07, "TestModuleHooks": 0.059000000000000025, "TestStateDictHooks": 0.01}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 7.0440000000000005, "TestMultiheadAttentionNNDeviceTypeCUDA": 1.141}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.189}, "nn/test_parametrization": {"TestNNParametrization": 1.2389999999999994}, "nn/test_pooling": {"TestAvgPool": 0.346, "TestPoolingNN": 1.06, "TestPoolingNNDeviceTypeCUDA": 29.90500000000001}, "nn/test_pruning": {"TestPruningNN": 0.07600000000000004}, "profiler/test_memory_profiler": {"TestDataFlow": 1.1779999999999997, "TestIdentifyGradients": 0.41900000000000004, "TestMemoryProfiler": 1.002, "TestMemoryProfilerE2E": 3.9110000000000005}, "profiler/test_profiler": {"TestExecutionTrace": 1.044, "TestExperimentalUtils": 2.312999999999999, "TestProfiler": 8.785000000000004, "TestProfilerCUDA": 3.577, "TestProfilerITT": 0.001, "TestRecordFunction": 0.037000000000000005, "TestTorchTidyProfiler": 3.5589999999999997}, "profiler/test_profiler_tree": {"TestProfilerTree": 1.0590000000000002}, "test_ao_sparsity": {"TestActivationSparsifier": 0.081, "TestBaseDataScheduler": 0.026000000000000002, "TestBaseDataSparsifier": 0.07300000000000001, "TestBaseSparsifier": 0.023, "TestBaseStructuredSparsifier": 4.646999999999998, "TestComposability": 1.8549999999999995, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.12, "TestFakeSparsity": 0.065, "TestFxComposability": 1.601, "TestNearlyDiagonalSparsifier": 0.749, "TestNormDataSparsifiers": 0.942, "TestQuantizationUtils": 0.018, "TestQuantizedSparseKernels": 0.443, "TestQuantizedSparseLayers": 0.271, "TestSaliencyPruner": 0.024, "TestScheduler": 0.015, "TestSparsityUtilFunctions": 0.034, "TestWeightNormSparsifier": 0.321}, "test_autocast": {"TestAutocastCPU": 0.714, "TestAutocastGPU": 0.374, "TestTorchAutocast": 0.004}, "test_autograd": {"TestAllowMutationOnSaved": 0.035, "TestAutograd": 17.93299999999998, "TestAutogradComplex": 0.011, "TestAutogradDeviceTypeCUDA": 1.6449999999999994, "TestAutogradForwardMode": 0.069, "TestAutogradForwardModeBatchedGrad": 0.016, "TestAutogradFunctional": 9.959000000000003, "TestAutogradInferenceMode": 0.062000000000000006, "TestAutogradMultipleDispatchCUDA": 0.02, "TestMultithreadAutograd": 0.334, "TestNestedCheckpoint": 0.41100000000000003}, "test_autograd_fallback": {"TestAutogradFallback": 0.272}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 130.54400000000092}, "test_bundled_inputs": {"TestBundledInputs": 1.4089999999999994}, "test_comparison_utils": {"TestComparisonUtils": 0.393}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.135}, "test_content_store": {"TestContentStoreCUDA": 6.837}, "test_cpp_api_parity": {"TestCppApiParity": 15.518999999999973}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.486, "TestORTTensor": 0.09000000000000001, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.003, "TestTorchLibrary": 0.055}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.29600000000000004, "TestORTTensor": 0.202, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.003, "TestTorchLibrary": 0.049}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 385.056}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 32.861}, "test_cuda": {"TestBlockStateAbsorption": 0.0, "TestCuda": 44.59100000000001, "TestCudaMallocAsync": 9.882000000000001}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 46.734, "TestCudaMallocAsync": 29.002000000000002}, "test_cuda_multigpu": {"TestCudaComm": 0.03600000000000001, "TestCudaMultiGPU": 1.4199999999999997}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.003}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.8410000000000001, "TestEventHandler": 0.02700000000000001, "TestMessages": 0.004}, "test_cuda_trace": {"TestCudaTrace": 1.9380000000000002}, "test_custom_ops": {"MiniOpTest": 0.5010000000000001, "MiniOpTestOther": 0.051000000000000004, "TestCustomOp": 1.5129999999999963, "TestCustomOpTestingCUDA": 1.77, "TestGenerateOpcheckTests": 0.10700000000000001}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 99.934, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.043, "TestCustomPinFn": 0.214, "TestDataLoader": 60.12000000000002, "TestDataLoaderDeviceTypeCUDA": 12.981, "TestDataLoaderPersistentWorkers": 92.05699999999997, "TestDatasetRandomSplit": 0.04900000000000001, "TestDictDataLoader": 0.045, "TestIndividualWorkerQueue": 0.002, "TestNamedTupleDataLoader": 0.004, "TestSetAffinity": 0.045, "TestStackDataset": 0.10800000000000001, "TestStringDataLoader": 0.057, "TestTensorDataset": 0.018000000000000002}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.003, "TestFunctionalIterDataPipe": 2.168, "TestFunctionalMapDataPipe": 0.04, "TestGraph": 0.013, "TestIterDataPipeCountSampleYielded": 0.008, "TestIterDataPipeGraphFastForward": 0.046, "TestIterDataPipeSingletonConstraint": 0.021, "TestIterableDataPipeBasic": 0.032999999999999995, "TestSerialization": 0.002, "TestSharding": 1.1629999999999996, "TestStreamWrapper": 0.357, "TestTyping": 0.007}, "test_decomp": {"DecompOneOffTestsCUDA": 0.022000000000000002, "HasDecompTest": 0.149, "TestDecompCUDA": 17381.96600000008}, "test_deploy": {"TestFreezer": 0.274}, "test_dispatch": {"TestDispatch": 58.21, "TestPythonDispatcher": 0.06}, "test_dlpack": {"TestTorchDlPackCUDA": 0.36400000000000016}, "test_dynamic_shapes": {"TestDimConstraints": 3.451, "TestFloorDiv": 0.062, "TestPySymInt": 1.5439999999999998, "TestSymNumberMagicMethods": 1.169999999999999}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 4.663999999999996, "TestExpandedWeightHelperFunctionCUDA": 0.457, "TestExpandedWeightModuleCUDA": 19.452}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04400000000000001, "FakeTensorConverterTest": 0.020000000000000004, "FakeTensorOpInfoTestCUDA": 0.18900000000000003, "FakeTensorOperatorInvariants": 0.259, "FakeTensorPropTest": 0.034999999999999996, "FakeTensorTest": 0.48300000000000015}, "test_flop_counter": {"TestFlopCounter": 0.6290000000000001}, "test_foreach": {"TestForeachCUDA": 324.3020000000007}, "test_function_schema": {"TestFunctionSchema": 0.7360000000000001}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 42.550999999999995}, "test_functional_optim": {"TestFunctionalOptimParity": 0.39899999999999997}, "test_functionalization": {"TestCrossRefFunctionalization": 2.346999999999999, "TestFunctionalization": 3.0059999999999962}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 3.4139999999999997}, "test_futures": {"TestFuture": 1.039}, "test_fx": {"AnnotationsTest": 0.012000000000000004, "TestCSEPass": 0.30500000000000005, "TestCommonPass": 0.2980000000000001, "TestConstFold": 0.15400000000000005, "TestConstParamShapeInControlFlow": 0.039, "TestDCE": 0.027, "TestFX": 3.0599999999999947, "TestFXAPIBackwardCompatibility": 0.023, "TestFunctionalTracing": 0.2910000000000002, "TestMatcher": 1.1359999999999997, "TestOperatorSignaturesCUDA": 0.6770000000000005, "TestPassManager": 0.020999999999999998, "TestSourceMatcher": 1.188, "TestSubgraphRewriter": 0.3900000000000001, "TestVisionTracing": 280.237, "TypeCheckerTest": 1.8809999999999985}, "test_fx_experimental": {"TestFXExperimental": 15.075999999999999, "TestNormalizeOperatorsCUDA": 0.6930000000000005, "TestTranslationValidation": 0.135}, "test_fx_passes": {"TestFXGraphPasses": 0.5570000000000002, "TestFXMatcherUtils": 0.14700000000000005}, "test_fx_reinplace_pass": {"TestReinplacePass": 1.4579999999999997}, "test_import_stats": {"TestImportTime": 5.0280000000000005}, "test_indexing": {"NumpyTestsCUDA": 0.11400000000000003, "TestIndexingCUDA": 2.288999999999998}, "test_itt": {"TestItt": 0.233}, "test_jit": {"TestAliasAnalysis": 0.025, "TestAsync": 0.36300000000000004, "TestAtenPow": 0.023, "TestAutodiffJit": 0.056999999999999995, "TestAutodiffSubgraphSlicing": 0.2610000000000001, "TestAwait": 0.16000000000000006, "TestBackends": 0.003, "TestBackendsWithCompiler": 0.13, "TestBatchMM": 0.076, "TestBuiltins": 0.052, "TestCUDA": 0.816, "TestClassType": 0.7700000000000004, "TestComplex": 0.7210000000000002, "TestCustomOperators": 0.05000000000000002, "TestDCE": 0.017, "TestDataParallel": 0.002, "TestDataclasses": 4.151999999999998, "TestDeviceAnalysis": 4.0600000000000005, "TestDict": 0.39700000000000013, "TestDtypeAnalysis": 0.239, "TestEnum": 0.14300000000000004, "TestFreezing": 1.0600000000000007, "TestFrontend": 0.055, "TestFrozenOptimizations": 10.916000000000002, "TestFunctionalBlocks": 0.008, "TestFunctionalToInplaceActivation": 2.086, "TestGenerator": 0.05500000000000001, "TestGetDefaultAttr": 0.006, "TestGraphRewritePasses": 0.062, "TestHash": 0.07, "TestHooks": 0.6230000000000002, "TestIgnorableArgs": 0.009000000000000001, "TestIgnoreContextManager": 0.04, "TestInplaceToFunctionalActivation": 1.635, "TestIsinstance": 0.18400000000000005, "TestJit": 7.8839999999999995, "TestJitGeneratedModule": 14.260999999999944, "TestJitProfiler": 0.001, "TestJitUtils": 0.012000000000000004, "TestList": 1.2280000000000004, "TestLogging": 0.041, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.622, "TestMixTracingScripting": 0.8740000000000001, "TestModels": 9.216999999999999, "TestModuleAPIs": 0.114, "TestModuleContainers": 1.1580000000000001, "TestModuleInterface": 0.3420000000000001, "TestModules": 0.012, "TestNamedTuple": 0.06999999999999999, "TestNnapiBackend": 7.524000000000001, "TestOpDecompositions": 0.014, "TestOptimizeForMobilePreserveDebugInfo": 0.14500000000000002, "TestParametrization": 0.083, "TestPeephole": 0.3970000000000002, "TestProducerVersion": 0.001, "TestProfiler": 0.262, "TestPythonBindings": 0.037, "TestPythonBuiltinOP": 0.31100000000000005, "TestPythonIr": 0.007, "TestRecursiveScript": 0.5520000000000002, "TestRemoveMutation": 0.11400000000000002, "TestSaveLoad": 112.749, "TestSaveLoadFlatbuffer": 0.23700000000000004, "TestSaveLoadForOpVersion": 3.1849999999999996, "TestScript": 20.801000000000002, "TestScriptDict": 0.026000000000000002, "TestScriptList": 0.037000000000000005, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.13399999999999998, "TestScriptProfile": 0.668, "TestSlice": 0.13300000000000006, "TestSparse": 0.071, "TestStringFormatting": 0.13900000000000007, "TestSymbolicShapeAnalysis": 1.2329999999999994, "TestTensorBuiltins": 0.09, "TestTensorCreationOps": 0.042, "TestTensorMethods": 0.012, "TestTorchbind": 0.12300000000000003, "TestTracer": 4.910999999999996, "TestTypeSharing": 0.4110000000000001, "TestTypesAndAnnotation": 0.09200000000000003, "TestTyping": 0.3410000000000002, "TestUnion": 0.39000000000000024, "TestUnsupportedOps": 0.024, "TestUpgraders": 0.05500000000000001, "TestWarn": 0.044000000000000004, "TestWith": 0.261}, "test_jit_autocast": {"TestAutocast": 2.0129999999999986, "TestJitTraceAutocast": 15.192000000000002}, "test_jit_disabled": {"TestJitDisabled": 0.379}, "test_jit_fuser_te": {"TestFuserCommon": 0.108, "TestNNCOpInfoCUDA": 7.202999999999488, "TestTEFuserDynamic": 835.1029999999998, "TestTEFuserStatic": 795.915}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.167, "TestFusionPatternCUDA": 0.010000000000000002, "TestModel": 0.002, "TestOpCUDA": 0.002}, "test_jiterator": {"TestPythonJiteratorCUDA": 28.949999999999974}, "test_legacy_vmap": {"TestVmapAPI": 1.2249999999999983, "TestVmapBatchedGradientCUDA": 0.7350000000000002, "TestVmapOperators": 1.086}, "test_license": {"TestLicense": 0.253}, "test_linalg": {"TestLinalgCUDA": 619.3119999999914}, "test_logging": {"LoggingTest": 2.773}, "test_masked": {"TestMaskedCUDA": 24.021000000000008}, "test_maskedtensor": {"TestBasicsCUDA": 0.31, "TestBinary": 0.2730000000000002, "TestOperatorsCUDA": 4.300999999999948, "TestReductions": 0.06400000000000002, "TestUnary": 0.2450000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.007, "TestMatmulCudaCUDA": 58.967, "TestMixedDtypesLinearCudaCUDA": 0.0}, "test_meta": {"TestMetaCUDA": 2265.6409999998114, "TestMetaConverter": 2.0650000000000004}, "test_mkl_verbose": {"TestMKLVerbose": 4.346}, "test_mkldnn_fusion": {"TestMkldnnFusion": 36.047999999999995}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.189}, "test_mobile_optimizer": {"TestOptimizer": 2.9269999999999996}, "test_model_dump": {"TestModelDump": 1.289}, "test_module_init": {"TestModuleInitCUDA": 1.4419999999999937}, "test_modules": {"TestModuleCUDA": 2578.6169999999825}, "test_monitor": {"TestMonitor": 0.273, "TestMonitorTensorboard": 0.162}, "test_multiprocessing": {"TestMultiprocessing": 49.797999999999995}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.483, "SpawnTest": 22.618}, "test_namedtensor": {"TestNamedTensor": 2.3349999999999964}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.081}, "test_native_functions": {"TestNativeFunctions": 0.805}, "test_native_mha": {"TestMHADeviceTypeCUDA": 1.3039999999999967}, "test_nestedtensor": {"TestNestedTensor": 0.3890000000000001, "TestNestedTensorAutogradCUDA": 1.2349999999999994, "TestNestedTensorDeviceTypeCUDA": 4.040999999999993, "TestNestedTensorSubclassCUDA": 0.2870000000000002}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.4, "TestFusionUtils": 0.004, "TestNN": 82.61600000000026, "TestNNDeviceTypeCUDA": 117.36500000000423}, "test_numba_integration": {"TestNumbaIntegration": 0.381}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.29000000000000004}, "test_openmp": {"TestOpenMP_ParallelFor": 5.329000000000001}, "test_ops": {"TestCommonCUDA": 4673.108999999925, "TestCompositeComplianceCUDA": 1626.0059999999962, "TestFakeTensorCUDA": 573.887, "TestMathBitsCUDA": 145.95600000000007, "TestTagsCUDA": 1.0360000000000007}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1613.2639999999728}, "test_ops_gradients": {"TestBwdGradientsCUDA": 2761.1009999999387}, "test_ops_jit": {"TestJitCUDA": 1993.7589999999957}, "test_optim": {"TestDifferentiableOptimizer": 0.183, "TestLRScheduler": 0.6270000000000003, "TestOptim": 188.53500000000003, "TestSWAUtils": 1.998}, "test_out_dtype_op": {"TestOutDtypeOp": 1.6749999999999996}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.004, "TestGradCheckOverride": 0.015, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.002, "TestRNN": 0.002, "TestResolveName": 0.079, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 1.8329999999999234, "TestTorchFunctionWarning": 0.011, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.039, "ModelTest": 0.001, "TestAnalyze": 0.001, "TestDependencyAPI": 0.069, "TestDependencyHooks": 0.007, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.009000000000000001, "TestLoadBCPackages": 0.048, "TestMangling": 0.012, "TestMisc": 0.030000000000000006, "TestPackageFX": 0.066, "TestPackageScript": 1.7269999999999994, "TestRepackage": 0.006, "TestResources": 0.336, "TestSaveLoad": 0.031}, "test_per_overload_api": {"TestPerOverloadAPI": 0.412}, "test_prims": {"TestDecompCUDA": 0.017, "TestPrimsBasic": 0.277, "TestPrimsCUDA": 0.7080000000000002, "TestRefsCUDA": 0.011000000000000003}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.11300000000000002, "TestGenericProxyTensorFake": 1.9669999999999999, "TestGenericProxyTensorReal": 3.2049999999999983, "TestGenericProxyTensorSymbolic": 21.101000000000003, "TestSymbolicTracing": 4.7989999999999995}, "test_pruning_op": {"PruningOpTest": 0.64}, "test_public_bindings": {"TestPublicBindings": 6.405}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.021, "TestPythonDispatch": 0.12100000000000005, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 0.19400000000000003, "TestWrapperSubclassAliasingCUDA": 0.17800000000000005}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 0.4100000000000001, "TestPythonPytree": 0.01900000000000001}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011, "TestAOMigrationNNQuantized": 0.031, "TestAOMigrationQuantization": 0.015, "TestAOMigrationQuantizationFx": 0.02, "TestBackendConfig": 0.03200000000000001, "TestBiasCorrectionEager": 0.9510000000000001, "TestBits": 0.003, "TestComparatorOps": 1.337, "TestDeprecatedJitQuantized": 3.8449999999999998, "TestDistributed": 0.027000000000000003, "TestDuplicateDQPass": 161.363, "TestDynamicQuantizedModule": 35.302, "TestDynamicQuantizedOps": 25.087, "TestEqualizeEager": 0.10500000000000001, "TestEqualizeFx": 5.511, "TestFXGraphMatcher": 1.6410000000000002, "TestFXGraphMatcherModels": 7.859999999999999, "TestFXNumericSuiteCoreAPIs": 37.1, "TestFXNumericSuiteCoreAPIsModels": 30.212000000000003, "TestFXNumericSuiteNShadows": 45.550999999999995, "TestFakeQuantize": 0.265, "TestFakeQuantizeOps": 27.405000000000005, "TestFloat8DtypeCUDA": 0.337, "TestFuseEager": 2.753, "TestFuseFx": 2.02, "TestFusedObsFakeQuant": 0.23099999999999998, "TestFusedObsFakeQuantModule": 0.303, "TestFusionPasses": 0.017, "TestFxDetectInputWeightEqualization": 0.23, "TestFxDetectOutliers": 0.312, "TestFxModelReportClass": 0.775, "TestFxModelReportDetectDynamicStatic": 0.138, "TestFxModelReportDetector": 0.326, "TestFxModelReportObserver": 0.20099999999999998, "TestFxModelReportVisualizer": 0.323, "TestGraphUtils": 3.912, "TestHistogramObserver": 37.711, "TestMetaDataPorting": 186.71699999999998, "TestModelNumericsEager": 0.9369999999999999, "TestNumericSuiteEager": 6.4670000000000005, "TestObserver": 0.903, "TestPT2ERepresentation": 879.0029999999999, "TestPadding": 8.594, "TestQNNPackOps": 5.652, "TestQuantizationDocs": 0.214, "TestQuantizeDynamicJitOps": 1.827, "TestQuantizeDynamicJitPasses": 3.9290000000000003, "TestQuantizeEagerOps": 1.3589999999999998, "TestQuantizeEagerPTQDynamic": 6.947, "TestQuantizeEagerPTQStatic": 18.220999999999997, "TestQuantizeEagerQAT": 10.82, "TestQuantizeEagerQATNumerics": 2.0589999999999997, "TestQuantizeFx": 22.969999999999995, "TestQuantizeFxModels": 10.695, "TestQuantizeFxOps": 95.00100000000003, "TestQuantizeJit": 6.892000000000001, "TestQuantizeJitOps": 206.98399999999998, "TestQuantizeJitPasses": 5.343, "TestQuantizePT2E": 800.129, "TestQuantizePT2EQAT": 1116.465, "TestQuantizePT2EQATModels": 214.14499999999998, "TestQuantizePT2EX86Inductor": 1242.485, "TestQuantizedConv": 47.949000000000005, "TestQuantizedEmbeddingOps": 0.6880000000000001, "TestQuantizedFunctionalOps": 3.318, "TestQuantizedLinear": 8.395999999999999, "TestQuantizedOps": 74.299, "TestQuantizedTensor": 2.622, "TestRecordHistogramObserver": 0.033, "TestReferenceQuantizedModule": 0.041999999999999996, "TestSerialization": 1.7080000000000002, "TestStaticQuantizedModule": 132.92499999999998, "TestSubgraphRewriter": 0.958, "TestUtils": 0.02, "TestXNNPACKQuantizer": 804.861, "TestXNNPACKQuantizerModels": 37.473}, "test_reductions": {"TestReductionsCUDA": 101.02000000000308}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 20.523}, "test_schema_check": {"TestSchemaCheck": 0.3500000000000001, "TestSchemaCheckModeOpInfoCUDA": 619.9819999999933}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 2.3240000000000003}, "test_serialization": {"TestBothSerializationCUDA": 0.151, "TestOldSerialization": 20.673999999999996, "TestSerialization": 8.417000000000003, "TestSubclassSerialization": 0.01}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.318}, "test_shape_ops": {"TestShapeOpsCUDA": 31.575000000000017}, "test_show_pickle": {"TestShowPickle": 0.295}, "test_sort_and_select": {"TestSortAndSelectCUDA": 5.384999999999997}, "test_sparse": {"TestSparseAnyCUDA": 917.518999999998, "TestSparseCUDA": 23.357000000000024, "TestSparseLegacyAndDeprecation": 0.274, "TestSparseMaskedReductionsCUDA": 1.7129999999999994, "TestSparseMeta": 0.002, "TestSparseOneOff": 0.13699999999999998, "TestSparseUnaryUfuncsCUDA": 3.3159999999999146}, "test_sparse_csr": {"TestSparseCSRCUDA": 181.08300000000358, "TestSparseCSRSampler": 0.384, "TestSparseCompressedCUDA": 116.10400000000087, "TestSparseCompressedTritonKernelsCUDA": 0.06000000000000003}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.001, "TestSparseSemiStructuredCUDA": 0.02100000000000001}, "test_spectral_ops": {"TestFFTCUDA": 263.97700000000003}, "test_stateless": {"TestPythonOptimizeMode": 3.965, "TestStatelessDeprecation": 2.175, "TestStatelessFunctionalAPI": 0.40100000000000013}, "test_subclass": {"TestSubclass": 1.2279999999999966}, "test_sympy_utils": {"TestSingletonInt": 0.005, "TestSympyInterp": 0.4530000000000001, "TestSympySolve": 0.17, "TestValueRanges": 20.503999999999998}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.4950000000000004, "TestLikeTensorCreationCUDA": 0.007, "TestRandomTensorCreationCUDA": 0.6100000000000001, "TestTensorCreationCUDA": 171.88100000000026}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.012, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.007, "TestTensorBoardPyTorchNumpy": 0.551, "TestTensorBoardPytorchGraph": 22.577, "TestTensorBoardSummary": 0.041000000000000016, "TestTensorBoardSummaryWriter": 0.007, "TestTensorBoardUtils": 0.148, "TestTensorBoardWriter": 0.082, "TestTensorProtoSummary": 0.008}, "test_tensorexpr": {"TestTensorExprFuser": 86.92600000000004}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.007, "TestTensorExprPyBind": 0.7070000000000002}, "test_testing": {"TestAssertClose": 0.09600000000000004, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.05900000000000001, "TestAssertCloseMultiDeviceCUDA": 0.008, "TestAssertCloseQuantized": 0.01, "TestAssertCloseSparseBSC": 0.014, "TestAssertCloseSparseBSR": 0.015, "TestAssertCloseSparseCOO": 0.023, "TestAssertCloseSparseCSC": 0.016, "TestAssertCloseSparseCSR": 0.020999999999999998, "TestFrameworkUtils": 12.066, "TestImports": 14.234, "TestMakeTensorCUDA": 1.0919999999999934, "TestOpInfoSampleFunctionsCUDA": 1.1589999999999867, "TestOpInfos": 0.003, "TestTestParametrization": 0.02100000000000001, "TestTestParametrizationDeviceTypeCUDA": 3.190999999999998, "TestTestingCUDA": 0.5610000000000002}, "test_torch": {"TestBasicVitalSigns": 0.027000000000000003, "TestDevicePrecisionCUDA": 0.08800000000000002, "TestTorch": 3.0789999999999864, "TestTorchDeviceTypeCUDA": 138.4580000000002, "TestVitalSignsCudaCUDA": 0.048}, "test_transformers": {"TestSDPACUDA": 0.25000000000000017, "TestSDPACudaOnlyCUDA": 41.258999999994444, "TestSDPAFailureModesCUDA": 0.048000000000000015, "TestTransformersCUDA": 5.983999999999999}, "test_type_hints": {"TestTypeHints": 0.282}, "test_type_info": {"TestDTypeInfo": 0.263}, "test_type_promotion": {"TestTypePromotionCUDA": 15.823000000000023}, "test_typing": {"TestTyping": 61.02999999999999}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 288.607000000064}, "test_utils": {"TestAssert": 0.065, "TestBottleneck": 19.732000000000003, "TestCheckpoint": 0.922, "TestCollectEnv": 1.392, "TestCppExtensionUtils": 0.209, "TestDataLoaderUtils": 0.2, "TestDeviceUtilsCUDA": 5.935000000000213, "TestExtensionUtils": 0.008, "TestHipify": 0.002, "TestONNXUtils": 0.006, "TestRenderUtils": 0.012, "TestStandaloneCPPJIT": 16.891, "TestTraceback": 0.013999999999999999}, "test_view_ops": {"TestOldViewOpsCUDA": 17.064000000000004, "TestViewOpsCUDA": 4.203000000000005}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryTestCase": 0.024, "WeakTest": 5.615999999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 72.389, "TestXNNPACKOps": 2.029, "TestXNNPACKRewritePass": 0.861, "TestXNNPACKSerDes": 2.842}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.001}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.264, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.003, "TestPickling": 0.083, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 13.711, "TestEinsumPath": 0.0, "TestMisc": 0.005}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.001, "TestHalf": 0.0, "TestIinfo": 0.803, "TestMisc": 0.003, "TestPythonFloat": 0.001, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.003, "TestBooleanIndexing": 0.034, "TestBroadcastedAssignments": 0.077, "TestFancyIndexingCast": 0.004, "TestFloatNonIntegerArgument": 0.007, "TestIndexing": 0.6270000000000001, "TestMultiIndexingAutomated": 0.008, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.04100000000000001, "TestArgmax": 0.7880000000000005, "TestArgmaxArgminCommon": 0.04700000000000002, "TestArgmin": 0.8900000000000006, "TestArrayAttributeDeletion": 0.008, "TestArrayConstruction": 0.027000000000000007, "TestArrayCreationCopyArgument": 0.005, "TestArrayInterface": 0.032999999999999995, "TestAssignment": 0.08900000000000001, "TestAttributes": 0.018000000000000006, "TestBinop": 0.013, "TestBool": 17.994, "TestCequenceMethods": 0.002, "TestChoose": 0.013000000000000001, "TestClip": 0.006, "TestCompress": 0.003, "TestConversion": 0.034, "TestCreation": 0.001, "TestDelMisc": 0.002, "TestDot": 0.05400000000000002, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.021, "TestFlag": 0.012000000000000004, "TestFormat": 0.006, "TestFromBuffer": 0.011000000000000003, "TestHash": 0.366, "TestHashing": 0.004, "TestIO": 0.002, "TestInner": 0.161, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.7270000000000002, "TestMatmulOperator": 0.6220000000000001, "TestMethods": 1.1620000000000004, "TestMinMax": 0.005, "TestMinScalarType": 0.008, "TestNewaxis": 0.003, "TestPEP3118Dtype": 0.003, "TestPutmask": 0.008, "TestRepeat": 0.017, "TestResize": 0.035, "TestRichcompareScalar": 0.002, "TestScalarIndexing": 0.025, "TestSortFloatMisc": 0.13600000000000007, "TestStats": 0.262, "TestSubscripting": 0.001, "TestTake": 0.03900000000000001, "TestVdot": 0.028999999999999998, "TestWarnings": 0.002, "TestWhere": 0.469, "TestWritebackIfCopy": 0.031000000000000003}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.013999999999999999, "TestArgwhere": 0.028999999999999998, "TestArrayComparisons": 0.016, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.007, "TestBoolArray": 2.7119999999999997, "TestBoolCmp": 0.165, "TestBoolScalar": 0.007, "TestBroadcast": 0.006, "TestClip": 0.31200000000000006, "TestConvolve": 0.021, "TestCorrelate": 0.062, "TestCreationFuncs": 0.775, "TestCross": 0.056, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.007, "TestFromiter": 0.001, "TestIndex": 0.005, "TestIndices": 0.026000000000000002, "TestIsclose": 0.059, "TestIsscalar": 0.118, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.021000000000000005, "TestNonarrayArgs": 0.08900000000000002, "TestNonzeroAndCountNonzero": 0.18300000000000002, "TestOuterMisc": 0.006, "TestRequire": 0.004, "TestResize": 0.21200000000000002, "TestRoll": 0.035, "TestRollaxis": 0.005, "TestSeterr": 0.005, "TestStdVar": 0.016, "TestStdVarComplex": 0.007, "TestStringFunction": 0.002, "TestTensordot": 0.016, "TestTypes": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.002, "TestCommonType": 0.314, "TestDocStrings": 0.001, "TestIsSubDType": 0.012, "TestScalarTypeNames": 0.033000000000000015}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06300000000000004, "TestFromInt": 0.5640000000000001, "TestFromString": 0.34}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.001, "TestBitCount": 0.0, "TestClassGetItem": 0.002, "TestClassGetitemMisc": 0.183, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.002}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.08999999999999998, "TestBaseMath": 7.685, "TestBitShifts": 0.078, "TestComplexDivision": 0.056999999999999995, "TestConversion": 0.048, "TestHash": 0.001, "TestModulus": 0.913, "TestMultiply": 0.0, "TestNegative": 0.024, "TestPower": 0.097, "TestRepr": 0.001, "TestScalarOpsMisc": 0.10200000000000004, "TestScalarSubclassingMisc": 0.011000000000000003, "TestSubtract": 0.024, "TestTypes": 14.540000000000001}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.912, "TestAtleast2d": 0.016, "TestAtleast3d": 0.012, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.3040000000000001, "TestHstack": 0.016, "TestStackMisc": 0.005, "TestVstack": 0.018000000000000002}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.01, "TestFFTShift": 6.5729999999999995, "TestIRFFTN": 0.008, "TestRFFTFreq": 0.01}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.803, "TestFFTShift": 0.876, "TestFFTThreadSafe": 0.7150000000000001}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.779}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.065, "TestUnique": 0.43900000000000006}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.007, "TestAmax": 0.007, "TestAmin": 0.007, "TestAngle": 0.008, "TestAny": 0.008, "TestAverage": 0.138, "TestBincount": 0.07400000000000002, "TestCheckFinite": 0.004, "TestCopy": 0.008, "TestCorrCoef": 0.037000000000000005, "TestCov": 0.085, "TestCumprod": 0.039, "TestCumsum": 0.042, "TestDelete": 0.021000000000000005, "TestDiff": 0.11499999999999999, "TestDigitize": 0.015000000000000003, "TestExtins": 0.006, "TestFilterwindows": 0.8010000000000006, "TestFlip": 0.03300000000000001, "TestGradient": 0.171, "TestInsert": 0.014000000000000002, "TestInterp": 0.04100000000000002, "TestKaiser": 0.013000000000000001, "TestMedian": 0.124, "TestMeshgrid": 0.061, "TestMsort": 0.0, "TestPercentile": 0.13700000000000007, "TestPiecewise": 0.012, "TestProd": 0.036, "TestPtp": 0.011, "TestQuantile": 0.03600000000000002, "TestRot90": 0.47, "TestSelect": 0.007, "TestSinc": 0.01, "TestSortComplex": 0.01, "TestTrapz": 0.007, "TestTrimZeros": 0.012000000000000004, "TestUnique": 0.009000000000000001, "Test_I0": 0.024}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 1.3099999999999994, "TestHistogramOptimBinNums": 0.029000000000000012, "TestHistogramdd": 0.203}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.024, "TestDiagIndices": 0.004, "TestDiagIndicesFrom": 0.005, "TestFillDiagonal": 0.018000000000000002, "TestGrid": 0.533, "TestIndexExpression": 0.008, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.273}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.013000000000000001, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.17000000000000004, "TestColumnStack": 0.009000000000000001, "TestDsplit": 0.009000000000000001, "TestDstack": 0.014000000000000002, "TestExpandDims": 0.005, "TestHsplit": 0.011, "TestKron": 0.014000000000000002, "TestMayShareMemory": 0.002, "TestPutAlongAxis": 0.016, "TestSplit": 0.007, "TestSqueeze": 0.03900000000000001, "TestTakeAlongAxis": 0.966, "TestTile": 0.083, "TestVsplit": 0.007}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.138, "TestEye": 1.008, "TestFliplr": 0.01, "TestFlipud": 0.006, "TestHistogram2d": 0.055, "TestTri": 0.114, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.004, "TestTriuIndicesFrom": 0.002, "TestVander": 0.026}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.721, "TestImag": 0.008, "TestIscomplex": 0.003, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.005, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.004, "TestNanToNum": 0.008, "TestReal": 0.009000000000000001, "TestRealIfClose": 0.003}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.20099999999999998, "TestCond": 0.20199999999999999, "TestDet": 0.14200000000000002, "TestEig": 0.03300000000000001, "TestEigh": 0.03900000000000001, "TestEighCases": 0.0, "TestEigvals": 0.051000000000000004, "TestEigvalsh": 0.036000000000000004, "TestEigvalshCases": 0.001, "TestInv": 0.044000000000000004, "TestLstsq": 0.279, "TestMatrixRank": 0.34600000000000003, "TestMisc": 0.07, "TestMisc2": 0.013, "TestMultiDot": 0.069, "TestNormDouble": 0.931, "TestNormInt64": 0.9390000000000001, "TestNormSingle": 0.9420000000000002, "TestNorm_NonSystematic": 0.003, "TestPinv": 0.1, "TestPinvHermitian": 0.031, "TestQR": 1.1259999999999961, "TestSVD": 0.038000000000000006, "TestSVDHermitian": 0.088, "TestSolve": 0.273, "TestTensorinv": 0.033, "TestTensorsolve": 0.013000000000000001}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.148, "TestCtorNested": 0.002, "TestDefaultDtype": 0.004, "TestDivmod": 0.020000000000000004, "TestExport": 0.0, "TestMisc": 0.433, "TestNormalizations": 0.006, "TestOneArr": 0.7180000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.006, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.021, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.769}, "torch_np/test_dtype": {"TestConvertDType": 0.32000000000000006}, "torch_np/test_function_base": {"TestAppend": 0.893}, "torch_np/test_ndarray_methods": {"TestAmax": 0.006, "TestAmin": 0.006, "TestArgmax": 0.7230000000000004, "TestArgmaxArgminCommon": 0.15200000000000002, "TestArgmin": 0.8130000000000005, "TestContains": 0.002, "TestIndexing": 0.179, "TestIter": 0.003, "TestNoExtraMethods": 0.006, "TestNonzero": 0.113, "TestRavel": 0.005, "TestReshape": 0.003, "TestTranspose": 0.094}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.03000000000000001, "TestNEP50Table": 0.001}, "torch_np/test_random": {"TestChoice": 0.008, "TestNumpyGlobal": 0.003, "TestScalarReturn": 0.31000000000000005, "TestShuffle": 0.015000000000000003}, "torch_np/test_reductions": {"TestAll": 0.007, "TestAny": 0.009000000000000001, "TestFlatnonzero": 0.67, "TestGenericCumSumProd": 0.022, "TestGenericReductions": 1.7079999999999638, "TestMean": 0.022, "TestSum": 0.189}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.34500000000000003, "TestIsScalar": 0.13000000000000003}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3920000000000003, "TestNdarrayDunderVsUfunc": 0.29500000000000015, "TestUfuncDtypeKwd": 0.004, "TestUnaryUfuncs": 0.785}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 1.0799999999999998}}, "distributed": {"distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 44.803}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 25.021}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 4.457}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 21.509}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 9.937000000000001}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 12.157}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 4.457}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 0.723}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 43.065999999999995}, "distributed/_composable/test_contract": {"TestContract": 0.191}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 7.377, "ReplicateTest": 24.171}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 18.672}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.245}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 10.623999999999999, "TestShardingSpec": 0.35300000000000004}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.323}, "distributed/_tensor/test_api": {"DTensorAPITest": 17.584}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 29.241}, "distributed/_tensor/test_device_mesh": {"DeviceMeshCollectiveTest": 27.787, "DeviceMeshTest": 17.501, "DeviceMeshTestNDim": 7.56, "InitDeviceMeshTest": 11.846, "TestDeviceMeshGetItem": 23.285999999999998}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 30.969, "DTensorTest": 63.948, "TestDTensorPlacementTypes": 3.57}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 1.6280000000000001, "TestDTensorCompileE2E": 9.154}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 12.786}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 21.736, "DTensorInitOpsTest": 4.477}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 13.725999999999999}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 37.667}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.166, "TestEinsumDims": 0.17200000000000001, "TestEinsumStrategies": 0.406}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.802}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 4.504, "DistTensorRandomOpTest": 23.056}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 3.102, "RedistributeTest": 30.469000000000005}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 89.18100000000001}, "distributed/_tensor/test_utils": {"UtilTest": 8.303}, "distributed/_tensor/test_view_ops": {"TestViewOps": 7.513}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.247}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 2.361}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 27.3}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 16.891000000000005}, "distributed/algorithms/test_join": {"TestJoin": 31.227}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 2.902}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 8.349, "TestDistributedFailure": 22.223}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.192}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 4.95}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 13.705000000000002, "TestDTensorReshardPlacementChange": 7.558}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 20.514000000000003, "TestDistributedStateDictSaveLoad": 0.484, "TestDistributedStateDictSaveLoadWithSharedTensor": 4.633}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 27.009999999999998, "TestDistributedStateDictSaveLoad": 0.488, "TestDistributedStateDictSaveLoadWithSharedTensor": 6.855}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 8.149000000000001}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 5.623}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 6.227}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.486, "TestFSSpecWithDist": 6.135}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 11.984}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.195}, "distributed/checkpoint/test_planner": {"TestPlannerHelpers": 0.001, "TestSavePlan": 0.198}, "distributed/checkpoint/test_state_dict": {"TestStateDict": 41.397}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 6.031}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.2}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.17500000000000002}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.227, "RdzvEventLibTest": 0.045000000000000005}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.278}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.226, "StartProcessesListTest": 15.113000000000001, "StartProcessesTest": 11.412, "StdTest": 0.003}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 9.545}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.15000000000000002, "LocalTimerTest": 2.519, "MultiprocessingRequestQueueTest": 1.5070000000000001}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 3.4390000000000005}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.265}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.228, "UtilTest": 0.042}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 0.9850000000000001}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 9.062000000000001}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 14.083}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 6.108}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 88.437, "TestFSDPCheckpointSubmodule": 5.048}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 37.265}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 43.419000000000004}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 132.36199999999997}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 7.053, "TestHooks": 39.388999999999996, "TestNoGrad": 309.764, "TestParamInit": 10.177, "TestParityWithDDP": 1366.569}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 75.82100000000001}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 38.252}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 24.441}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 42.625}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 46.935}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.209}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 51.315}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 40.404999999999994}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 63.82899999999999}, "distributed/fsdp/test_fsdp_input": {"TestInput": 9.431000000000001}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 14.963999999999999}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 40.55200000000001}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 104.95, "TestFSDPMiscMultiThread": 0.9110000000000001, "TestFSDPMiscWorldSize1": 0.35900000000000004}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 25.480999999999995, "TestFSDPMixedPrecisionIgnoredModules": 3.234, "TestFSDPMixedPrecisionSharded": 267.10499999999996, "TestFSDPMixedPrecisionUnsharded": 11.705, "TestFSDPTrainEval": 6.252}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 5.549}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 4.604}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 326.649}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 22.04, "TestForwardOverlapWorldSizeTwo": 39.189}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 10.048}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.479, "TestShardedGradScalerParityWithDDP": 80.137}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 801.9599999999996, "TestFSDPStateDict4GPUs": 4.134}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 16.535}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 4.406}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 5.208}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 39.261, "TestUnshardParamsErrors": 16.311, "TestUnshardParamsNoShard": 8.239999999999998}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 4.328, "TestFSDPUseOrigParamsInit": 4.426, "TestFSDPUseOrigParamsMultipleParamGroups": 52.539, "TestFSDPUseOrigParamsNoSync": 9.956, "TestFSDPUseOrigParamsParamAccess": 5.229, "TestFSDPUseOrigParamsUnshardReshard": 28.432000000000002, "TestFSDPUseOrigParamsWriteback": 25.043, "TestMultiTensorApply": 0.045}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 23.881}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 4.421, "TestShardUtilsDistributedDTensor": 0.002}, "distributed/fsdp/test_utils": {"TestUtils": 0.572}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 5.095, "TestFSDPWrap": 102.209, "TestWrapUtils": 0.017}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.234}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 121.63299999999998, "TestZeroRedundancyOptimizerSingleRank": 28.34}, "distributed/pipeline/sync/skip/test_api": {"test_api": 0.007}, "distributed/pipeline/sync/skip/test_gpipe": {"test_gpipe": 3.5049999999999994}, "distributed/pipeline/sync/skip/test_inspect_skip_layout": {"test_inspect_skip_layout": 0.007}, "distributed/pipeline/sync/skip/test_leak": {"test_leak": 0.17800000000000005}, "distributed/pipeline/sync/skip/test_portal": {"TestTensorLife": 0.007, "test_portal": 0.311}, "distributed/pipeline/sync/skip/test_stash_pop": {"test_stash_pop": 0.011000000000000001}, "distributed/pipeline/sync/skip/test_tracker": {"test_tracker": 0.369}, "distributed/pipeline/sync/skip/test_verify_skippables": {"test_verify_skippables": 0.010000000000000002}, "distributed/pipeline/sync/test_balance": {"test_balance": 5.9449999999999985}, "distributed/pipeline/sync/test_bugs": {"test_bugs": 2.2790000000000004}, "distributed/pipeline/sync/test_checkpoint": {"test_checkpoint": 0.65}, "distributed/pipeline/sync/test_copy": {"test_copy": 0.861}, "distributed/pipeline/sync/test_deferred_batch_norm": {"test_deferred_batch_norm": 0.7370000000000001}, "distributed/pipeline/sync/test_dependency": {"test_dependency": 0.289}, "distributed/pipeline/sync/test_inplace": {"test_inplace": 0.223}, "distributed/pipeline/sync/test_microbatch": {"test_microbatch": 0.011000000000000003}, "distributed/pipeline/sync/test_phony": {"test_phony": 0.006}, "distributed/pipeline/sync/test_pipe": {"test_pipe": 2.7799999999999994}, "distributed/pipeline/sync/test_pipeline": {"test_pipeline": 0.002}, "distributed/pipeline/sync/test_stream": {"TestCurrentStream": 0.0, "TestDefaultStream": 0.0, "TestGetDevice": 0.0, "TestNewStream": 0.33, "TestRecordStream": 0.188, "TestUseDevice": 0.0, "TestUseStream": 0.0, "TestWaitStream": 0.553}, "distributed/pipeline/sync/test_transparency": {"test_transparency": 0.087}, "distributed/pipeline/sync/test_worker": {"test_worker": 0.037000000000000005}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 3.173}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"Test2dParallelIntegration": 22.16, "TestNew2dParallelStateDict": 25.588, "TestNew2dParallelTraining": 15.622}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 35.884}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 25.494999999999997}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 2.886}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 34.554}, "distributed/tensor/parallel/test_view_sharding_dim_change": {"TPViewShardingDimChangeTest": 4.288}, "distributed/test_c10d_common": {"CommTest": 3.17, "ComputeBucketAssignmentTest": 0.983, "ProcessGroupWithDispatchedCollectivesTests": 5.934, "PythonProcessGroupExtensionTest": 28.066000000000003, "ReduceOpTest": 1.0150000000000001, "TimeoutTest": 31.313}, "distributed/test_c10d_gloo": {"CommTest": 32.178, "CompilerTest": 36.452000000000005, "DistributedDataParallelTest": 145.83100000000005, "GlooProcessGroupWithDispatchedCollectivesTests": 18.193, "LargeCommTest": 9.334, "ProcessGroupGlooTest": 184.473, "ReducerTest": 0.23299999999999998, "RendezvousEnvTest": 0.187, "TimeoutTest": 3.32}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 16.107999999999997}, "distributed/test_c10d_nccl": {"CommTest": 59.126000000000005, "CompilerTest": 48.594, "DistributedDataParallelTest": 294.44, "LargeCommTest": 8.902, "NcclErrorHandlingTest": 22.230999999999998, "NcclProcessGroupWithDispatchedCollectivesTests": 18.772000000000002, "ProcessGroupNCCLNoGPUTest": 0.001, "ProcessGroupNCCLTest": 100.399, "RendezvousEnvTest": 0.376, "SparseCollective": 3.858, "TimeoutTest": 3.328, "WorkHookTest": 23.870000000000005}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 35.906}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 80.94299999999998, "TestDDPWithWorkWrapper": 80.89}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 3.9170000000000003, "ProcessGroupShareTensorTest": 14.297, "TestDistributedNNFunctionsGloo": 26.354}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 20.015, "TestDistributedNNFunctionsNccl": 35.269999999999996}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.003, "TestDistributedNNFunctionsUcc": 0.006}, "distributed/test_data_parallel": {"TestDataParallel": 7.082999999999998, "TestDataParallelDeviceTypeCUDA": 0.18800000000000006}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 840.5349999999992}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 0.554, "TestMultiProc": 46.352999999999994, "TestSingleProc": 10.299000000000001}, "distributed/test_fake_pg": {"TestFakePG": 1.9309999999999996}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 35.036, "TestExpand": 0.267, "TestGradCollectives": 0.007, "TestMakeFx": 0.182, "TestMetaCollectives": 0.017, "TestOpWaitiness": 0.022, "TestPgTag": 0.027999999999999997, "TestTraceableCollectives": 0.16699999999999998}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 7.518000000000001, "TestCollectivesMultiProc": 96.63700000000001}, "distributed/test_launcher": {"TestDistributedLaunch": 1.285}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.511, "TestCollectivesWithWrapper": 0.29800000000000004}, "distributed/test_nccl": {"TestNCCLCUDA": 0.765}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 30.266, "ProcessGroupNCCLWrapperTest": 23.267999999999997}, "distributed/test_store": {"FileStoreTest": 3.3870000000000005, "HashStoreTest": 1.9560000000000002, "InitPgWithUvStore": 1.585, "LibUvTCPStoreTest": 10.919, "PrefixFileStoreTest": 2.748, "PrefixStoreTest": 0.003, "PrefixTCPStoreTest": 1.983, "PythonStoreTest": 0.269, "RendezvousEnvTest": 0.365, "RendezvousFileTest": 0.5569999999999999, "RendezvousTCPTest": 22.499999999999996, "RendezvousTest": 0.554, "TCPStoreTest": 7.116, "TestMultiThreadedWait": 1.8770000000000002, "TestPythonStore": 2.092, "TimeoutTest": 5.375}}, "slow": {"backends/xeon/test_launch": {"TestTorchrun": 3.2350000000000003}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 366.5839999999999}, "distributions/test_constraints": {"test_constraints": 0.7510000000000002}, "distributions/test_distributions": {"TestAgainstScipy": 0.004, "TestConstraints": 0.002, "TestDistributionShapes": 0.04300000000000003, "TestDistributions": 0.7770000000000001, "TestFunctors": 0.004, "TestJit": 0.008, "TestKL": 0.017000000000000005, "TestLazyLogitsInitialization": 0.002, "TestNumericalStability": 0.010000000000000002, "TestRsample": 0.007, "TestValidation": 0.004}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.24600000000000002}, "dynamo/test_after_aot": {"TestAfterAot": 0.192}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.306}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 0.22200000000000003}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 0.26}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.001, "TestCustomBackendAPI": 0.003, "TestExplainWithBackend": 0.001, "TestOptimizations": 0.23}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 0.201}, "dynamo/test_base_output": {"TestBaseOutput": 0.005}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 0.189}, "dynamo/test_compile": {"InPlaceCompilationTests": 0.192, "PublicTorchCompilerTests": 0.001}, "dynamo/test_comptime": {"ComptimeTests": 0.197}, "dynamo/test_config": {"ConfigTests": 0.189}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.055000000000000035}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 0.23900000000000002}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.234}, "dynamo/test_decorators": {"DecoratorTests": 0.203}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 16.026000000000028, "DynamicShapesCtxManagerTests": 0.03800000000000003, "DynamicShapesExportTests": 43.24799999999998, "DynamicShapesFuncTorchHigherOrderOpTests": 0.04100000000000003, "DynamicShapesFunctionTests": 0.2620000000000002, "DynamicShapesHigherOrderOpTests": 0.10000000000000007, "DynamicShapesMiscTests": 0.4110000000000003, "DynamicShapesNNModuleTests": 0.07400000000000005, "DynamicShapesReproTests": 0.17900000000000013, "DynamicShapesSubGraphTests": 0.046000000000000034, "DynamicShapesTestSDPA": 0.004}, "dynamo/test_exc": {"ExcTests": 0.011}, "dynamo/test_export": {"ExportTests": 0.27200000000000013}, "dynamo/test_export_mutations": {"MutationExportTests": 0.199}, "dynamo/test_frame_init": {"FrameInitTests": 0.189}, "dynamo/test_functions": {"DefaultsTests": 0.02000000000000001, "FunctionTests": 0.45600000000000024}, "dynamo/test_global": {"TestGlobals": 0.196}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.010000000000000002, "FuncTorchHigherOrderOpTests": 0.04100000000000003, "HigherOrderOpTests": 0.32700000000000007, "HigherOrderOpVmapGuardTests": 0.005}, "dynamo/test_hooks": {"HooksTests": 0.21200000000000002}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 0.228}, "dynamo/test_interop": {"InteropTests": 0.193}, "dynamo/test_logging": {"LoggingTests": 0.23300000000000004}, "dynamo/test_minifier": {"MinifierTests": 0.231}, "dynamo/test_misc": {"MiscTests": 0.4150000000000003, "TestTracer": 0.001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.003}, "dynamo/test_modules": {"NNModuleTests": 0.26400000000000007, "OptimizedModuleTest": 0.026000000000000016}, "dynamo/test_nops": {"NopTests": 0.224}, "dynamo/test_optimizers": {"End2EndTests": 0.003, "OptimizerTests": 0.223}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.194}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.198}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.193}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.192}, "dynamo/test_recompiles": {"RecompileTests": 0.198}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.195}, "dynamo/test_repros": {"ReproTests": 0.43600000000000017}, "dynamo/test_sdpa": {"TestSDPA": 0.189}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.198}, "dynamo/test_sources": {"SourceTests": 0.186}, "dynamo/test_subclasses": {"SubclassTests": 0.275, "TestNestedTensor": 0.007}, "dynamo/test_subgraphs": {"SubGraphTests": 0.26}, "dynamo/test_trace_rules": {"TraceRuleTests": 0.197}, "dynamo/test_triton_kernels": {"KernelTests": 0.3500000000000001, "MutationTests": 0.017000000000000008, "NoOptimizationKernelTests": 0.2330000000000001, "no_opt_test_class": 0.1240000000000001}, "dynamo/test_unspec": {"UnspecTests": 0.21700000000000003}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.193}, "export/test_db": {"ExampleTests": 0.22700000000000004}, "export/test_experimental": {"TestExperiment": 0.214}, "export/test_export": {"TestDynamismExpression": 0.003, "TestExport": 0.18400000000000008, "TestExportCustomClass": 0.742, "TestOneOffModelExportResult": 0.005}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.003, "NonStrictExportTestExport": 0.09500000000000007}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.85}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.8116666666666666}, "export/test_lift_unlift": {"TestLiftUnlift": 0.10200000000000001}, "export/test_pass_infra": {"TestPassInfra": 0.19}, "export/test_passes": {"TestPasses": 0.202}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.003, "RetraceExportTestExport": 0.1650000000000001}, "export/test_safeguard": {"TestSafeguard": 0.225}, "export/test_schema": {"TestSchema": 0.187}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.003, "SerDesExportTestExport": 0.18300000000000008}, "export/test_serialize": {"TestDeserialize": 0.04900000000000004, "TestOpVersioning": 0.003, "TestSaveLoad": 0.006, "TestSchemaVersioning": 0.001, "TestSerialize": 0.321, "TestSerializeCustomClass": 0.696}, "export/test_torchbind": {"TestExportTorchbind": 0.9660000000000001}, "export/test_tree_utils": {"TestTreeUtils": 0.19}, "export/test_unflatten": {"TestUnflatten": 0.20600000000000002}, "export/test_upgrade": {"TestUpgrade": 0.197}, "export/test_verifier": {"TestVerifier": 0.198}, "functorch/test_aotdispatch": {"TestAOTAutograd": 0.11200000000000009, "TestAOTDispatch": 0.008, "TestAOTExport": 0.026000000000000016, "TestAOTModuleSimplified": 0.007, "TestPartitioning": 0.012000000000000004}, "functorch/test_control_flow": {"TestControlFlow": 0.293, "TestControlFlowTraced": 0.18100000000000013}, "functorch/test_dims": {"TestMin": 0.41700000000000004, "TestMinFunctorchOnly": 0.035000000000000024}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.02900000000000002, "TestAutogradFunctionVmapAPICUDA": 0.009000000000000001, "TestCompileTransformsCUDA": 0.002, "TestComposabilityCUDA": 0.046000000000000034, "TestExamplesCorrectnessCUDA": 0.02000000000000001, "TestFunctionalizeCUDA": 0.01900000000000001, "TestGradTransformCUDA": 0.06500000000000004, "TestHelpersCUDA": 0.005, "TestHessianCUDA": 0.004, "TestHigherOrderOperatorInteractionCUDA": 0.009000000000000001, "TestJacCUDA": 0.07900000000000006, "TestJvpCUDA": 0.023000000000000013, "TestLinearizeCUDA": 0.005, "TestMakeFunctional": 0.02000000000000001, "TestSliceArgnums": 0.011000000000000003, "TestVmapJvpInplaceViewCUDA": 0.005, "TestVmapOfGradCUDA": 0.007}, "functorch/test_logging": {"TestAOTLogging": 0.226}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.004, "RandomOpTestCase": 0.001, "ReduceTestCase": 0.009000000000000001, "TestMemoryEfficientOpAuthoring": 0.193}, "functorch/test_minifier": {"TestMinifier": 0.188}, "functorch/test_ops": {"TestOperatorsCUDA": 1527.6779999998287}, "functorch/test_parsing": {"TestAnonymousAxis": 0.868, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.915}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.2720000000000002, "TestTransformFailureCUDA": 0.007, "TestVmapAPI": 0.6180000000000001, "TestVmapBatchedGradientCUDA": 0.03200000000000002, "TestVmapDeviceTypeCUDA": 0.005, "TestVmapNestedTensorCUDA": 0.013000000000000005, "TestVmapOperators": 0.16600000000000012, "TestVmapOperatorsOpInfoCUDA": 5.9340000000000765}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.6439999999998225}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.08600000000000006, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.09300000000000007, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.05500000000000004, "AOTInductorTestABICompatibleCuda": 0.08000000000000006, "AOTInductorTestNonABICompatibleCpu": 0.08900000000000007, "AOTInductorTestNonABICompatibleCuda": 0.07900000000000006}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 0.003, "BenchmarkFusionCudaTest": 0.003}, "inductor/test_binary_folding": {"FreezingCpuTests": 0.002, "FreezingCudaTests": 0.002}, "inductor/test_codecache": {"TestFxGraphCache": 0.024000000000000014, "TestFxGraphCacheHashing": 0.004, "test_codecache": 3.097}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.194}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 0.33000000000000024, "TestCompiledAutograd": 0.032000000000000015}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 0.21400000000000016}, "inductor/test_config": {"TestInductorConfig": 0.23500000000000001}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 0.225}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 0.05000000000000004, "DynamicShapesCudaWrapperCudaTests": 613.03, "TestCppWrapper": 837.4259999999992, "TestCudaWrapper": 520.9359999999995}, "inductor/test_cpu_repro": {"CPUReproTests": 1032.0899999999979}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 0.027000000000000017, "TestCudaWrapper": 0.03000000000000002}, "inductor/test_cuda_repro": {"CudaReproTests": 0.04700000000000003}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 0.07200000000000004}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.225}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 0.302}, "inductor/test_debug_trace": {"TestDebugTrace": 0.002}, "inductor/test_dependencies": {"TestDependencies": 0.211}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 183.487, "EfficientConvBNEvalCudaTests": 114.517}, "inductor/test_extension_backend": {"ExtensionBackendTests": 31.346}, "inductor/test_foreach": {"ForeachTests": 0.19900000000000015}, "inductor/test_fp8": {"TestFP8Types": 0.019000000000000006}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 0.019000000000000003, "SDPAPatternRewriterCpuTests": 0.02800000000000001}, "inductor/test_fx_fusion": {"TestFxFusion": 0.193}, "inductor/test_group_batch_fusion": {"TestGroupBatchFusion": 0.221, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.009000000000000001, "TestIndexingSimplification": 0.225}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 0.01800000000000001, "FreezingCudaTests": 0.017000000000000008}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 0.224}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 0.233}, "inductor/test_layout_optim": {"TestLayoutOptim": 0.23}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.003}, "inductor/test_minifier": {"MinifierTests": 0.384}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 0.334}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 0.008, "TestPatternMatcher": 0.275}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.033000000000000015}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 0.017000000000000005}, "inductor/test_multi_kernel": {"MultiKernelTest": 0.232}, "inductor/test_pad_mm": {"PadMMTest": 0.29500000000000004}, "inductor/test_pattern_matcher": {"TestPaternMatcher": 0.03600000000000002, "TestPatternMatcher": 0.04800000000000003}, "inductor/test_perf": {"FusionTests": 0.01800000000000001, "InplacingTests": 0.009000000000000001, "MinCutPartitioningTests": 0.007, "NoopTests": 0.006, "NumBytesMetricTests": 0.24400000000000002, "SchedulerFusionTests": 0.003, "TilingTests": 0.002}, "inductor/test_profiler": {"DynamoProfilerTests": 0.296}, "inductor/test_smoke": {"SmokeTest": 0.222}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 0.007, "MemoryBoundedTests": 0.004, "UnsupportedTests": 0.218}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 0.229}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 0.226}, "inductor/test_storage_offset": {"StorageOffsetTests": 0.003}, "inductor/test_torchinductor": {"CpuTests": 131.04800000000134, "CudaTests": 0.46400000000000036, "GPUTests": 0.5450000000000004, "NanCheckerTest": 0.002, "RNNTest": 0.001, "SweepInputsCpuTest": 0.06500000000000004, "SweepInputsCudaTest": 0.06600000000000004, "SweepInputsGPUTest": 0.06600000000000004, "TestFull": 0.001, "TritonCodeGenTests": 0.01900000000000001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 177.4620000000016, "DynamicShapesCodegenCudaTests": 74.01700000000125, "DynamicShapesCodegenGPUTests": 82.09500000000153}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 233.63300000000183, "DynamicShapesCudaTests": 81.89300000000135, "DynamicShapesGPUTests": 90.72200000000169, "TestInductorDynamicCUDA": 0.04100000000000003}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 7.846000000000594}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.227}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 0.218}, "inductor/test_utils": {"TestUtils": 0.286}, "lazy/test_debug_util": {"DebugUtilTest": 0.811}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.838}, "lazy/test_generator": {"LazyGeneratorTest": 0.836}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.873}, "lazy/test_step_closures": {"ClosuresTest": 0.841}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.002, "TestLazyTensor": 0.565}, "nn/test_convolution": {"TestConvolutionNN": 0.7110000000000001, "TestConvolutionNNDeviceTypeCUDA": 0.5490000000000004}, "nn/test_dropout": {"TestDropoutNN": 0.636, "TestDropoutNNDeviceTypeCUDA": 0.005}, "nn/test_embedding": {"TestEmbeddingNN": 0.608, "TestEmbeddingNNDeviceTypeCUDA": 0.1330000000000001}, "nn/test_init": {"TestNNInit": 0.937}, "nn/test_lazy_modules": {"TestLazyModules": 0.7110000000000001}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.635, "TestLoadStateDictSwap": 0.001}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.007, "TestModuleHookNN": 0.016000000000000007, "TestModuleHooks": 0.67, "TestStateDictHooks": 0.006}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 0.665, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.013000000000000005}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.883}, "nn/test_parametrization": {"TestNNParametrization": 0.661, "TestNNParametrizationDeviceCUDA": 0.001}, "nn/test_pooling": {"TestAvgPool": 0.739, "TestPoolingNN": 0.014000000000000005, "TestPoolingNNDeviceTypeCUDA": 8.088999999999968}, "nn/test_pruning": {"TestPruningNN": 0.668}, "profiler/test_memory_profiler": {"TestDataFlow": 0.010000000000000002, "TestIdentifyGradients": 0.006, "TestMemoryProfiler": 0.795, "TestMemoryProfilerE2E": 0.017000000000000008}, "profiler/test_profiler": {"TestExecutionTrace": 0.006, "TestExperimentalUtils": 0.02000000000000001, "TestProfiler": 0.037000000000000026, "TestProfilerCUDA": 0.664, "TestProfilerITT": 0.001, "TestRecordFunction": 0.004, "TestTorchTidyProfiler": 0.022000000000000013}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.901}, "test_ao_sparsity": {"TestActivationSparsifier": 0.001, "TestBaseDataScheduler": 0.004, "TestBaseDataSparsifier": 0.003, "TestBaseSparsifier": 0.010000000000000002, "TestBaseStructuredSparsifier": 0.01800000000000001, "TestComposability": 0.007, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.002, "TestFakeSparsity": 0.004, "TestFxComposability": 0.005, "TestNearlyDiagonalSparsifier": 0.005, "TestNormDataSparsifiers": 0.003, "TestQuantizationUtils": 0.002, "TestQuantizedSparseKernels": 0.342, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.002, "TestScheduler": 0.004, "TestSparsityUtilFunctions": 0.008, "TestWeightNormSparsifier": 0.006}, "test_autocast": {"TestAutocastCPU": 0.902, "TestAutocastGPU": 0.002, "TestTorchAutocast": 0.002}, "test_autograd": {"TestAllowMutationOnSaved": 0.012000000000000004, "TestAutograd": 6.953000000000088, "TestAutogradComplex": 0.002, "TestAutogradDeviceTypeCUDA": 0.06600000000000004, "TestAutogradForwardMode": 0.02900000000000002, "TestAutogradForwardModeBatchedGrad": 0.005, "TestAutogradFunctional": 0.1290000000000001, "TestAutogradInferenceMode": 0.02000000000000001, "TestAutogradLogging": 0.004, "TestAutogradMultipleDispatchCUDA": 0.008, "TestMultithreadAutograd": 0.013000000000000005, "TestNestedCheckpoint": 0.014000000000000005}, "test_autograd_fallback": {"TestAutogradFallback": 0.884}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 21.207999999998208}, "test_bundled_inputs": {"TestBundledInputs": 0.896}, "test_comparison_utils": {"TestComparisonUtils": 0.842}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCUDA": 0.628}, "test_content_store": {"TestContentStoreCUDA": 0.004}, "test_cpp_api_parity": {"TestCppApiParity": 1.1699999999999824}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.574, "TestORTTensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.592, "TestORTTensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 0.589}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 35.664}, "test_cuda": {"TestBlockStateAbsorption": 0.001, "TestCuda": 8.61799999999998, "TestCudaMallocAsync": 0.016000000000000007}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 10.914999999999981, "TestCudaMallocAsync": 0.016000000000000007}, "test_cuda_multigpu": {"TestCudaComm": 0.016000000000000007, "TestCudaMultiGPU": 0.679}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 2.851}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.859, "TestEventHandler": 0.02300000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 10.215000000000002}, "test_custom_ops": {"MiniOpTest": 0.5350000000000001, "MiniOpTestOther": 0.05800000000000001, "TestCustomOp": 1.2529999999999968, "TestCustomOpTestingCUDA": 1.944, "TestGenerateOpcheckTests": 0.11699999999999999}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 113.204, "TestConcatDataset": 0.006, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.002, "TestDataLoader": 0.09400000000000006, "TestDataLoaderDeviceTypeCUDA": 0.003, "TestDataLoaderPersistentWorkers": 0.07100000000000005, "TestDatasetRandomSplit": 0.729, "TestDictDataLoader": 0.004, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.001, "TestSetAffinity": 0.001, "TestStackDataset": 0.010000000000000002, "TestStringDataLoader": 0.002, "TestTensorDataset": 0.005}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.002, "TestDataChunk": 0.6, "TestDataFramesPipes": 0.003, "TestFunctionalIterDataPipe": 0.01900000000000001, "TestFunctionalMapDataPipe": 0.009000000000000001, "TestGraph": 0.006, "TestIterDataPipeCountSampleYielded": 0.005, "TestIterDataPipeGraphFastForward": 0.005, "TestIterDataPipeSingletonConstraint": 0.005, "TestIterableDataPipeBasic": 0.12000000000000002, "TestSerialization": 0.002, "TestSharding": 0.008, "TestStreamWrapper": 0.219, "TestTyping": 0.004}, "test_decomp": {"DecompOneOffTestsCUDA": 0.015000000000000003, "HasDecompTest": 0.003, "TestDecompCUDA": 3019.1560000011737}, "test_deploy": {"TestFreezer": 0.839}, "test_dispatch": {"TestDispatch": 0.895, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCUDA": 0.7820000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 0.004, "TestFloorDiv": 0.009000000000000001, "TestPySymInt": 0.633, "TestSymNumberMagicMethods": 0.20300000000000015}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 0.09000000000000007, "TestExpandedWeightHelperFunctionCUDA": 0.731, "TestExpandedWeightModuleCUDA": 0.1290000000000001}, "test_fake_tensor": {"FakeTensorConstHandling": 0.010000000000000002, "FakeTensorConverterTest": 0.010000000000000002, "FakeTensorDispatchCache": 0.01900000000000001, "FakeTensorOpInfoTestCUDA": 0.011000000000000003, "FakeTensorOperatorInvariants": 0.010000000000000002, "FakeTensorPropTest": 0.002, "FakeTensorTest": 0.056000000000000036}, "test_flop_counter": {"TestFlopCounter": 0.193}, "test_foreach": {"TestForeachCUDA": 1.8039999999999154}, "test_function_schema": {"TestFunctionSchema": 0.889}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 120.868}, "test_functional_optim": {"TestFunctionalOptimParity": 0.365}, "test_functionalization": {"TestCrossRefFunctionalization": 0.05600000000000004, "TestFunctionalization": 1.0479999999999983}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 0.011000000000000003}, "test_futures": {"TestFuture": 0.886}, "test_fx": {"AnnotationsTest": 0.007, "TestCSEPass": 0.015000000000000006, "TestCommonPass": 0.017000000000000008, "TestConstFold": 0.02000000000000001, "TestConstParamShapeInControlFlow": 0.006, "TestDCE": 0.007, "TestFX": 0.18700000000000014, "TestFXAPIBackwardCompatibility": 0.005, "TestFunctionalTracing": 0.12500000000000008, "TestMatcher": 0.008, "TestOperatorSignaturesCUDA": 1.7350000000000003, "TestPassManager": 0.006, "TestSourceMatcher": 0.004, "TestSubgraphRewriter": 0.028000000000000018, "TestVisionTracing": 279.274, "TypeCheckerTest": 0.04000000000000002}, "test_fx_experimental": {"TestFXExperimental": 0.04100000000000003, "TestNormalizeOperatorsCUDA": 0.8790000000000006, "TestTranslationValidation": 0.004}, "test_fx_passes": {"TestFXGraphPasses": 0.8450000000000001, "TestFXMatcherUtils": 0.11600000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.871}, "test_import_stats": {"TestImportTime": 0.895}, "test_indexing": {"NumpyTestsCUDA": 0.022000000000000013, "TestIndexingCUDA": 0.7000000000000001}, "test_itt": {"TestItt": 0.848}, "test_jit": {"TestAliasAnalysis": 0.003, "TestAsync": 0.02100000000000001, "TestAtenPow": 0.001, "TestAutodiffJit": 0.005, "TestAutodiffSubgraphSlicing": 0.01800000000000001, "TestAwait": 0.017000000000000008, "TestBackends": 0.003, "TestBackendsWithCompiler": 0.002, "TestBatchMM": 0.008, "TestBuiltins": 0.004, "TestCUDA": 0.006, "TestClassType": 0.04500000000000003, "TestComplex": 0.014000000000000005, "TestCustomOperators": 0.014000000000000005, "TestDCE": 0.002, "TestDataParallel": 0.002, "TestDataclasses": 0.007, "TestDeviceAnalysis": 0.016000000000000007, "TestDict": 0.028000000000000018, "TestDtypeAnalysis": 0.3960000000000001, "TestEnum": 0.017000000000000008, "TestFreezing": 0.05500000000000004, "TestFrontend": 0.002, "TestFrozenOptimizations": 0.03400000000000002, "TestFunctionalBlocks": 0.001, "TestFunctionalToInplaceActivation": 0.004, "TestGenerator": 0.005, "TestGetDefaultAttr": 0.001, "TestGraphRewritePasses": 0.001, "TestHash": 0.009000000000000001, "TestHooks": 0.024000000000000014, "TestIgnorableArgs": 0.002, "TestIgnoreContextManager": 0.003, "TestInplaceToFunctionalActivation": 0.002, "TestIsinstance": 0.02900000000000002, "TestJit": 0.8800000000000001, "TestJitGeneratedModule": 7.036000000000016, "TestJitProfiler": 0.001, "TestJitUtils": 0.008, "TestList": 0.08200000000000006, "TestLogging": 0.006, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.024000000000000014, "TestMixTracingScripting": 0.022000000000000013, "TestModels": 6.618000000000001, "TestModuleAPIs": 0.003, "TestModuleContainers": 0.01800000000000001, "TestModuleInterface": 0.016000000000000007, "TestModules": 0.001, "TestNamedTuple": 0.013000000000000005, "TestNnapiBackend": 6.489, "TestOpDecompositions": 0.002, "TestOptimizeForMobilePreserveDebugInfo": 0.007, "TestPDT": 0.019000000000000006, "TestParametrization": 0.002, "TestPeephole": 0.03900000000000003, "TestProducerVersion": 0.001, "TestProfiler": 0.30800000000000005, "TestPythonBindings": 0.009000000000000001, "TestPythonBuiltinOP": 0.015000000000000006, "TestPythonIr": 0.004, "TestRecursiveScript": 0.03200000000000002, "TestRemoveMutation": 0.008, "TestSaveLoad": 83.21400000000006, "TestSaveLoadFlatbuffer": 0.010000000000000002, "TestSaveLoadForOpVersion": 0.011000000000000003, "TestScript": 0.7580000000000005, "TestScriptDict": 0.010000000000000002, "TestScriptList": 0.017000000000000008, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.014000000000000005, "TestScriptProfile": 0.005, "TestSlice": 0.01900000000000001, "TestSparse": 0.004, "TestStringFormatting": 0.022000000000000013, "TestSymbolicShapeAnalysis": 0.025000000000000015, "TestTensorBuiltins": 0.006, "TestTensorCreationOps": 0.006, "TestTensorMethods": 0.002, "TestTorchbind": 0.12800000000000006, "TestTracer": 0.1320000000000001, "TestTypeSharing": 0.025000000000000015, "TestTypesAndAnnotation": 0.016000000000000007, "TestTyping": 0.03900000000000003, "TestUnion": 0.05000000000000004, "TestUnsupportedOps": 0.002, "TestUpgraders": 0.014000000000000005, "TestWarn": 0.007, "TestWith": 0.006}, "test_jit_autocast": {"TestAutocast": 0.04300000000000003, "TestJitTraceAutocast": 0.013000000000000001}, "test_jit_disabled": {"TestJitDisabled": 0.915}, "test_jit_fuser_te": {"TestFuserCommon": 0.002, "TestNNCOpInfoCUDA": 12.87700000000069, "TestTEFuserDynamic": 400.85699999999866, "TestTEFuserStatic": 372.42499999999876}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCUDA": 0.001, "TestModel": 0.005, "TestOpCUDA": 0.002}, "test_jiterator": {"TestPythonJiteratorCUDA": 0.9030000000000002}, "test_legacy_vmap": {"TestVmapAPI": 0.49200000000000005, "TestVmapAPILegacy": 0.657, "TestVmapBatchedGradientCUDA": 0.03000000000000002, "TestVmapBatchedGradientLegacyCUDA": 0.03000000000000002, "TestVmapOperators": 0.05200000000000004, "TestVmapOperatorsLegacy": 0.05400000000000004}, "test_license": {"TestLicense": 0.889}, "test_linalg": {"TestLinalgCUDA": 349.8419999999906}, "test_logging": {"LoggingTest": 0.885}, "test_masked": {"TestMaskedCUDA": 0.8060000000000002}, "test_maskedtensor": {"TestBasicsCUDA": 0.017000000000000008, "TestBinary": 0.07100000000000005, "TestOperatorsCUDA": 0.7340000000000005, "TestReductions": 0.01900000000000001, "TestUnary": 0.8190000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.0, "TestMatmulCudaCUDA": 0.762, "TestMixedDtypesLinearCudaCUDA": 0.001}, "test_meta": {"TestMetaCUDA": 312.6379999996014, "TestMetaConverter": 0.585}, "test_mkl_verbose": {"TestMKLVerbose": 0.84}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.898}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 0.822}, "test_mobile_optimizer": {"TestOptimizer": 0.397}, "test_model_dump": {"TestModelDump": 0.86}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.271}, "test_module_init": {"TestModuleInitCUDA": 0.3955000000000003}, "test_modules": {"TestModuleCUDA": 1252.8169999999568}, "test_monitor": {"TestMonitor": 0.967, "TestMonitorTensorboard": 0.233}, "test_multiprocessing": {"TestMultiprocessing": 0.909}, "test_multiprocessing_spawn": {"ErrorTest": 0.001, "ForkTest": 0.008, "SpawnTest": 0.85}, "test_namedtensor": {"TestNamedTensor": 0.6980000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 0.787}, "test_native_functions": {"TestNativeFunctions": 0.876}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.798}, "test_nestedtensor": {"TestNestedTensor": 0.48900000000000005, "TestNestedTensorAutogradCUDA": 0.058000000000000045, "TestNestedTensorDeviceTypeCUDA": 0.1550000000000001, "TestNestedTensorSubclassCUDA": 0.06900000000000005}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.001, "TestFusionUtils": 0.002, "TestNN": 1.686999999999926, "TestNNDeviceTypeCUDA": 1.7769999999999788}, "test_numba_integration": {"TestNumbaIntegration": 0.634}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.749}, "test_openmp": {"TestOpenMP_ParallelFor": 0.869}, "test_ops": {"TestCommonCUDA": 80.81900000001161, "TestCompositeComplianceCUDA": 1062.9589999999448, "TestFakeTensorCUDA": 856.1869999999965, "TestMathBitsCUDA": 4.3990000000000125, "TestSelfKwarg": 0.567, "TestTagsCUDA": 1.020999999999999}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 168.57700000001364}, "test_ops_gradients": {"TestBwdGradientsCUDA": 528.3639999999288}, "test_ops_jit": {"TestJitCUDA": 123.27600000000152}, "test_optim": {"TestDifferentiableOptimizer": 0.012000000000000004, "TestLRScheduler": 0.1360000000000001, "TestOptim": 0.716, "TestOptimRenewedCUDA": 0.3730000000000003, "TestSWAUtils": 0.013000000000000005}, "test_out_dtype_op": {"TestOutDtypeOp": 0.02700000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.001, "TestGradCheckOverride": 0.001, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.001, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 2.460999999999856, "TestTorchFunctionWarning": 0.001, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.008, "ModelTest": 0.001, "TestAnalyze": 0.001, "TestDependencyAPI": 0.01800000000000001, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006, "TestLoadBCPackages": 0.003, "TestMangling": 0.010000000000000002, "TestMisc": 0.011000000000000003, "TestPackageFX": 0.006, "TestPackageScript": 0.023000000000000013, "TestRepackage": 0.001, "TestResources": 0.28, "TestSaveLoad": 0.011000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.845}, "test_prims": {"TestDecompCUDA": 0.002, "TestPrimsBasic": 0.56, "TestPrimsCUDA": 0.012000000000000004, "TestRefsCUDA": 0.005}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.006, "TestGenericProxyTensorFake": 0.035000000000000024, "TestGenericProxyTensorReal": 0.035000000000000024, "TestGenericProxyTensorSymbolic": 0.035000000000000024, "TestRealProxyTensor": 0.001, "TestSymbolicTracing": 0.05500000000000004}, "test_pruning_op": {"PruningOpTest": 0.806}, "test_public_bindings": {"TestPublicBindings": 0.887}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.001, "TestPythonDispatch": 0.07100000000000005, "TestPythonDispatcher": 0.002, "TestPythonRegistration": 0.02000000000000001, "TestWrapperSubclassAliasingCUDA": 0.01800000000000001}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 1.024, "TestPythonPytree": 0.02900000000000002}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.01800000000000001, "TestAOMigrationQuantization": 0.011000000000000003, "TestAOMigrationQuantizationFx": 0.012000000000000004, "TestBackendConfig": 0.01900000000000001, "TestBiasCorrectionEager": 0.003, "TestBits": 0.002, "TestBitsCUDA": 0.004, "TestComparatorOps": 0.002, "TestDeprecatedJitQuantized": 0.004, "TestDistributed": 0.006, "TestDuplicateDQPass": 0.004, "TestDynamicQuantizedModule": 0.010000000000000002, "TestDynamicQuantizedOps": 0.012000000000000004, "TestEqualizeEager": 0.005, "TestEqualizeFx": 0.010000000000000002, "TestFXGraphMatcher": 0.014000000000000005, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 0.048000000000000036, "TestFXNumericSuiteCoreAPIsModels": 0.022000000000000006, "TestFXNumericSuiteNShadows": 0.024000000000000014, "TestFakeQuantize": 0.003, "TestFakeQuantizeOps": 0.03100000000000002, "TestFloat8DtypeCUDA": 0.014000000000000005, "TestFuseEager": 0.011000000000000003, "TestFuseFx": 0.10700000000000001, "TestFusedObsFakeQuant": 0.004, "TestFusedObsFakeQuantModule": 0.008, "TestFusionPasses": 0.001, "TestFxDetectInputWeightEqualization": 0.003, "TestFxDetectOutliers": 0.005, "TestFxModelReportClass": 0.006, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.009000000000000001, "TestFxModelReportObserver": 0.004, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.003, "TestHistogramObserver": 0.007, "TestMetaDataPorting": 0.006, "TestModelNumericsEager": 0.004, "TestNumericSuiteEager": 0.02000000000000001, "TestObserver": 0.013000000000000005, "TestPT2ERepresentation": 0.008, "TestPadding": 0.003, "TestQNNPackOps": 0.012000000000000004, "TestQuantizationDocs": 0.006, "TestQuantizeDynamicJitOps": 0.003, "TestQuantizeDynamicJitPasses": 0.010000000000000002, "TestQuantizeEagerOps": 0.011000000000000003, "TestQuantizeEagerPTQDynamic": 0.013000000000000005, "TestQuantizeEagerPTQStatic": 0.02100000000000001, "TestQuantizeEagerQAT": 0.014000000000000005, "TestQuantizeEagerQATNumerics": 0.008, "TestQuantizeFx": 0.1550000000000001, "TestQuantizeFxModels": 0.009000000000000001, "TestQuantizeFxOps": 0.060000000000000046, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.03100000000000002, "TestQuantizeJitPasses": 0.03900000000000003, "TestQuantizePT2E": 0.03100000000000002, "TestQuantizePT2EQAT": 582.4289999999999, "TestQuantizePT2EQATModels": 0.002, "TestQuantizePT2EQAT_ConvBn1d": 441.67100000000005, "TestQuantizePT2EQAT_ConvBn2d": 484.74899999999997, "TestQuantizePT2EX86Inductor": 126.71200000000005, "TestQuantizedConv": 0.02900000000000002, "TestQuantizedEmbeddingOps": 0.009000000000000001, "TestQuantizedFunctionalOps": 0.005, "TestQuantizedLinear": 0.010000000000000002, "TestQuantizedOps": 43.564999999999934, "TestQuantizedTensor": 0.06400000000000004, "TestRecordHistogramObserver": 0.002, "TestReferenceQuantizedModule": 0.004, "TestSerialization": 0.02000000000000001, "TestStaticQuantizedModule": 0.03200000000000002, "TestSubgraphRewriter": 0.014000000000000005, "TestUtils": 0.006, "TestXNNPACKQuantizer": 0.025000000000000015, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCUDA": 5.703000000000107}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 0.7030000000000001}, "test_schema_check": {"TestSchemaCheck": 0.77, "TestSchemaCheckModeOpInfoCUDA": 8.650000000000404}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 0.6960000000000001}, "test_serialization": {"TestBothSerializationCUDA": 0.003, "TestOldSerialization": 0.785, "TestSerialization": 0.07400000000000005, "TestSubclassSerialization": 0.006}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.877}, "test_shape_ops": {"TestShapeOpsCUDA": 0.7090000000000001}, "test_show_pickle": {"TestShowPickle": 0.839}, "test_sort_and_select": {"TestSortAndSelectCUDA": 1.2259999999999915}, "test_sparse": {"TestSparseAnyCUDA": 366.2719999999717, "TestSparseCUDA": 0.2800000000000002, "TestSparseLegacyAndDeprecation": 0.687, "TestSparseMaskedReductionsCUDA": 0.04400000000000003, "TestSparseMeta": 0.001, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCUDA": 1.3699999999999624}, "test_sparse_csr": {"TestSparseCSRCUDA": 1.8969999999999052, "TestSparseCSRSampler": 0.001, "TestSparseCompressedCUDA": 3.177999999999789, "TestSparseCompressedTritonKernelsCUDA": 114.39600000000024}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.002, "TestCUSPARSELTCUDA": 0.014000000000000005, "TestSparseSemiStructuredCUDA": 0.07500000000000005}, "test_spectral_ops": {"TestFFTCUDA": 0.9670000000000002}, "test_stateless": {"TestPythonOptimizeMode": 0.001, "TestStatelessDeprecation": 0.002, "TestStatelessFunctionalAPI": 0.734}, "test_subclass": {"TestSubclass": 0.8810000000000001}, "test_sympy_utils": {"TestSingletonInt": 0.001, "TestSympyInterp": 0.059000000000000045, "TestSympySolve": 0.028000000000000018, "TestValueRanges": 0.4660000000000001}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.1460000000000001, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.025000000000000015, "TestTensorCreationCUDA": 1.404999999999971}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.002, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.004, "TestTensorBoardPyTorchNumpy": 0.269, "TestTensorBoardPytorchGraph": 0.007, "TestTensorBoardSummary": 0.025000000000000015, "TestTensorBoardSummaryWriter": 0.003, "TestTensorBoardUtils": 0.004, "TestTensorBoardWriter": 0.001, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 0.9660000000000001}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.001, "TestTensorExprPyBind": 0.878}, "test_testing": {"TestAssertClose": 0.03300000000000002, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.014000000000000005, "TestAssertCloseMultiDeviceCUDA": 0.002, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.004, "TestAssertCloseSparseBSR": 0.004, "TestAssertCloseSparseCOO": 0.006, "TestAssertCloseSparseCSC": 0.004, "TestAssertCloseSparseCSR": 0.004, "TestFrameworkUtils": 0.001, "TestImports": 0.006, "TestMakeTensorCUDA": 0.9180000000000006, "TestOpInfoSampleFunctionsCUDA": 1.196999999999981, "TestOpInfos": 0.002, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCUDA": 0.027000000000000017, "TestTestingCUDA": 0.624}, "test_torch": {"TestBasicVitalSigns": 0.003, "TestDevicePrecisionCUDA": 0.02000000000000001, "TestTorch": 0.21300000000000016, "TestTorchDeviceTypeCUDA": 28.30300000000085, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 0.022000000000000013, "TestAttnMasksCUDA": 0.02300000000000001, "TestSDPACUDA": 1.3539999999999641, "TestSDPACudaOnlyCUDA": 46.68299999998661, "TestSDPAFailureModesCUDA": 0.013000000000000005, "TestTransformersCUDA": 2.3899999999999966}, "test_type_hints": {"TestTypeHints": 0.891}, "test_type_info": {"TestDTypeInfo": 0.853}, "test_type_promotion": {"TestTypePromotionCUDA": 1.2459999999999802}, "test_typing": {"TestTyping": 0.885}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 26.637000000009458}, "test_utils": {"TestAssert": 0.002, "TestBottleneck": 0.002, "TestCheckpoint": 0.338, "TestCollectEnv": 0.001, "TestCppExtensionUtils": 0.002, "TestDataLoaderUtils": 0.004, "TestDeviceUtilsCUDA": 6.372000000000502, "TestExtensionUtils": 0.002, "TestHipify": 0.001, "TestHipifyTrie": 0.007, "TestONNXUtils": 0.002, "TestRenderUtils": 0.001, "TestStandaloneCPPJIT": 0.001, "TestTraceback": 0.005}, "test_view_ops": {"TestOldViewOpsCUDA": 0.12000000000000009, "TestViewOpsCUDA": 0.7760000000000001}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.10400000000000001, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 0.881}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 236.45299999999997, "TestXNNPACKOps": 0.78, "TestXNNPACKRewritePass": 0.002, "TestXNNPACKSerDes": 0.004}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.005}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.30200000000000005, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.002, "TestMisc": 0.003, "TestPickling": 0.017000000000000008, "TestPromotion": 0.002}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 0.263, "TestEinsumPath": 0.094, "TestMisc": 0.001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.599, "TestHalf": 0.0, "TestIinfo": 0.19, "TestMisc": 0.004, "TestPythonFloat": 0.001, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.003, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.001, "TestFloatNonIntegerArgument": 0.004, "TestIndexing": 0.31800000000000006, "TestMultiIndexingAutomated": 0.003, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.013000000000000005, "TestArgmax": 0.06300000000000004, "TestArgmaxArgminCommon": 0.03800000000000003, "TestArgmin": 0.06300000000000004, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.305, "TestArrayCreationCopyArgument": 0.003, "TestArrayInterface": 0.012000000000000004, "TestAssignment": 0.005, "TestAttributes": 0.023, "TestBinop": 0.001, "TestBool": 842.4989999999999, "TestCequenceMethods": 0.001, "TestChoose": 0.024, "TestClip": 0.003, "TestCompress": 0.003, "TestConversion": 0.003, "TestCreation": 0.007, "TestDelMisc": 0.001, "TestDot": 3.6759999999999997, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.006, "TestFlag": 0.013000000000000005, "TestFormat": 0.003, "TestFromBuffer": 0.010000000000000002, "TestHash": 0.277, "TestHashing": 0.002, "TestIO": 0.002, "TestInner": 0.005, "TestLexsort": 0.012000000000000004, "TestMatmul": 0.9300000000000002, "TestMatmulOperator": 0.015000000000000003, "TestMethods": 0.12000000000000009, "TestMinMax": 0.002, "TestMinScalarType": 0.004, "TestNewaxis": 0.001, "TestPEP3118Dtype": 0.002, "TestPutmask": 0.008, "TestRepeat": 0.017, "TestResize": 0.009000000000000001, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.20800000000000002, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.017000000000000005, "TestStats": 0.32999999999999996, "TestSubscripting": 0.001, "TestTake": 0.008, "TestVdot": 0.004, "TestViewDtype": 0.007, "TestWarnings": 0.001, "TestWhere": 0.008, "TestWritebackIfCopy": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.005, "TestArgwhere": 0.005, "TestArrayComparisons": 0.004, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006, "TestBoolArray": 0.003, "TestBoolCmp": 0.002, "TestBoolScalar": 0.004, "TestBroadcast": 0.005, "TestClip": 0.05500000000000004, "TestConvolve": 0.004, "TestCorrelate": 0.004, "TestCreationFuncs": 0.005, "TestCross": 0.006, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006, "TestFromiter": 0.0, "TestIndex": 0.002, "TestIndices": 0.016000000000000007, "TestIsclose": 0.008, "TestIsscalar": 0.001, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.005, "TestNonarrayArgs": 0.037000000000000026, "TestNonzeroAndCountNonzero": 0.023000000000000013, "TestOuterMisc": 0.001, "TestRequire": 0.004, "TestResize": 0.32, "TestRoll": 0.003, "TestRollaxis": 0.002, "TestSeterr": 0.004, "TestStdVar": 0.005, "TestStdVarComplex": 0.002, "TestStringFunction": 0.001, "TestTensordot": 0.003, "TestTypes": 0.006}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.841, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.022000000000000013}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06200000000000005, "TestFromInt": 0.002, "TestFromString": 0.805}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.006, "TestBitCount": 0.0, "TestClassGetItem": 0.001, "TestClassGetitemMisc": 0.786, "TestIsInteger": 0.001}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.010000000000000002, "TestBaseMath": 0.002, "TestBitShifts": 0.010000000000000002, "TestComplexDivision": 0.003, "TestConversion": 0.007, "TestHash": 0.0, "TestModulus": 57.288999999999994, "TestMultiply": 0.0, "TestNegative": 0.002, "TestPower": 0.005, "TestRepr": 0.001, "TestScalarOpsMisc": 0.028000000000000018, "TestScalarSubclassingMisc": 0.010000000000000002, "TestSubtract": 0.002, "TestTypes": 0.8}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.777, "TestAtleast2d": 0.006, "TestAtleast3d": 0.004, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.047000000000000035, "TestHstack": 0.008, "TestStackMisc": 0.007, "TestVstack": 0.008}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.001, "TestFFTShift": 0.808, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.07600000000000005, "TestFFTShift": 0.779, "TestFFTThreadSafe": 0.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.802}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.009000000000000001, "TestUnique": 0.266}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.002, "TestAmax": 0.001, "TestAmin": 0.001, "TestAngle": 0.001, "TestAny": 0.002, "TestAverage": 0.005, "TestBincount": 0.013000000000000005, "TestCheckFinite": 0.002, "TestCopy": 0.002, "TestCorrCoef": 0.010000000000000002, "TestCov": 0.013000000000000005, "TestCumprod": 0.001, "TestCumsum": 0.001, "TestDelete": 0.10200000000000001, "TestDiff": 0.006, "TestDigitize": 0.011000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.1210000000000001, "TestFlip": 0.009000000000000001, "TestGradient": 0.019000000000000006, "TestInsert": 0.005, "TestInterp": 0.02900000000000002, "TestKaiser": 0.002, "TestMedian": 0.016000000000000007, "TestMeshgrid": 0.011000000000000003, "TestMsort": 0.001, "TestPercentile": 0.04500000000000003, "TestPiecewise": 0.008, "TestProd": 0.001, "TestPtp": 0.001, "TestQuantile": 0.007, "TestRot90": 0.275, "TestSelect": 0.006, "TestSinc": 0.002, "TestSortComplex": 0.007, "TestTrapz": 0.002, "TestTrimZeros": 0.013000000000000005, "TestUnique": 0.002, "Test_I0": 0.002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 1.3089999999999977, "TestHistogramOptimBinNums": 0.018000000000000006, "TestHistogramdd": 0.017000000000000008}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.001, "TestDiagIndicesFrom": 0.003, "TestFillDiagonal": 0.008, "TestGrid": 0.008, "TestIndexExpression": 0.002, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.8140000000000001}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.011000000000000003, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.010000000000000002, "TestColumnStack": 0.004, "TestDsplit": 0.005, "TestDstack": 0.006, "TestExpandDims": 0.004, "TestHsplit": 0.004, "TestKron": 0.002, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.002, "TestSplit": 0.002, "TestSqueeze": 0.006, "TestTakeAlongAxis": 0.801, "TestTile": 0.004, "TestVsplit": 0.004}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.005, "TestEye": 0.804, "TestFliplr": 0.001, "TestFlipud": 0.001, "TestHistogram2d": 0.006, "TestTri": 0.007, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.803, "TestImag": 0.002, "TestIscomplex": 0.002, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.002, "TestIsposinf": 0.001, "TestIsreal": 0.003, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.004, "TestReal": 0.002, "TestRealIfClose": 0.001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.02100000000000001, "TestCond": 0.35100000000000003, "TestDet": 0.241, "TestEig": 0.064, "TestEigh": 0.007, "TestEighCases": 0.0, "TestEigvals": 0.08800000000000001, "TestEigvalsh": 0.007, "TestEigvalshCases": 0.0, "TestInv": 0.09, "TestLstsq": 0.012000000000000004, "TestMatrixRank": 0.003, "TestMisc": 0.373, "TestMisc2": 0.002, "TestMultiDot": 0.014000000000000005, "TestNormDouble": 0.010000000000000002, "TestNormInt64": 0.010000000000000002, "TestNormSingle": 0.010000000000000002, "TestNorm_NonSystematic": 0.001, "TestPinv": 0.33799999999999997, "TestPinvHermitian": 0.10099999999999999, "TestQR": 0.012000000000000004, "TestSVD": 0.056, "TestSVDHermitian": 0.16699999999999998, "TestSolve": 0.36800000000000005, "TestTensorinv": 0.007, "TestTensorsolve": 0.004}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.003, "TestCtorNested": 0.001, "TestDefaultDtype": 0.004, "TestDivmod": 0.005, "TestExport": 0.0, "TestMisc": 0.002, "TestNormalizations": 0.003, "TestOneArr": 0.8550000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.2670000000000001, "TestOneArrAndShape": 0.016000000000000007, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.852}, "torch_np/test_dtype": {"TestConvertDType": 0.8390000000000001}, "torch_np/test_function_base": {"TestAppend": 0.764}, "torch_np/test_ndarray_methods": {"TestAmax": 0.001, "TestAmin": 0.001, "TestArgmax": 0.07600000000000005, "TestArgmaxArgminCommon": 0.03800000000000003, "TestArgmin": 0.07600000000000005, "TestContains": 0.001, "TestIndexing": 0.277, "TestIter": 0.002, "TestNoExtraMethods": 0.006, "TestNonzero": 0.005, "TestRavel": 0.002, "TestReshape": 0.002, "TestTranspose": 0.002}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.06500000000000003, "TestNEP50Table": 0.006}, "torch_np/test_random": {"TestChoice": 0.002, "TestNumpyGlobal": 0.001, "TestScalarReturn": 0.24900000000000003, "TestShuffle": 0.006}, "torch_np/test_reductions": {"TestAll": 0.003, "TestAny": 0.003, "TestFlatnonzero": 0.892, "TestGenericCumSumProd": 0.008, "TestGenericReductions": 0.9410000000000007, "TestMean": 0.004, "TestSum": 0.010000000000000002}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.2, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3170000000000002, "TestNdarrayDunderVsUfunc": 0.03000000000000002, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.912}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.79}}}, "linux-focal-rocm5.7-py3.8": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 1.8145}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 2.952}, "distributions/test_constraints": {"test_constraints": 0.6980000000000004}, "distributions/test_distributions": {"TestAgainstScipy": 0.8515000000000001, "TestConstraints": 0.10250000000000001, "TestDistributionShapes": 0.11750000000000003, "TestDistributions": 33.167, "TestFunctors": 0.0055, "TestJit": 9.0975, "TestKL": 2.3159999999999994, "TestLazyLogitsInitialization": 0.007, "TestNumericalStability": 0.046500000000000014, "TestRsample": 0.521, "TestValidation": 0.2425}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 16.3315}, "dynamo/test_after_aot": {"TestAfterAot": 5.5825}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 18.952}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 1.8374999999999992}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0, "NormalizeIRTests": 0.0235, "TestCustomBackendAPI": 1.3169999999999997, "TestExplainWithBackend": 8.492999999999999, "TestOptimizations": 0.7435}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 10.965000000000002}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 5.3985}, "dynamo/test_compile": {"InPlaceCompilationTests": 7.234, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.65}, "dynamo/test_config": {"ConfigTests": 0.6900000000000001}, "dynamo/test_ctx_manager": {"CtxManagerTests": 2.0749999999999993}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 2.5445}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.512}, "dynamo/test_decorators": {"DecoratorTests": 0.7590000000000001}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 41.1155, "DynamicShapesCtxManagerTests": 5.319, "DynamicShapesExportTests": 381.011, "DynamicShapesFuncTorchHigherOrderOpTests": 7.534000000000001, "DynamicShapesFunctionTests": 65.787, "DynamicShapesHigherOrderOpTests": 11.097999999999999, "DynamicShapesMiscTests": 82.66700000000003, "DynamicShapesNNModuleTests": 5.317999999999999, "DynamicShapesReproTests": 97.5015, "DynamicShapesSubGraphTests": 6.7545, "DynamicShapesTestSDPA": 0.268}, "dynamo/test_exc": {"ExcTests": 1.5839999999999999}, "dynamo/test_export": {"ExportTests": 17.46999999999999}, "dynamo/test_export_mutations": {"MutationExportTests": 0.7355}, "dynamo/test_frame_init": {"FrameInitTests": 0.1445}, "dynamo/test_functions": {"DefaultsTests": 0.7080000000000001, "FunctionTests": 19.659499999999994}, "dynamo/test_global": {"TestGlobals": 0.6305000000000001}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 6.6640000000000015, "FuncTorchHigherOrderOpTests": 3.5320000000000005, "HigherOrderOpTests": 6.5429999999999975, "HigherOrderOpVmapGuardTests": 0.7110000000000001}, "dynamo/test_hooks": {"HooksTests": 18.9865}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 7.032499999999999}, "dynamo/test_interop": {"InteropTests": 0.7674999999999998}, "dynamo/test_logging": {"LoggingTests": 17.6015}, "dynamo/test_minifier": {"MinifierTests": 2.4654999999999996}, "dynamo/test_misc": {"MiscTests": 34.51100000000003, "TestTracer": 0.0435}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.001}, "dynamo/test_modules": {"NNModuleTests": 3.221999999999998, "OptimizedModuleTest": 8.514}, "dynamo/test_nops": {"NopTests": 0.5990000000000001}, "dynamo/test_optimizers": {"End2EndTests": 0.287, "OptimizerTests": 1.605}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.6725000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.254}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.8815000000000001}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.1740000000000002}, "dynamo/test_recompiles": {"RecompileTests": 0.9405000000000001}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.7605000000000002}, "dynamo/test_repros": {"ReproTests": 28.358500000000003}, "dynamo/test_sdpa": {"TestSDPA": 0.623}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.6859999999999999}, "dynamo/test_sources": {"SourceTests": 0.1265}, "dynamo/test_subclasses": {"SubclassTests": 1.1554999999999997, "TestNestedTensor": 7.427499999999999}, "dynamo/test_subgraphs": {"SubGraphTests": 2.118499999999999}, "dynamo/test_trace_rules": {"TraceRuleTests": 2.0414999999999996}, "dynamo/test_triton_kernels": {"KernelTests": 11.449500000000004, "MutationTests": 0.01900000000000001, "NoOptimizationKernelTests": 2.7909999999999986, "no_opt_test_class": 3.012999999999999}, "dynamo/test_unspec": {"UnspecTests": 10.8355}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.7575000000000001}, "export/test_db": {"ExampleTests": 2.6615}, "export/test_experimental": {"TestExperiment": 0.7655}, "export/test_export": {"TestDynamismExpression": 0.7949999999999999, "TestExport": 17.638499999999997, "TestExportCustomClass": 0.026, "TestOneOffModelExportResult": 0.22550000000000003}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.6825000000000001, "NonStrictExportTestExport": 14.304499999999997}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.591}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.9663333333333334}, "export/test_lift_unlift": {"TestLiftUnlift": 0.0825}, "export/test_pass_infra": {"TestPassInfra": 0.9730000000000001}, "export/test_passes": {"TestPasses": 1.4505}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.9039999999999999, "RetraceExportTestExport": 21.530499999999996}, "export/test_safeguard": {"TestSafeguard": 0.9335}, "export/test_schema": {"TestSchema": 0.1585}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.7785, "SerDesExportTestExport": 14.953}, "export/test_serialize": {"TestDeserialize": 3.7894999999999994, "TestOpVersioning": 0.003, "TestSaveLoad": 0.19649999999999998, "TestSchemaVersioning": 0.0305, "TestSerialize": 0.9139999999999999, "TestSerializeCustomClass": 0.042499999999999996}, "export/test_torchbind": {"TestExportTorchbind": 0.5960000000000001}, "export/test_tree_utils": {"TestTreeUtils": 0.1245}, "export/test_unflatten": {"TestUnflatten": 1.5465}, "export/test_upgrade": {"TestUpgrade": 0.721}, "export/test_verifier": {"TestVerifier": 0.9215}, "functorch/test_aotdispatch": {"TestAOTAutograd": 8.000500000000002, "TestAOTDispatch": 0.27849999999999997, "TestAOTExport": 0.8280000000000003, "TestAOTModuleSimplified": 0.7545000000000001, "TestPartitioning": 4.121}, "functorch/test_control_flow": {"TestControlFlow": 1.2345, "TestControlFlowTraced": 78.19249999999998}, "functorch/test_dims": {"TestMin": 10.087000000000002, "TestMinFunctorchOnly": 9.968500000000002}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.10550000000000004, "TestAutogradFunctionVmapAPICUDA": 0.011000000000000003, "TestCompileTransformsCUDA": 0.597, "TestComposabilityCUDA": 0.13600000000000007, "TestExamplesCorrectnessCUDA": 3.2015000000000002, "TestFunctionalizeCUDA": 0.07400000000000001, "TestGradTransformCUDA": 1.293499999999999, "TestHelpersCUDA": 0.006, "TestHessianCUDA": 0.0385, "TestHigherOrderOperatorInteractionCUDA": 0.0175, "TestJacCUDA": 0.39850000000000013, "TestJvpCUDA": 0.03500000000000001, "TestLinearizeCUDA": 0.10149999999999999, "TestMakeFunctional": 0.736, "TestSliceArgnums": 0.009000000000000001, "TestVmapJvpInplaceViewCUDA": 0.01, "TestVmapOfGradCUDA": 0.345}, "functorch/test_logging": {"TestAOTLogging": 0.1775}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.484, "RandomOpTestCase": 0.29600000000000004, "ReduceTestCase": 0.054, "TestMemoryEfficientOpAuthoring": 7.327999999999999}, "functorch/test_minifier": {"TestMinifier": 0.36950000000000005}, "functorch/test_ops": {"TestOperatorsCUDA": 3048.20599999998}, "functorch/test_parsing": {"TestAnonymousAxis": 0.5489999999999999, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.5660000000000001}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.9235000000000007, "TestTransformFailureCUDA": 0.0505, "TestVmapAPI": 0.792, "TestVmapBatchedGradientCUDA": 0.14650000000000007, "TestVmapDeviceTypeCUDA": 0.094, "TestVmapNestedTensorCUDA": 0.08100000000000002, "TestVmapOperators": 3.2024999999999944, "TestVmapOperatorsOpInfoCUDA": 250.9854999999999}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.2834999999998606}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 305.54049999999995, "AOTInductorTestABICompatibleCpuWithStackAllocation": 223.75600000000023, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 85.37150000000004, "AOTInductorTestABICompatibleCuda": 306.70899999999983, "AOTInductorTestNonABICompatibleCpu": 698.0349999999997, "AOTInductorTestNonABICompatibleCuda": 553.8359999999999}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 4.284000000000001, "BenchmarkFusionCudaTest": 41.095499999999994}, "inductor/test_binary_folding": {"FreezingCpuTests": 19.774, "FreezingCudaTests": 1.741}, "inductor/test_codecache": {"TestFxGraphCache": 45.756, "TestFxGraphCacheHashing": 0.558, "test_codecache": 1.4525}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.1915}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 167.5695000000004, "TestCompiledAutograd": 44.9935}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 375.50750000000005}, "inductor/test_config": {"TestInductorConfig": 4.0305}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 1.8765}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1043.808, "DynamicShapesCudaWrapperCudaTests": 350.9056666666666, "TestCppWrapper": 1169.613, "TestCudaWrapper": 482.6993333333334}, "inductor/test_cpu_repro": {"CPUReproTests": 452.94849999999997}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 370.30699999999996, "TestCudaWrapper": 367.8719999999999}, "inductor/test_cuda_repro": {"CudaReproTests": 75.6455}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 39.915}, "inductor/test_custom_lowering": {"TestCustomLowering": 2.1555}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 4.1135}, "inductor/test_debug_trace": {"TestDebugTrace": 2.0255}, "inductor/test_dependencies": {"TestDependencies": 0.14900000000000002}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.001, "EfficientConvBNEvalCudaTests": 0.001}, "inductor/test_extension_backend": {"ExtensionBackendTests": 23.7965}, "inductor/test_foreach": {"ForeachTests": 139.32349999999997}, "inductor/test_fp8": {"TestFP8Types": 0.004}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 20.205499999999994, "SDPAPatternRewriterCpuTests": 25.104000000000013, "SDPAPatternRewriterCudaDynamicTests": 41.04099999999998, "SDPAPatternRewriterCudaTests": 37.03349999999999}, "inductor/test_fx_fusion": {"TestFxFusion": 0.3665}, "inductor/test_group_batch_fusion": {"TestGroupBatchFusion": 49.4215, "TestPostGradBatchLinearFusion": 0.922}, "inductor/test_indexing": {"ExprPrinterTests": 0.025500000000000002, "TestIndexingSimplification": 0.3745}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 27.639000000000003, "FreezingCudaTests": 20.719}, "inductor/test_inductor_utils": {"TestBench": 0.7476666666666666}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 2.3529999999999998}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 52.695499999999996}, "inductor/test_layout_optim": {"TestLayoutOptim": 5.0605}, "inductor/test_max_autotune": {"TestMaxAutotune": 90.45150000000002, "TestTuningProcess": 9.311}, "inductor/test_memory_planning": {"TestMemoryPlanning": 1.492}, "inductor/test_minifier": {"MinifierTests": 26.951}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 41.459999999999994}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 23.919000000000004, "TestPatternMatcher": 43.2849999999999}, "inductor/test_mmdecomp": {"TestDecompCUDA": 6.858499999999999}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 11.277500000000002}, "inductor/test_multi_kernel": {"MultiKernelTest": 9.391000000000002}, "inductor/test_pad_mm": {"PadMMTest": 7.061333333333331}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 46.976000000000006}, "inductor/test_perf": {"FusionTests": 1.811, "InplacingTests": 0.345, "MinCutPartitioningTests": 0.635, "NoopTests": 0.2255, "NumBytesMetricTests": 2.363, "SchedulerFusionTests": 0.0955, "TilingTests": 0.09}, "inductor/test_profiler": {"DynamoProfilerTests": 2.0504999999999995}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 38.355000000000004}, "inductor/test_smoke": {"SmokeTest": 2.468}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 1.0610000000000002, "MemoryBoundedTests": 0.114, "TestCommAnalysis": 1.0630000000000002, "UnsupportedTests": 0.3865}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 74.42750000000001}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 6.7295}, "inductor/test_storage_offset": {"StorageOffsetTests": 2.058}, "inductor/test_torchinductor": {"CpuTests": 1225.6246666666668, "CudaTests": 625.9101666666661, "GPUTests": 654.57775, "NanCheckerTest": 0.6874999999999999, "RNNTest": 0.8275, "SweepInputsCpuTest": 124.81933333333332, "SweepInputsCudaTest": 28.221499999999995, "SweepInputsGPUTest": 26.295749999999998, "TestFull": 12.165333333333335, "TritonCodeGenTests": 19.834}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 844.2949999999998, "DynamicShapesCodegenCudaTests": 384.6739999999998, "DynamicShapesCodegenGPUTests": 472.9325000000001}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 911.1544999999996, "DynamicShapesCudaTests": 675.9076666666666, "DynamicShapesGPUTests": 721.6004999999997, "TestInductorDynamicCUDA": 18.129}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1242.0814999999914}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.1245}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 3.95}, "inductor/test_unbacked_symints": {"TestUnbackedSymints": 5.481999999999999, "TestUnbackedSymintsCUDA": 12.704}, "inductor/test_utils": {"TestUtils": 0.2165}, "lazy/test_debug_util": {"DebugUtilTest": 0.5705}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.5830000000000001}, "lazy/test_generator": {"LazyGeneratorTest": 0.587}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 2.606}, "lazy/test_step_closures": {"ClosuresTest": 2.526}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.17049999999999998, "TestLazyTensor": 0.4375}, "nn/test_convolution": {"TestConvolutionNN": 296.086, "TestConvolutionNNDeviceTypeCUDA": 58.483499999999864}, "nn/test_dropout": {"TestDropoutNN": 0.9264999999999999, "TestDropoutNNDeviceTypeCUDA": 0.473}, "nn/test_embedding": {"TestEmbeddingNN": 0.796, "TestEmbeddingNNDeviceTypeCUDA": 8.784499999999976}, "nn/test_init": {"TestNNInit": 86.5245}, "nn/test_lazy_modules": {"TestLazyModules": 6.014000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.3684999999999992, "TestLoadStateDictSwap": 0.02}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.07500000000000001, "TestModuleHookNN": 0.08300000000000002, "TestModuleHooks": 0.43000000000000005, "TestStateDictHooks": 0.008}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 414.44999999999993, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.499}, "nn/test_packed_sequence": {"PackedSequenceTest": 6.161}, "nn/test_parametrization": {"TestNNParametrization": 5.842500000000001, "TestNNParametrizationDeviceCUDA": 0.21000000000000002}, "nn/test_pooling": {"TestAvgPool": 0.7665000000000001, "TestPoolingNN": 0.7085, "TestPoolingNNDeviceTypeCUDA": 3.702499999999997}, "nn/test_pruning": {"TestPruningNN": 0.43950000000000006}, "profiler/test_memory_profiler": {"TestDataFlow": 0.6715, "TestIdentifyGradients": 0.2485, "TestMemoryProfiler": 0.5415000000000001, "TestMemoryProfilerE2E": 2.2425}, "profiler/test_profiler": {"TestExecutionTrace": 5.6415, "TestExperimentalUtils": 5.8725000000000005, "TestProfiler": 7.018000000000004, "TestProfilerCUDA": 4.808, "TestProfilerITT": 0.001, "TestRecordFunction": 0.027000000000000003, "TestTorchTidyProfiler": 3.8169999999999993}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.5760000000000001}, "test_ao_sparsity": {"TestActivationSparsifier": 1.8125, "TestBaseDataScheduler": 0.8910000000000001, "TestBaseDataSparsifier": 0.8475, "TestBaseSparsifier": 0.013000000000000001, "TestBaseStructuredSparsifier": 20.259500000000003, "TestComposability": 1.5495, "TestCubicScheduler": 0.003, "TestFPGMPruner": 0.183, "TestFakeSparsity": 0.04050000000000001, "TestFxComposability": 1.4675, "TestNearlyDiagonalSparsifier": 0.374, "TestNormDataSparsifiers": 23.7145, "TestQuantizationUtils": 0.5925, "TestQuantizedSparseKernels": 0.4615, "TestQuantizedSparseLayers": 0.694, "TestSaliencyPruner": 0.0155, "TestScheduler": 0.025500000000000002, "TestSparsityUtilFunctions": 0.022500000000000003, "TestWeightNormSparsifier": 8.3705}, "test_autocast": {"TestAutocastCPU": 1.2715, "TestAutocastGPU": 0.2965, "TestTorchAutocast": 0.002}, "test_autograd": {"TestAllowMutationOnSaved": 0.027500000000000007, "TestAutograd": 15.192499999999992, "TestAutogradComplex": 0.00925, "TestAutogradDeviceTypeCUDA": 1.8592499999999987, "TestAutogradForwardMode": 0.057750000000000024, "TestAutogradForwardModeBatchedGrad": 0.015250000000000001, "TestAutogradFunctional": 8.964250000000003, "TestAutogradInferenceMode": 0.05375000000000001, "TestAutogradLogging": 0.0095, "TestAutogradMultipleDispatchCUDA": 0.017750000000000002, "TestMultithreadAutograd": 0.2895, "TestNestedCheckpoint": 0.36200000000000004}, "test_autograd_fallback": {"TestAutogradFallback": 0.6535000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 185.71850000000182}, "test_bundled_inputs": {"TestBundledInputs": 3.3164999999999996}, "test_comparison_utils": {"TestComparisonUtils": 0.626}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.485}, "test_content_store": {"TestContentStoreCUDA": 2.0595}, "test_cpp_api_parity": {"TestCppApiParity": 13.914499999999961}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.651, "TestORTTensor": 0.066, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.0365}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.632, "TestORTTensor": 0.0665, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.0375}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 282.909}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 24.106}, "test_cuda": {"TestBlockStateAbsorption": 0.0, "TestCuda": 36.7185, "TestCudaMallocAsync": 18.831500000000002}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 24.370500000000007, "TestCudaMallocAsync": 21.07950000000001}, "test_cuda_multigpu": {"TestCudaComm": 0.03500000000000001, "TestCudaMultiGPU": 0.8875}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.1475}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.76, "TestEventHandler": 0.02000000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 6.48}, "test_custom_ops": {"MiniOpTest": 0.3280000000000001, "MiniOpTestOther": 0.033, "TestCustomOp": 0.8295000000000001, "TestCustomOpTestingCUDA": 1.2950000000000002, "TestGenerateOpcheckTests": 0.07200000000000001}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.001, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.07450000000000001, "TestCustomPinFn": 0.0825, "TestDataLoader": 50.2765, "TestDataLoaderDeviceTypeCUDA": 7.911, "TestDataLoaderPersistentWorkers": 74.94650000000001, "TestDatasetRandomSplit": 0.3925, "TestDictDataLoader": 0.0365, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.002, "TestSetAffinity": 0.03, "TestStackDataset": 0.095, "TestStringDataLoader": 0.0335, "TestTensorDataset": 0.012}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.008, "TestDataChunk": 0.40700000000000003, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 3.0469999999999997, "TestFunctionalMapDataPipe": 0.021500000000000002, "TestGraph": 0.008, "TestIterDataPipeCountSampleYielded": 0.005, "TestIterDataPipeGraphFastForward": 0.027, "TestIterDataPipeSingletonConstraint": 0.013000000000000001, "TestIterableDataPipeBasic": 0.0225, "TestSerialization": 3.463, "TestSharding": 0.3955000000000001, "TestStreamWrapper": 0.138, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.023, "HasDecompTest": 6.598000000000001, "TestDecompCUDA": 4536.524999999985}, "test_deploy": {"TestFreezer": 0.535}, "test_dispatch": {"TestDispatch": 37.70450000000001, "TestPythonDispatcher": 0.0665}, "test_dlpack": {"TestTorchDlPackCUDA": 0.6185}, "test_dynamic_shapes": {"TestDimConstraints": 2.0785, "TestFloorDiv": 0.034, "TestPySymInt": 1.2094999999999994, "TestSymNumberMagicMethods": 0.9525000000000005}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 5.732499999999996, "TestExpandedWeightHelperFunctionCUDA": 0.516, "TestExpandedWeightModuleCUDA": 23.773999999999997}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04300000000000001, "FakeTensorConverterTest": 0.012000000000000004, "FakeTensorDispatchCache": 0.041500000000000016, "FakeTensorOpInfoTestCUDA": 0.14250000000000002, "FakeTensorOperatorInvariants": 0.3865, "FakeTensorPropTest": 0.0305, "FakeTensorTest": 0.8720000000000001}, "test_flop_counter": {"TestFlopCounter": 5.516000000000001}, "test_foreach": {"TestForeachCUDA": 114.97699999999958}, "test_function_schema": {"TestFunctionSchema": 0.778}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 0.5295000000000001}, "test_functional_optim": {"TestFunctionalOptimParity": 0.265}, "test_functionalization": {"TestCrossRefFunctionalization": 3.2594999999999983, "TestFunctionalization": 4.192999999999998}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 1.9670000000000003}, "test_futures": {"TestFuture": 1.2289999999999999}, "test_fx": {"AnnotationsTest": 0.009500000000000001, "TestCSEPass": 0.23350000000000004, "TestCommonPass": 0.17600000000000007, "TestConstFold": 0.11850000000000004, "TestConstParamShapeInControlFlow": 0.0245, "TestDCE": 0.015000000000000001, "TestFX": 1.878499999999995, "TestFXAPIBackwardCompatibility": 0.014000000000000002, "TestFunctionalTracing": 0.21000000000000016, "TestMatcher": 0.5720000000000001, "TestOperatorSignaturesCUDA": 0.7245000000000006, "TestPassManager": 0.013500000000000002, "TestSourceMatcher": 0.7284999999999999, "TestSubgraphRewriter": 0.1700000000000001, "TestVisionTracing": 185.383, "TypeCheckerTest": 1.6209999999999993}, "test_fx_experimental": {"TestFXExperimental": 139.83849999999995, "TestNormalizeOperatorsCUDA": 0.7285000000000006, "TestTranslationValidation": 0.08449999999999999}, "test_fx_passes": {"TestFXGraphPasses": 0.7835000000000001, "TestFXMatcherUtils": 0.05500000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.7560000000000001}, "test_import_stats": {"TestImportTime": 2.933}, "test_indexing": {"NumpyTestsCUDA": 0.09000000000000001, "TestIndexingCUDA": 1.7204999999999955}, "test_itt": {"TestItt": 0.5175000000000001}, "test_jit": {"TestAliasAnalysis": 0.013999999999999999, "TestAsync": 0.20750000000000002, "TestAtenPow": 0.015, "TestAutodiffJit": 0.159, "TestAutodiffSubgraphSlicing": 0.14300000000000004, "TestAwait": 0.09650000000000003, "TestBackends": 0.001, "TestBackendsWithCompiler": 0.078, "TestBatchMM": 0.044, "TestBuiltins": 0.0325, "TestCUDA": 0.487, "TestClassType": 0.4765000000000002, "TestComplex": 0.473, "TestCustomOperators": 0.0495, "TestDCE": 0.011, "TestDataParallel": 0.0005, "TestDataclasses": 2.284, "TestDeviceAnalysis": 2.5785, "TestDict": 0.2310000000000001, "TestDtypeAnalysis": 0.221, "TestEnum": 0.08200000000000002, "TestFreezing": 0.9620000000000004, "TestFrontend": 0.028, "TestFrozenOptimizations": 62.714499999999994, "TestFunctionalBlocks": 0.003, "TestFunctionalToInplaceActivation": 5.961, "TestGenerator": 0.031, "TestGetDefaultAttr": 0.004, "TestGraphRewritePasses": 0.1015, "TestHash": 0.0405, "TestHooks": 0.3735000000000001, "TestIgnorableArgs": 0.005, "TestIgnoreContextManager": 0.024, "TestInplaceToFunctionalActivation": 5.3185, "TestIsinstance": 0.10500000000000004, "TestJit": 13.341499999999996, "TestJitGeneratedModule": 57.02700000000016, "TestJitProfiler": 0.001, "TestJitUtils": 0.009000000000000001, "TestList": 0.7790000000000004, "TestLogging": 0.024000000000000004, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.34600000000000003, "TestMixTracingScripting": 0.6970000000000001, "TestModels": 54.03150000000002, "TestModuleAPIs": 0.115, "TestModuleContainers": 0.8180000000000001, "TestModuleInterface": 0.23000000000000004, "TestModules": 0.008, "TestNamedTuple": 0.034, "TestNnapiBackend": 18.447500000000005, "TestOpDecompositions": 0.009500000000000001, "TestOptimizeForMobilePreserveDebugInfo": 0.29550000000000004, "TestParametrization": 0.6635, "TestPeephole": 0.2335000000000001, "TestProducerVersion": 0.001, "TestProfiler": 0.14450000000000002, "TestPythonBindings": 0.016, "TestPythonBuiltinOP": 0.19750000000000004, "TestPythonIr": 0.011, "TestRecursiveScript": 0.33400000000000013, "TestRemoveMutation": 0.06650000000000002, "TestSaveLoad": 0.21550000000000002, "TestSaveLoadFlatbuffer": 0.14200000000000004, "TestSaveLoadForOpVersion": 1.9949999999999999, "TestScript": 19.581000000000003, "TestScriptDict": 0.011500000000000002, "TestScriptList": 0.018500000000000006, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.0615, "TestScriptProfile": 11.708000000000002, "TestSlice": 0.07950000000000004, "TestSparse": 0.21000000000000002, "TestStringFormatting": 0.08050000000000003, "TestSymbolicShapeAnalysis": 4.628999999999999, "TestTensorBuiltins": 0.05449999999999999, "TestTensorCreationOps": 0.024, "TestTensorMethods": 0.005, "TestTorchbind": 0.07100000000000004, "TestTracer": 4.96599999999999, "TestTypeSharing": 0.25450000000000006, "TestTypesAndAnnotation": 0.054000000000000006, "TestTyping": 0.20150000000000007, "TestUnion": 0.2240000000000001, "TestUnsupportedOps": 0.027, "TestUpgraders": 0.03400000000000001, "TestWarn": 0.025000000000000005, "TestWith": 0.15600000000000003}, "test_jit_autocast": {"TestAutocast": 1.1899999999999997, "TestJitTraceAutocast": 15.736999999999998}, "test_jit_disabled": {"TestJitDisabled": 0.7025}, "test_jit_fuser_te": {"TestFuserCommon": 0.0625, "TestNNCOpInfoCUDA": 7.618500000000557, "TestTEFuserDynamic": 325.4649999999999, "TestTEFuserStatic": 506.085}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.1375, "TestFusionPatternCUDA": 0.0, "TestModel": 0.002, "TestOpCUDA": 0.0005}, "test_jiterator": {"TestPythonJiteratorCUDA": 17.123999999999945}, "test_legacy_vmap": {"TestVmapAPI": 145.06399999999977, "TestVmapAPILegacy": 1.2634999999999974, "TestVmapBatchedGradientCUDA": 0.41600000000000015, "TestVmapBatchedGradientLegacyCUDA": 0.49600000000000005, "TestVmapOperators": 4.586999999999999, "TestVmapOperatorsLegacy": 0.7270000000000001}, "test_license": {"TestLicense": 0.5485}, "test_linalg": {"TestLinalgCUDA": 280.055499999998}, "test_logging": {"LoggingTest": 2.2960000000000003}, "test_masked": {"TestMaskedCUDA": 19.724499999999978}, "test_maskedtensor": {"TestBasicsCUDA": 0.18250000000000002, "TestBinary": 0.16300000000000012, "TestOperatorsCUDA": 3.887500000000006, "TestReductions": 0.04500000000000001, "TestUnary": 0.7115000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.0, "TestMatmulCudaCUDA": 18.79550000000002, "TestMixedDtypesLinearCudaCUDA": 0.0}, "test_meta": {"TestMetaCUDA": 1652.175999999865, "TestMetaConverter": 1.1225}, "test_mkl_verbose": {"TestMKLVerbose": 3.136}, "test_mkldnn_fusion": {"TestMkldnnFusion": 209.389}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 2.9255}, "test_mobile_optimizer": {"TestOptimizer": 3.0459999999999994}, "test_model_dump": {"TestModelDump": 1.49}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.194}, "test_module_init": {"TestModuleInitCUDA": 1.4349999999999938}, "test_modules": {"TestModuleCUDA": 557.5404999999738}, "test_monitor": {"TestMonitor": 0.5665, "TestMonitorTensorboard": 0.16999999999999998}, "test_multiprocessing": {"TestMultiprocessing": 43.49149999999999}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.41100000000000003, "SpawnTest": 14.6675}, "test_namedtensor": {"TestNamedTensor": 2.2304999999999953}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.8064999999999998}, "test_native_functions": {"TestNativeFunctions": 0.658}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.9575000000000002}, "test_nestedtensor": {"TestNestedTensor": 0.4675000000000001, "TestNestedTensorAutogradCUDA": 0.7400000000000003, "TestNestedTensorDeviceTypeCUDA": 2.1704999999999948, "TestNestedTensorSubclassCUDA": 1.598499999999999}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.0022500000000000003, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.32075, "TestFusionUtils": 0.003, "TestNN": 86.41275000000019, "TestNNDeviceTypeCUDA": 224.67075000000406}, "test_numba_integration": {"TestNumbaIntegration": 0.597}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.6020000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 3.721}, "test_ops": {"TestCommonCUDA": 3431.6587499999832, "TestCompositeComplianceCUDA": 665.9602499999984, "TestFakeTensorCUDA": 549.559499999998, "TestMathBitsCUDA": 84.53925000000022, "TestSelfKwarg": 0.4795, "TestTagsCUDA": 2.0779999999999927}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 672.8324999999688}, "test_ops_gradients": {"TestBwdGradientsCUDA": 881.0884999999532}, "test_ops_jit": {"TestJitCUDA": 904.012}, "test_optim": {"TestDifferentiableOptimizer": 0.23, "TestLRScheduler": 0.5230000000000002, "TestOptim": 189.221, "TestOptimRenewedCUDA": 58.27299999999999, "TestSWAUtils": 15.951999999999998}, "test_out_dtype_op": {"TestOutDtypeOp": 0.7825000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.014, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.002, "TestRNN": 0.057999999999999996, "TestResolveName": 0.0725, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 2.0714999999998938, "TestTorchFunctionWarning": 0.0215, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.0245, "ModelTest": 0.0, "TestAnalyze": 0.001, "TestDependencyAPI": 0.03450000000000001, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006500000000000001, "TestLoadBCPackages": 0.030000000000000002, "TestMangling": 0.011000000000000001, "TestMisc": 0.018000000000000002, "TestPackageFX": 0.04200000000000001, "TestPackageScript": 1.1059999999999999, "TestRepackage": 0.004, "TestResources": 0.187, "TestSaveLoad": 0.019000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.6315}, "test_prims": {"TestDecompCUDA": 0.015000000000000001, "TestPrimsBasic": 0.40750000000000003, "TestPrimsCUDA": 0.29150000000000004, "TestRefsCUDA": 0.006}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.05800000000000001, "TestGenericProxyTensorFake": 10.185499999999998, "TestGenericProxyTensorReal": 18.001500000000004, "TestGenericProxyTensorSymbolic": 21.643, "TestRealProxyTensor": 0.011, "TestSymbolicTracing": 2.5385}, "test_pruning_op": {"PruningOpTest": 0.6605}, "test_public_bindings": {"TestPublicBindings": 0.5375000000000001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.0205, "TestPythonDispatch": 0.11200000000000007, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 0.5549999999999999, "TestWrapperSubclassAliasingCUDA": 0.17450000000000004}, "test_pytree": {"TestCxxPytree": 0.010500000000000002, "TestGenericPytree": 0.7340000000000002, "TestPythonPytree": 0.03700000000000002}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000001, "TestAOMigrationNNQuantized": 0.027500000000000004, "TestAOMigrationQuantization": 0.011, "TestAOMigrationQuantizationFx": 0.014500000000000002, "TestBackendConfig": 0.024, "TestBiasCorrectionEager": 40.176500000000004, "TestBits": 0.004, "TestBitsCUDA": 0.067, "TestComparatorOps": 27.451, "TestDeprecatedJitQuantized": 2.633, "TestDistributed": 0.3355, "TestDuplicateDQPass": 3.2945, "TestDynamicQuantizedModule": 170.1825, "TestDynamicQuantizedOps": 298.272, "TestEqualizeEager": 4.4595, "TestEqualizeFx": 8.8265, "TestFXGraphMatcher": 0.9500000000000001, "TestFXGraphMatcherModels": 8.884, "TestFXNumericSuiteCoreAPIs": 26.0305, "TestFXNumericSuiteCoreAPIsModels": 50.55, "TestFXNumericSuiteNShadows": 76.88650000000001, "TestFakeQuantize": 0.2335, "TestFakeQuantizeOps": 18.6345, "TestFloat8DtypeCUDA": 0.7074999999999999, "TestFuseEager": 25.839, "TestFuseFx": 4.0205, "TestFusedObsFakeQuant": 1.0165, "TestFusedObsFakeQuantModule": 1.052, "TestFusionPasses": 0.097, "TestFxDetectInputWeightEqualization": 0.336, "TestFxDetectOutliers": 2.9964999999999997, "TestFxModelReportClass": 4.099500000000001, "TestFxModelReportDetectDynamicStatic": 0.8105, "TestFxModelReportDetector": 0.9480000000000001, "TestFxModelReportObserver": 3.015, "TestFxModelReportVisualizer": 0.7909999999999999, "TestGenerateNumericDebugHandle": 0.5780000000000001, "TestGraphUtils": 1.7415, "TestHistogramObserver": 39.4355, "TestMetaDataPorting": 4.2575, "TestModelNumericsEager": 7.6465, "TestNumericSuiteEager": 55.70499999999999, "TestObserver": 3.477, "TestPT2ERepresentation": 21.8385, "TestPadding": 49.6175, "TestQNNPackOps": 21.392500000000002, "TestQuantizationDocs": 0.28, "TestQuantizeDynamicJitOps": 2.5839999999999996, "TestQuantizeDynamicJitPasses": 4.0125, "TestQuantizeEagerOps": 8.3225, "TestQuantizeEagerPTQDynamic": 52.188, "TestQuantizeEagerPTQStatic": 70.69149999999999, "TestQuantizeEagerQAT": 61.801, "TestQuantizeEagerQATNumerics": 97.803, "TestQuantizeFx": 53.10750000000001, "TestQuantizeFxModels": 32.3965, "TestQuantizeFxOps": 143.74849999999998, "TestQuantizeJit": 10.8555, "TestQuantizeJitOps": 247.0655, "TestQuantizeJitPasses": 11.588000000000001, "TestQuantizePT2E": 37.7865, "TestQuantizePT2EQAT": 84.738, "TestQuantizePT2EQATModels": 241.59500000000003, "TestQuantizePT2EQAT_ConvBn1d": 257.02599999999995, "TestQuantizePT2EQAT_ConvBn2d": 266.80600000000004, "TestQuantizePT2EX86Inductor": 145.27249999999998, "TestQuantizedConv": 233.55700000000002, "TestQuantizedEmbeddingOps": 8.7555, "TestQuantizedFunctionalOps": 11.972999999999999, "TestQuantizedLinear": 72.879, "TestQuantizedOps": 996.133, "TestQuantizedTensor": 7.008, "TestRecordHistogramObserver": 0.020499999999999997, "TestReferenceQuantizedModule": 1.7225000000000001, "TestSerialization": 5.274000000000001, "TestStaticQuantizedModule": 570.4589999999998, "TestSubgraphRewriter": 0.619, "TestUtils": 0.027500000000000004, "TestXNNPACKQuantizer": 25.994, "TestXNNPACKQuantizerModels": 31.950499999999998}, "test_reductions": {"TestReductionsCUDA": 67.5570000000014}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 11.116499999999998}, "test_schema_check": {"TestSchemaCheck": 0.8725000000000003, "TestSchemaCheckModeOpInfoCUDA": 417.87899999999433}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 1.875}, "test_serialization": {"TestBothSerializationCUDA": 0.11649999999999999, "TestOldSerialization": 14.549500000000002, "TestSerialization": 6.169000000000007, "TestSubclassSerialization": 0.006}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.6145}, "test_shape_ops": {"TestShapeOpsCUDA": 18.064499999999992}, "test_show_pickle": {"TestShowPickle": 0.5549999999999999}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.742499999999997}, "test_sparse": {"TestSparseAnyCUDA": 320.5279999999982, "TestSparseCUDA": 15.87299999999998, "TestSparseLegacyAndDeprecation": 0.8685, "TestSparseMaskedReductionsCUDA": 1.6485000000000003, "TestSparseMeta": 0.0025, "TestSparseOneOff": 0.105, "TestSparseUnaryUfuncsCUDA": 3.942999999999899}, "test_sparse_csr": {"TestSparseCSRCUDA": 143.3724999999983, "TestSparseCSRSampler": 0.351, "TestSparseCompressedCUDA": 95.47900000000067, "TestSparseCompressedTritonKernelsCUDA": 374.73049999999876}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.001, "TestCUSPARSELTCUDA": 0.0025, "TestSparseSemiStructuredCUDA": 0.064}, "test_spectral_ops": {"TestFFTCUDA": 105.88150000000019}, "test_stateless": {"TestPythonOptimizeMode": 2.2504999999999997, "TestStatelessDeprecation": 1.1949999999999998, "TestStatelessFunctionalAPI": 0.7165}, "test_subclass": {"TestSubclass": 0.6880000000000001}, "test_sympy_utils": {"TestSingletonInt": 0.0035, "TestSympyInterp": 0.5080000000000002, "TestSympySolve": 0.11500000000000002, "TestValueRanges": 12.436500000000002}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.35850000000000026, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.403, "TestTensorCreationCUDA": 73.42950000000035}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0075, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.403, "TestTensorBoardPytorchGraph": 14.9205, "TestTensorBoardSummary": 0.025000000000000012, "TestTensorBoardSummaryWriter": 0.004, "TestTensorBoardUtils": 0.07350000000000001, "TestTensorBoardWriter": 0.0485, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 56.18150000000001}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.005, "TestTensorExprPyBind": 0.8395000000000001}, "test_testing": {"TestAssertClose": 0.34900000000000003, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.030500000000000006, "TestAssertCloseMultiDeviceCUDA": 0.005, "TestAssertCloseQuantized": 0.2485, "TestAssertCloseSparseBSC": 0.009500000000000001, "TestAssertCloseSparseBSR": 0.009500000000000001, "TestAssertCloseSparseCOO": 0.21549999999999997, "TestAssertCloseSparseCSC": 0.009500000000000001, "TestAssertCloseSparseCSR": 0.010499999999999999, "TestFrameworkUtils": 8.467500000000001, "TestImports": 5.9655000000000005, "TestMakeTensorCUDA": 1.0534999999999952, "TestOpInfoSampleFunctionsCUDA": 2.5904999999999374, "TestOpInfos": 0.003, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCUDA": 2.418999999999998, "TestTestingCUDA": 0.7085000000000001}, "test_torch": {"TestBasicVitalSigns": 0.019, "TestDevicePrecisionCUDA": 0.07125000000000002, "TestTorch": 4.117749999999987, "TestTorchDeviceTypeCUDA": 128.99325000000061, "TestVitalSignsCudaCUDA": 0.052000000000000005}, "test_transformers": {"TestAttnBiasCUDA": 1.0709999999999997, "TestAttnMasksCUDA": 0.02266666666666667, "TestSDPACUDA": 1.7414999999999226, "TestSDPACudaOnlyCUDA": 70.30100000000277, "TestSDPAFailureModesCUDA": 0.08550000000000005, "TestTransformersCUDA": 3.8069999999999995}, "test_type_hints": {"TestTypeHints": 0.521}, "test_type_info": {"TestDTypeInfo": 0.544}, "test_type_promotion": {"TestTypePromotionCUDA": 10.649500000000003}, "test_typing": {"TestTyping": 40.513999999999974}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 545.9729999998882}, "test_utils": {"TestAssert": 0.046, "TestBottleneck": 8.0445, "TestCheckpoint": 0.6665000000000001, "TestCollectEnv": 0.8905000000000001, "TestCppExtensionUtils": 0.1125, "TestDataLoaderUtils": 0.1755, "TestDeviceUtilsCUDA": 6.170000000000359, "TestExtensionUtils": 0.0075, "TestHipify": 0.001, "TestHipifyTrie": 0.0085, "TestONNXUtils": 0.0045000000000000005, "TestRenderUtils": 0.0185, "TestStandaloneCPPJIT": 11.7045, "TestTraceback": 0.006}, "test_view_ops": {"TestOldViewOpsCUDA": 10.363500000000002, "TestViewOpsCUDA": 3.747499999999995}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.015000000000000005, "WeakKeyDictionaryTestCase": 0.0175, "WeakTest": 4.327500000000001}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.002, "TestXNNPACKOps": 14.1415, "TestXNNPACKRewritePass": 5.252000000000001, "TestXNNPACKSerDes": 13.774999999999999}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.002}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.14700000000000002, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.003, "TestPickling": 0.1385, "TestPromotion": 0.0}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 10.452, "TestEinsumPath": 0.0, "TestMisc": 0.003}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.372, "TestHalf": 0.0, "TestIinfo": 0.13, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.024, "TestBroadcastedAssignments": 0.05800000000000001, "TestFancyIndexingCast": 0.002, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.42250000000000015, "TestMultiIndexingAutomated": 0.07, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.019000000000000003, "TestArgmax": 0.6185000000000003, "TestArgmaxArgminCommon": 0.02700000000000001, "TestArgmin": 0.6475000000000004, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.025000000000000005, "TestArrayCreationCopyArgument": 0.0, "TestArrayInterface": 0.033, "TestAssignment": 0.07100000000000001, "TestAttributes": 0.017000000000000005, "TestBinop": 0.011, "TestBool": 15.106, "TestCequenceMethods": 0.001, "TestChoose": 0.012, "TestClip": 0.003, "TestCompress": 0.003, "TestConversion": 0.022, "TestCreation": 0.001, "TestDelMisc": 0.001, "TestDot": 0.04050000000000002, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.018000000000000002, "TestFlag": 0.008, "TestFormat": 0.003, "TestFromBuffer": 0.010000000000000002, "TestHash": 0.183, "TestHashing": 0.002, "TestIO": 0.0, "TestInner": 0.132, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.5980000000000001, "TestMatmulOperator": 0.4960000000000001, "TestMethods": 0.9435000000000004, "TestMinMax": 0.003, "TestMinScalarType": 0.004, "TestNewaxis": 0.002, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.012, "TestResize": 0.028000000000000004, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.0195, "TestSortFloatMisc": 0.09400000000000001, "TestStats": 0.1735, "TestSubscripting": 0.001, "TestTake": 0.030000000000000002, "TestVdot": 0.0225, "TestWarnings": 0.001, "TestWhere": 0.601, "TestWritebackIfCopy": 0.015000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.012, "TestArgwhere": 0.017, "TestArrayComparisons": 0.0115, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006, "TestBoolArray": 1.2295, "TestBoolCmp": 0.1105, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.10800000000000007, "TestConvolve": 0.0155, "TestCorrelate": 0.053500000000000006, "TestCreationFuncs": 0.6755, "TestCross": 0.0305, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006, "TestFromiter": 0.0, "TestIndex": 0.004, "TestIndices": 0.025, "TestIsclose": 0.053000000000000005, "TestIsscalar": 0.0605, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.010000000000000002, "TestNonarrayArgs": 0.06850000000000003, "TestNonzeroAndCountNonzero": 0.159, "TestOuterMisc": 0.003, "TestRequire": 0.004, "TestResize": 0.2005, "TestRoll": 0.019500000000000003, "TestRollaxis": 0.002, "TestSeterr": 0.004, "TestStdVar": 0.017, "TestStdVarComplex": 0.007, "TestStringFunction": 0.001, "TestTensordot": 0.01, "TestTypes": 0.0075}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.519, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.060000000000000046, "TestFromInt": 0.015500000000000002, "TestFromString": 0.5515}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.493, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.065, "TestBaseMath": 6.001, "TestBitShifts": 0.058, "TestComplexDivision": 0.0385, "TestConversion": 0.0345, "TestHash": 0.0, "TestModulus": 0.636, "TestMultiply": 0.0, "TestNegative": 0.016, "TestPower": 0.083, "TestRepr": 0.001, "TestScalarOpsMisc": 0.14650000000000002, "TestScalarSubclassingMisc": 0.002, "TestSubtract": 0.016, "TestTypes": 9.4225}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.501, "TestAtleast2d": 0.009000000000000001, "TestAtleast3d": 0.008, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.20000000000000007, "TestHstack": 0.010000000000000002, "TestStackMisc": 0.004, "TestVstack": 0.011000000000000003}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007, "TestFFTShift": 4.28, "TestIRFFTN": 0.009, "TestRFFTFreq": 0.006500000000000001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.7424999999999997, "TestFFTShift": 0.5545, "TestFFTThreadSafe": 22.499000000000002}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.509}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.001, "TestUnique": 0.28150000000000003}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.004, "TestAmax": 0.004, "TestAmin": 0.004, "TestAngle": 0.005, "TestAny": 0.004, "TestAverage": 0.0165, "TestBincount": 0.04300000000000001, "TestCheckFinite": 0.002, "TestCopy": 0.005, "TestCorrCoef": 0.020000000000000004, "TestCov": 0.04950000000000001, "TestCumprod": 0.020999999999999998, "TestCumsum": 0.028, "TestDelete": 0.013000000000000001, "TestDiff": 0.07700000000000001, "TestDigitize": 0.011000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.5050000000000003, "TestFlip": 0.019000000000000003, "TestGradient": 0.10850000000000001, "TestInsert": 0.0085, "TestInterp": 0.03050000000000002, "TestKaiser": 0.007, "TestMedian": 0.068, "TestMeshgrid": 0.035, "TestMsort": 0.0, "TestPercentile": 0.035, "TestPiecewise": 0.008, "TestProd": 0.02, "TestPtp": 0.006500000000000001, "TestQuantile": 0.009000000000000001, "TestRot90": 0.3285, "TestSelect": 0.006, "TestSinc": 0.005, "TestSortComplex": 0.007, "TestTrapz": 0.004, "TestTrimZeros": 0.0085, "TestUnique": 0.005, "Test_I0": 0.013500000000000002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.7400000000000002, "TestHistogramOptimBinNums": 0.024000000000000007, "TestHistogramdd": 1.005}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.007, "TestDiagIndices": 0.003, "TestDiagIndicesFrom": 0.005, "TestFillDiagonal": 0.015000000000000001, "TestGrid": 0.007, "TestIndexExpression": 0.007, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.494}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.009000000000000001, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.10450000000000002, "TestColumnStack": 0.006, "TestDsplit": 0.007, "TestDstack": 0.010000000000000002, "TestExpandDims": 0.005, "TestHsplit": 0.008, "TestKron": 0.0075, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.01, "TestSplit": 0.004, "TestSqueeze": 0.048, "TestTakeAlongAxis": 0.617, "TestTile": 0.053000000000000005, "TestVsplit": 0.006}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.08050000000000002, "TestEye": 0.551, "TestFliplr": 0.005, "TestFlipud": 0.003, "TestHistogram2d": 0.047, "TestTri": 0.778, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.003, "TestTriuIndicesFrom": 0.001, "TestVander": 0.0115}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.506, "TestImag": 0.008, "TestIscomplex": 0.003, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.005, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.008, "TestReal": 0.009000000000000001, "TestRealIfClose": 0.003}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.10650000000000001, "TestCond": 0.1405, "TestDet": 0.0965, "TestEig": 0.021000000000000005, "TestEigh": 0.027500000000000004, "TestEighCases": 0.0, "TestEigvals": 0.037000000000000005, "TestEigvalsh": 0.025, "TestEigvalshCases": 0.0, "TestInv": 0.032, "TestLstsq": 0.196, "TestMatrixRank": 0.23600000000000002, "TestMisc": 0.0395, "TestMisc2": 0.006, "TestMultiDot": 0.0345, "TestNormDouble": 0.6400000000000001, "TestNormInt64": 0.6375000000000002, "TestNormSingle": 0.6410000000000001, "TestNorm_NonSystematic": 0.002, "TestPinv": 0.07, "TestPinvHermitian": 0.023, "TestQR": 0.34650000000000003, "TestSVD": 0.027500000000000004, "TestSVDHermitian": 0.0635, "TestSolve": 0.2185, "TestTensorinv": 0.0155, "TestTensorsolve": 0.004}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.068, "TestCtorNested": 0.002, "TestDefaultDtype": 0.0885, "TestDivmod": 0.010000000000000002, "TestExport": 0.0, "TestMisc": 0.374, "TestNormalizations": 0.003, "TestOneArr": 0.6230000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.0, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.043500000000000004, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5790000000000001}, "torch_np/test_dtype": {"TestConvertDType": 0.524}, "torch_np/test_function_base": {"TestAppend": 0.5635}, "torch_np/test_ndarray_methods": {"TestAmax": 0.005, "TestAmin": 0.005, "TestArgmax": 0.6155000000000004, "TestArgmaxArgminCommon": 0.027000000000000007, "TestArgmin": 0.6605000000000003, "TestContains": 0.001, "TestIndexing": 0.186, "TestIter": 0.003, "TestNoExtraMethods": 0.006, "TestNonzero": 0.0935, "TestRavel": 0.004, "TestReshape": 0.003, "TestTranspose": 0.0775}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.030000000000000013, "TestNEP50Table": 0.0}, "torch_np/test_random": {"TestChoice": 0.0055, "TestNumpyGlobal": 0.002, "TestScalarReturn": 0.16650000000000004, "TestShuffle": 0.007}, "torch_np/test_reductions": {"TestAll": 0.007, "TestAny": 0.007, "TestFlatnonzero": 0.5705, "TestGenericCumSumProd": 0.02, "TestGenericReductions": 1.400999999999983, "TestMean": 0.10049999999999999, "TestSum": 0.14500000000000002}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.15300000000000002, "TestIsScalar": 0.08200000000000002}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.34800000000000025, "TestNdarrayDunderVsUfunc": 0.2295000000000001, "TestUfuncDtypeKwd": 0.003, "TestUnaryUfuncs": 0.5795000000000001}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5940000000000001}}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_collectives": {"TestFullyShardCollectives": 128.9675}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 7.032, "TestFullyShardCommunication": 6.188}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.39849999999999997, "TestFullyShardDeviceTensor": 0.6659999999999999, "TestFullyShardLazyInit": 0.321, "TestFullyShardManagedModulesAndStates": 0.0935, "TestFullyShardMeshArg": 0.0285, "TestFullyShardParamModuleInfos": 0.033, "TestFullyShardShardedParameterDTensor": 0.186, "TestFullyShardShardedParameterTensor": 0.174}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.7635000000000001}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCore": 150.368, "TestFullyShardForwardInputs": 0.6445000000000001, "TestFullyShardRegisteredParams": 2.776, "TestFullyShardSharedParams": 9.561}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 77.859}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 37.197}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 7.0235}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 32.226}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 16.093}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 19.514499999999998}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 6.9695}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 1.185}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 69.59299999999999}, "distributed/_composable/test_contract": {"TestContract": 0.3055}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 10.5745, "ReplicateTest": 37.95100000000001}, "distributed/_composable/test_replicate_with_compiler": {"ReplicateTest": 51.012}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 24.1535}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.9984999999999999}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 16.505, "TestShardingSpec": 0.1915}, "distributed/_shard/test_sharder": {"TestCustomSharder": 9.34}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 1.2414999999999998}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.6245}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 17.9785}, "distributed/_tensor/test_api": {"DTensorAPITest": 28.9005}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 50.5895}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 56.227}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 45.3125, "DTensorTest": 128.683, "TestDTensorPlacementTypes": 5.609999999999999}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 7.394, "TestDTensorCompileE2E": 60.1135, "TestDTensorCompileWithNativeFunCol": 0.41500000000000004}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 22.345}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 21.079}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 29.644000000000002, "DTensorInitOpsTest": 6.9285}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 58.937}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 62.929500000000004}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.23100000000000004, "TestEinsumDims": 0.254, "TestEinsumStrategies": 0.108}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 76.7665}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.917}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 7.2225, "DistTensorRandomOpTest": 36.436499999999995}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 5.686, "RedistributeTest": 39.5025}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 154.4625}, "distributed/_tensor/test_utils": {"UtilTest": 11.674999999999999}, "distributed/_tensor/test_view_ops": {"TestViewOps": 10.1635}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.27}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 3.9844999999999997}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 41.706}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 63.94499999999999}, "distributed/algorithms/test_join": {"TestJoin": 50.5695}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ELoadAndSave": 21.380999999999997, "TestE2ESaveAndLoad": 41.7365}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 4.8555}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 4.5169999999999995}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 6.3965}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 13.366999999999999, "TestDistributedFailure": 31.1805}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.7489999999999999}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.2945}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 8.0175}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 32.9885, "TestDTensorReshardPlacementChange": 12.651}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 30.7305, "TestDistributedStateDictSaveLoad": 0.6755, "TestDistributedStateDictSaveLoadWithSharedTensor": 7.027}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 41.126000000000005, "TestDistributedStateDictSaveLoad": 0.837, "TestDistributedStateDictSaveLoadWithSharedTensor": 10.008}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 13.2195}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 17.8985}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 9.9645}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.8300000000000001, "TestFSSpecWithDist": 9.965}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 17.044}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.2955}, "distributed/checkpoint/test_planner": {"TestPlannerHelpers": 0.003, "TestSavePlan": 0.316}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 3.38}, "distributed/checkpoint/test_state_dict": {"TestStateDict": 94.1265}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 18.404}, "distributed/checkpoint/test_torch_save_to_dcp": {"TestTorchSaveToDCP": 15.559999999999999}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 16.3585}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.31200000000000006}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.3155}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.9835, "RdzvEventLibTest": 0.1}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.92}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.9215, "StartProcessesListTest": 21.579499999999996, "StartProcessesTest": 16.2425, "StdTest": 0.005}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 14.747}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.22050000000000003, "LocalTimerTest": 4.1450000000000005, "MultiprocessingRequestQueueTest": 2.231}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 4.237}, "distributed/elastic/utils/logging_test": {"LoggingTest": 1.0710000000000002}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.9345000000000001, "UtilTest": 0.07350000000000001}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 1.4644999999999997}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.27849999999999997}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 20.7545}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 10.1315}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 129.8285, "TestFSDPCheckpointSubmodule": 7.5515}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 62.64349999999999}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 68.697}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 196.93200000000002}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 11.1655, "TestHooks": 60.78349999999999, "TestNoGrad": 15.83, "TestParamInit": 15.52, "TestParityWithDDP": 2488.0715}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 121.9915}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 61.855000000000004}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 55.934}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 66.1515}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 269.257}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.317}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 74.85900000000001}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 75.99199999999999}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 99.63750000000002}, "distributed/fsdp/test_fsdp_input": {"TestInput": 13.797999999999998}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 23.481}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 64.0965}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 108.6135, "TestFSDPMiscMultiThread": 1.7669999999999997, "TestFSDPMiscWorldSize1": 0.018}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 38.747, "TestFSDPMixedPrecisionIgnoredModules": 5.042, "TestFSDPMixedPrecisionSharded": 414.4325, "TestFSDPMixedPrecisionUnsharded": 17.8805, "TestFSDPTrainEval": 9.619}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 8.2125}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 7.679}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 519.1379999999999}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 100.83699999999999, "TestForwardOverlapWorldSizeTwo": 111.987}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 14.854}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.7535000000000001, "TestShardedGradScalerParityWithDDP": 174.35399999999998}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 1241.0155, "TestFSDPStateDict4GPUs": 6.2595}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 37.04}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 6.89}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 7.758}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 58.47749999999999, "TestUnshardParamsErrors": 23.677500000000002, "TestUnshardParamsNoShard": 11.771500000000001}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 6.898999999999999, "TestFSDPUseOrigParamsInit": 7.1465, "TestFSDPUseOrigParamsMultipleParamGroups": 84.4505, "TestFSDPUseOrigParamsNoSync": 15.363499999999998, "TestFSDPUseOrigParamsParamAccess": 8.160499999999999, "TestFSDPUseOrigParamsUnshardReshard": 45.739999999999995, "TestFSDPUseOrigParamsWriteback": 38.653, "TestMultiTensorApply": 0.14400000000000002}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 35.878}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 6.685499999999999, "TestShardUtilsDistributedDTensor": 6.256}, "distributed/fsdp/test_utils": {"TestUtils": 1.4829999999999997}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 7.7364999999999995, "TestFSDPWrap": 162.88649999999998, "TestWrapUtils": 0.026}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.9420000000000001}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 196.5245, "TestZeroRedundancyOptimizerSingleRank": 46.048}, "distributed/pipeline/sync/skip/test_api": {"test_api": 0.0185}, "distributed/pipeline/sync/skip/test_gpipe": {"test_gpipe": 5.542}, "distributed/pipeline/sync/skip/test_inspect_skip_layout": {"test_inspect_skip_layout": 0.0105}, "distributed/pipeline/sync/skip/test_leak": {"test_leak": 0.7190000000000001}, "distributed/pipeline/sync/skip/test_portal": {"TestTensorLife": 0.006, "test_portal": 0.37}, "distributed/pipeline/sync/skip/test_stash_pop": {"test_stash_pop": 0.034}, "distributed/pipeline/sync/skip/test_tracker": {"test_tracker": 0.4545}, "distributed/pipeline/sync/skip/test_verify_skippables": {"test_verify_skippables": 0.015000000000000003}, "distributed/pipeline/sync/test_balance": {"test_balance": 9.013499999999999}, "distributed/pipeline/sync/test_bugs": {"test_bugs": 5.0305}, "distributed/pipeline/sync/test_checkpoint": {"test_checkpoint": 1.1945000000000001}, "distributed/pipeline/sync/test_copy": {"test_copy": 5.0809999999999995}, "distributed/pipeline/sync/test_deferred_batch_norm": {"test_deferred_batch_norm": 2.092}, "distributed/pipeline/sync/test_dependency": {"test_dependency": 0.43599999999999994}, "distributed/pipeline/sync/test_inplace": {"test_inplace": 0.3385}, "distributed/pipeline/sync/test_microbatch": {"test_microbatch": 0.017000000000000005}, "distributed/pipeline/sync/test_phony": {"test_phony": 0.018500000000000003}, "distributed/pipeline/sync/test_pipe": {"test_pipe": 4.903499999999999}, "distributed/pipeline/sync/test_pipeline": {"test_pipeline": 0.003}, "distributed/pipeline/sync/test_stream": {"TestCurrentStream": 0.001, "TestDefaultStream": 0.0, "TestGetDevice": 0.0, "TestNewStream": 0.4495, "TestRecordStream": 0.6565, "TestUseDevice": 0.0, "TestUseStream": 0.0005, "TestWaitStream": 0.778}, "distributed/pipeline/sync/test_transparency": {"test_transparency": 0.5269999999999999}, "distributed/pipeline/sync/test_worker": {"test_worker": 0.029}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 4.821}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 18.292499999999997, "TestNew2dParallelTraining": 23.4025}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 37.8955}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 47.391}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 4.664}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 51.646}, "distributed/tensor/parallel/test_view_sharding_dim_change": {"TPViewShardingDimChangeTest": 5.068}, "distributed/test_c10d_common": {"CommTest": 4.8595, "ComputeBucketAssignmentTest": 1.1, "ProcessGroupWithDispatchedCollectivesTests": 9.4515, "PythonProcessGroupExtensionTest": 40.056, "ReduceOpTest": 1.0835, "TimeoutTest": 46.8585}, "distributed/test_c10d_functional_native": {"C10DFunctionalNativeTest": 247.48700000000002}, "distributed/test_c10d_gloo": {"CommTest": 56.21150000000001, "CompilerTest": 61.748999999999995, "DistributedDataParallelTest": 248.7025, "GlooProcessGroupWithDispatchedCollectivesTests": 32.256, "LargeCommTest": 15.4215, "ProcessGroupGlooTest": 305.856, "ReducerTest": 0.3735, "RendezvousEnvTest": 0.3135, "TimeoutTest": 5.0655}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 25.067}, "distributed/test_c10d_nccl": {"CommTest": 101.41100000000002, "CompilerTest": 84.483, "DistributedDataParallelTest": 643.5140000000001, "LargeCommTest": 68.4915, "NCCLTraceTest": 69.42150000000001, "NCCLTraceTestDumpOnTimeout": 19.275, "NCCLTraceTestTimeoutDumpOnIdleRanks": 10.694, "NCCLTraceTestTimeoutDumpOnStuckRanks": 9.4345, "NcclErrorHandlingTest": 35.1345, "NcclProcessGroupWithDispatchedCollectivesTests": 31.089, "ProcessGroupNCCLNoGPUTest": 0.0015, "ProcessGroupNCCLTest": 209.6385, "RendezvousEnvTest": 0.2375, "SparseCollective": 6.3125, "TimeoutTest": 4.6899999999999995, "WorkHookTest": 30.246499999999997}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 57.94800000000001}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 126.9005, "TestDDPWithWorkWrapper": 126.6805}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 6.161, "ProcessGroupShareTensorTest": 22.853, "TestDistributedNNFunctionsGloo": 41.334}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 30.7195, "TestDistributedNNFunctionsNccl": 59.223000000000006}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.0045000000000000005, "TestDistributedNNFunctionsUcc": 0.009000000000000001}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 46.485}, "distributed/test_data_parallel": {"TestDataParallel": 12.136, "TestDataParallelDeviceTypeCUDA": 0.13250000000000003}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 16.2815, "DeviceMeshCollectiveTestWithNativeFunCol": 16.093, "DeviceMeshTest": 30.0835, "DeviceMeshTestNDim": 10.734, "DeviceMeshTestWithNativeFunCol": 30.7985, "InitDeviceMeshTest": 16.015, "TestDeviceMeshGetItem": 21.665, "TestMeshEnv": 24.438499999999998}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 5142.826499999988}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 14.7335, "TestMultiProc": 95.936, "TestSingleProc": 31.867999999999995}, "distributed/test_fake_pg": {"TestFakePG": 2.9369999999999994}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 61.34649999999999, "TestExpand": 0.5355000000000001, "TestGradCollectives": 0.009000000000000001, "TestMakeFx": 0.116, "TestMetaCollectives": 0.0035, "TestNCCLCollectivesWithWorldSize4": 51.725, "TestOpWaitiness": 0.035, "TestPgTag": 0.059, "TestTraceableCollectives": 0.2605}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 5.5009999999999994, "TestCollectivesMultiProc": 163.1165}, "distributed/test_launcher": {"TestDistributedLaunch": 2.5555}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.6125, "TestCollectivesWithWrapper": 0.3215}, "distributed/test_nccl": {"TestNCCLCUDA": 2.070499999999999}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 51.99950000000001, "ProcessGroupNCCLWrapperTest": 49.371500000000005}, "distributed/test_store": {"FileStoreTest": 3.8925, "HashStoreTest": 2.064, "InitPgWithUvStore": 2.083, "LibUvTCPStoreTest": 19.3365, "PrefixFileStoreTest": 3.1995, "PrefixStoreTest": 0.0885, "PrefixTCPStoreTest": 2.353, "PythonStoreTest": 0.257, "RendezvousEnvTest": 0.33999999999999997, "RendezvousFileTest": 0.5165, "RendezvousTCPTest": 32.802499999999995, "RendezvousTest": 0.5145, "TCPStoreTest": 13.423000000000002, "TestMultiThreadedWait": 1.823, "TestPythonStore": 2.0549999999999997, "TimeoutTest": 7.827500000000001}}}, "linux-focal-rocm6.0-py3.8": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 2.176}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 3.8379999999999996}, "distributions/test_constraints": {"test_constraints": 3.5580000000000003}, "distributions/test_distributions": {"TestAgainstScipy": 0.81, "TestConstraints": 0.098, "TestDistributionShapes": 0.09600000000000006, "TestDistributions": 33.048000000000016, "TestFunctors": 0.007, "TestJit": 9.113, "TestKL": 2.0809999999999995, "TestLazyLogitsInitialization": 0.007, "TestNumericalStability": 0.047000000000000014, "TestRsample": 0.49300000000000005, "TestValidation": 0.24000000000000005}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 32.766000000000005}, "dynamo/test_after_aot": {"TestAfterAot": 4.485}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 25.08799999999999}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.30300000000000005}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.0449999999999995}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0, "NormalizeIRTests": 0.025, "TestCustomBackendAPI": 1.295, "TestExplainWithBackend": 7.259, "TestOptimizations": 0.767}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 9.42}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 4.605}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.108, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.32600000000000007}, "dynamo/test_config": {"ConfigTests": 0.329}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.202, "CppGuardManagerFuncTorchHigherOrderOpTests": 7.496999999999997, "CppGuardManagerFunctionTests": 19.18600000000003, "CppGuardManagerHigherOrderOpTests": 5.168999999999996, "CppGuardManagerMiscTests": 45.4770000000001, "CppGuardManagerReproTests": 34.69600000000005}, "dynamo/test_ctx_manager": {"CtxManagerTests": 3.9629999999999983}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 2.9669999999999996}, "dynamo/test_debug_utils": {"TestDebugUtils": 3.0579999999999994}, "dynamo/test_decorators": {"DecoratorTests": 0.40800000000000014}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.012}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 17.865, "DynamicShapesCtxManagerTests": 9.983, "DynamicShapesExportTests": 60.98500000000001, "DynamicShapesFuncTorchHigherOrderOpTests": 94.05699999999999, "DynamicShapesFunctionTests": 50.89099999999999, "DynamicShapesHigherOrderOpTests": 11.352000000000002, "DynamicShapesMiscTests": 81.745, "DynamicShapesNNModuleTests": 5.093999999999999, "DynamicShapesReproTests": 79.00099999999998, "DynamicShapesSubGraphTests": 6.154, "DynamicShapesTestSDPA": 0.258}, "dynamo/test_exc": {"ExcTests": 1.534}, "dynamo/test_export": {"ExportTests": 17.297999999999995}, "dynamo/test_export_mutations": {"MutationExportTests": 0.33100000000000007}, "dynamo/test_frame_init": {"FrameInitTests": 0.188}, "dynamo/test_functions": {"DefaultsTests": 0.5190000000000001, "FunctionTests": 5.551999999999983}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.195}, "dynamo/test_global": {"TestGlobals": 0.30100000000000005}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.21600000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 8.337, "FuncTorchHigherOrderOpTests": 7.471999999999998, "HigherOrderOpTests": 5.279999999999999, "HigherOrderOpVmapGuardTests": 2.6190000000000007}, "dynamo/test_hooks": {"HooksTests": 18.84400000000001}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.026000000000001}, "dynamo/test_interop": {"InteropTests": 0.321}, "dynamo/test_logging": {"LoggingTests": 22.027000000000008}, "dynamo/test_minifier": {"MinifierTests": 4.484999999999999}, "dynamo/test_misc": {"MiscTests": 41.88200000000009, "TestTracer": 0.039}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0}, "dynamo/test_modules": {"NNModuleTests": 5.220999999999999, "OptimizedModuleTest": 9.065000000000001}, "dynamo/test_nops": {"NopTests": 0.251}, "dynamo/test_optimizers": {"End2EndTests": 0.46, "OptimizerTests": 1.536}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.323}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.03}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.422}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.7390000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.54}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.29000000000000004}, "dynamo/test_replay_record": {"ReplayRecordTests": 1.0003333333333335}, "dynamo/test_repros": {"ReproTests": 29.878999999999998}, "dynamo/test_sdpa": {"TestSDPA": 0.28700000000000003}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.30500000000000005}, "dynamo/test_sources": {"SourceTests": 0.25}, "dynamo/test_structured_trace": {"StructuredTraceTest": 16.114}, "dynamo/test_subclasses": {"SubclassTests": 1.6739999999999995, "TestNestedTensor": 10.286000000000003}, "dynamo/test_subgraphs": {"SubGraphTests": 1.6259999999999994}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.031, "TraceRuleTests": 1.8619999999999999}, "dynamo/test_triton_kernels": {"KernelTests": 13.758999999999997, "MutationTests": 0.024000000000000014, "NoOptimizationKernelTests": 2.713499999999998, "no_opt_test_class": 3.0264999999999986}, "dynamo/test_unspec": {"UnspecTests": 8.238999999999999}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.337}, "export/test_db": {"ExampleTests": 2.1049999999999995}, "export/test_experimental": {"TestExperiment": 0.388}, "export/test_export": {"TestDynamismExpression": 0.261, "TestExport": 19.90299999999999, "TestExportCustomClass": 0.045, "TestOneOffModelExportResult": 0.9500000000000001}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.227, "NonStrictExportTestExport": 18.022000000000006}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.31, "PreDispatchExportTestExport": 21.162000000000006}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.707}, "export/test_hop": {"TestHOPCUDA": 0.654, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.001, "TestLift": 0.055, "TestLiftUnlift": 0.0875}, "export/test_pass_infra": {"TestPassInfra": 0.6430000000000001}, "export/test_passes": {"TestPasses": 9.166}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.425, "RetraceExportTestExport": 27.458999999999985}, "export/test_safeguard": {"TestSafeguard": 0.5650000000000001}, "export/test_schema": {"TestSchema": 0.22}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.178, "SerDesExportPreDispatchTestExport": 15.586999999999998, "SerDesExportTestDynamismExpression": 0.323, "SerDesExportTestExport": 20.083999999999996}, "export/test_serialize": {"TestDeserialize": 9.049999999999999, "TestOpVersioning": 0.003, "TestSaveLoad": 0.19999999999999998, "TestSchemaVersioning": 0.021, "TestSerialize": 0.746, "TestSerializeCustomClass": 0.058}, "export/test_torchbind": {"TestExportTorchbind": 1.1560000000000001, "TestRegisterFakeClass": 0.003}, "export/test_tree_utils": {"TestTreeUtils": 0.188}, "export/test_unflatten": {"TestUnflatten": 2.286}, "export/test_upgrade": {"TestUpgrade": 0.35000000000000003}, "export/test_verifier": {"TestVerifier": 0.599}, "functorch/test_aotdispatch": {"TestAOTAutograd": 11.304999999999998, "TestAOTDispatch": 0.34099999999999997, "TestAOTExport": 1.456, "TestAOTModuleSimplified": 0.6950000000000001, "TestPartitioning": 7.485}, "functorch/test_control_flow": {"TestControlFlow": 0.8950000000000002, "TestControlFlowTraced": 67.72799999999995}, "functorch/test_dims": {"TestMin": 11.596, "TestMinFunctorchOnly": 9.492}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.115, "TestAutogradFunctionVmapAPICUDA": 0.015000000000000001, "TestCompileTransformsCUDA": 0.34400000000000003, "TestComposabilityCUDA": 0.14000000000000007, "TestExamplesCorrectnessCUDA": 3.2849999999999997, "TestFunctionalizeCUDA": 0.08100000000000002, "TestGradTransformCUDA": 3.897999999999993, "TestHelpersCUDA": 0.009000000000000001, "TestHessianCUDA": 0.041, "TestHigherOrderOperatorInteractionCUDA": 0.020000000000000004, "TestJacCUDA": 0.4520000000000002, "TestJvpCUDA": 0.042000000000000016, "TestLinearizeCUDA": 0.11, "TestMakeFunctional": 0.7390000000000001, "TestSliceArgnums": 0.096, "TestVmapJvpInplaceViewCUDA": 0.012, "TestVmapOfGradCUDA": 0.34900000000000003}, "functorch/test_logging": {"TestAOTLogging": 0.217}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.11800000000000002, "RandomOpTestCase": 0.232, "ReduceTestCase": 0.059, "TestMemoryEfficientOpAuthoring": 7.864000000000001}, "functorch/test_minifier": {"TestMinifier": 0.3460000000000001}, "functorch/test_ops": {"TestOperatorsCUDA": 2844.368999999999}, "functorch/test_parsing": {"TestAnonymousAxis": 0.734, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.772}, "functorch/test_vmap": {"TestRandomnessCUDA": 1.0880000000000003, "TestTransformFailureCUDA": 0.053000000000000005, "TestVmapAPI": 3.673, "TestVmapBatchedGradientCUDA": 0.14500000000000005, "TestVmapDeviceTypeCUDA": 0.099, "TestVmapNestedTensorCUDA": 0.038000000000000006, "TestVmapOperators": 3.3429999999999893, "TestVmapOperatorsOpInfoCUDA": 305.03399999999937}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.527999999999845}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.529}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 550.747, "AOTInductorTestABICompatibleCpuWithStackAllocation": 376.7170000000001, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 167.49399999999997, "AOTInductorTestABICompatibleCuda": 901.675, "AOTInductorTestNonABICompatibleCpu": 1138.8799999999999, "AOTInductorTestNonABICompatibleCuda": 1447.922}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 5.515, "BenchmarkFusionCudaTest": 105.422, "BenchmarkMultiTemplateFusionCudaTest": 41.105999999999995}, "inductor/test_binary_folding": {"FreezingCpuTests": 25.758000000000003, "FreezingCudaTests": 7.864}, "inductor/test_codecache": {"TestFxGraphCache": 79.63699999999999, "TestFxGraphCacheHashing": 0.6739999999999999, "TestUtils": 2.742, "test_codecache": 5.074}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.2}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 197.4210000000004, "TestAutogradWithCompiledAutograd": 7.526000000000006, "TestCompiledAutograd": 163.39800000000005, "TestCustomOpWithCompiledAutograd": 0.31100000000000017}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 654.423, "CompiledOptimizerTests": 647.1799999999998}, "inductor/test_config": {"TestInductorConfig": 3.675999999999998}, "inductor/test_control_flow": {"CondTests": 99.48, "WhileLoopTests": 37.46100000000001}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.338}, "inductor/test_cpu_repro": {"CPUReproTests": 426.004}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 420.10299999999995, "TestCudaWrapper": 406.0089999999999}, "inductor/test_cuda_repro": {"CudaReproTests": 118.369}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 92.849}, "inductor/test_custom_lowering": {"TestCustomLowering": 4.86}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 8.408}, "inductor/test_cutlass_backend": {"TestCutlassBackend": 42.992333333333335}, "inductor/test_debug_trace": {"TestDebugTrace": 1.842}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 50.982000000000006}, "inductor/test_dependencies": {"TestDependencies": 0.161}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 27.201000000000008}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.001, "EfficientConvBNEvalCudaTests": 0.0}, "inductor/test_extension_backend": {"ExtensionBackendTests": 35.729}, "inductor/test_flex_attention": {"TestTemplatedSDPA": 0.002}, "inductor/test_foreach": {"ForeachTests": 387.06299999999976}, "inductor/test_fp8": {"TestFP8Types": 0.002}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 19.50700000000001, "SDPAPatternRewriterCpuTests": 22.667999999999992, "SDPAPatternRewriterCudaDynamicTests": 39.55300000000001, "SDPAPatternRewriterCudaTests": 87.75199999999998}, "inductor/test_fx_fusion": {"TestFxFusion": 0.44100000000000006}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.017, "TestGroupBatchFusion": 76.641, "TestPostGradBatchLinearFusion": 2.658}, "inductor/test_indexing": {"ExprPrinterTests": 0.038000000000000006, "TestIndexingSimplification": 0.375}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 42.96900000000001, "FreezingCudaTests": 43.473000000000006}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 8.36}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 138.55200000000002}, "inductor/test_layout_optim": {"TestLayoutOptim": 15.308}, "inductor/test_max_autotune": {"TestMaxAutotune": 205.09600000000003, "TestTuningProcess": 10.084}, "inductor/test_memory_planning": {"TestMemoryPlanning": 5.477}, "inductor/test_metrics": {"TestMetrics": 4.111}, "inductor/test_minifier": {"MinifierTests": 24.286}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 44.799}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 25.402999999999995, "TestPatternMatcher": 60.04800000000013}, "inductor/test_mmdecomp": {"TestDecompCUDA": 18.236000000000008}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 12.591000000000001}, "inductor/test_multi_kernel": {"MultiKernelTest": 68.58399999999999}, "inductor/test_pad_mm": {"PadMMTest": 204.70399999999998}, "inductor/test_padding": {"PaddingTest": 15.832, "PerfTestBetweenGoodAndBadShape": 0.001, "PerfTestWithAndWithoutPadding": 7.829}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 98.15400000000002}, "inductor/test_perf": {"FusionTests": 4.253, "InplacingTests": 0.24400000000000002, "MinCutPartitioningTests": 1.563, "NoopTests": 0.24799999999999997, "NumBytesMetricTests": 5.529000000000001, "SchedulerFusionTests": 0.189, "TilingTests": 0.1}, "inductor/test_profiler": {"DynamoProfilerTests": 5.545}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 107.25299999999999}, "inductor/test_smoke": {"SmokeTest": 8.747}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 4.394, "MemoryBoundedTests": 0.13, "TestCommAnalysis": 1.105, "UnsupportedTests": 0.374}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 79.283}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 13.527000000000001}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.002}, "inductor/test_torchinductor": {"GPUTests": 1489.9109999999991, "NanCheckerTest": 2.2547499999999996, "RNNTest": 0.7247499999999999, "SweepInputsGPUTest": 97.14800000000001, "TritonCodeGenTests": 48.600500000000004}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 969.1930000000002, "DynamicShapesCodegenGPUTests": 962.3700000000001}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1112.884, "DynamicShapesGPUTests": 1635.842, "TestInductorDynamicCUDA": 25.168999999999997}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 3844.8939999999957}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.525}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.146}, "inductor/test_triton_kernels": {"KernelTests": 40.30700000000004, "MutationTests": 0.05200000000000003, "NoOptimizationKernelTests": 10.720500000000003, "no_opt_test_class": 10.990000000000004}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 6.371}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 31.461000000000002}, "inductor/test_utils": {"TestUtils": 0.184}, "lazy/test_debug_util": {"DebugUtilTest": 0.756}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.787}, "lazy/test_generator": {"LazyGeneratorTest": 0.754}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 2.299}, "lazy/test_step_closures": {"ClosuresTest": 2.738}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.156, "TestLazyTensor": 0.645}, "nn/test_convolution": {"TestConvolutionNN": 301.948, "TestConvolutionNNDeviceTypeCUDA": 61.93399999999992}, "nn/test_dropout": {"TestDropoutNN": 1.019, "TestDropoutNNDeviceTypeCUDA": 0.44399999999999995}, "nn/test_embedding": {"TestEmbeddingNN": 1.2019999999999995, "TestEmbeddingNNDeviceTypeCUDA": 9.419999999999986}, "nn/test_init": {"TestNNInit": 3.92}, "nn/test_lazy_modules": {"TestLazyModules": 4.25}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.7079999999999993, "TestLoadStateDictSwap": 0.035}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.013000000000000001, "TestModuleHookNN": 0.08900000000000001, "TestModuleHooks": 0.6930000000000001, "TestStateDictHooks": 0.009000000000000001}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 498.09, "TestMultiheadAttentionNNDeviceTypeCUDA": 2.989999999999999}, "nn/test_packed_sequence": {"PackedSequenceTest": 4.149}, "nn/test_parametrization": {"TestNNParametrization": 7.523999999999998, "TestNNParametrizationDeviceCUDA": 2.886}, "nn/test_pooling": {"TestAvgPool": 0.93, "TestPoolingNN": 0.541, "TestPoolingNNDeviceTypeCUDA": 3.4989999999999988}, "nn/test_pruning": {"TestPruningNN": 0.7010000000000001}, "profiler/test_execution_trace": {"TestExecutionTrace": 5.625}, "profiler/test_memory_profiler": {"TestDataFlow": 0.6950000000000001, "TestIdentifyGradients": 0.185, "TestMemoryProfiler": 0.796, "TestMemoryProfilerE2E": 2.721}, "profiler/test_profiler": {"TestExecutionTrace": 4.725, "TestExperimentalUtils": 2.0529999999999995, "TestProfiler": 21.804000000000002, "TestProfilerCUDA": 2.812, "TestProfilerITT": 0.003, "TestRecordFunction": 0.03900000000000001, "TestTorchTidyProfiler": 4.071999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.855}, "profiler/test_record_function": {"TestRecordFunction": 0.793}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.7179999999999995}, "test_ao_sparsity": {"TestActivationSparsifier": 2.346, "TestBaseDataScheduler": 1.068, "TestBaseDataSparsifier": 1.034, "TestBaseSparsifier": 0.019000000000000003, "TestBaseStructuredSparsifier": 38.471000000000004, "TestComposability": 2.375, "TestCubicScheduler": 0.003, "TestFPGMPruner": 0.294, "TestFakeSparsity": 0.044, "TestFxComposability": 1.919, "TestNearlyDiagonalSparsifier": 0.41800000000000004, "TestNormDataSparsifiers": 29.938000000000002, "TestQuantizationUtils": 0.721, "TestQuantizedSparseKernels": 0.62, "TestQuantizedSparseLayers": 1.016, "TestSaliencyPruner": 0.018000000000000002, "TestScheduler": 0.032999999999999995, "TestSparsityUtilFunctions": 0.025, "TestWeightNormSparsifier": 17.208}, "test_autocast": {"TestAutocastCPU": 1.6989999999999998, "TestAutocastGPU": 2.849, "TestTorchAutocast": 0.004}, "test_autograd": {"TestAllowMutationOnSaved": 0.038000000000000006, "TestAutograd": 24.507250000000006, "TestAutogradComplex": 0.010249999999999999, "TestAutogradDeviceTypeCUDA": 1.738249999999999, "TestAutogradForwardMode": 0.09275000000000004, "TestAutogradForwardModeBatchedGrad": 0.018750000000000003, "TestAutogradFunctional": 10.119249999999997, "TestAutogradInferenceMode": 0.069, "TestAutogradLogging": 0.01275, "TestAutogradMultipleDispatchCUDA": 0.023500000000000004, "TestMultithreadAutograd": 0.2745000000000001, "TestNestedCheckpoint": 0.41975000000000007}, "test_autograd_fallback": {"TestAutogradFallback": 0.8230000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 173.57975000000147}, "test_bundled_inputs": {"TestBundledInputs": 1.6369999999999996}, "test_comparison_utils": {"TestComparisonUtils": 0.745}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.683}, "test_content_store": {"TestContentStoreCUDA": 3.158}, "test_cpp_api_parity": {"TestCppApiParity": 15.14800000000003}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.6839999999999999, "TestMAIATensor": 0.009000000000000001, "TestORTTensor": 0.008666666666666668, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.034}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.705, "TestMAIATensor": 0.009000000000000001, "TestORTTensor": 0.008666666666666668, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.035}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 291.48900000000003}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.395}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 25.168}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.37}, "test_cuda": {"TestBlockStateAbsorption": 0.0005, "TestCuda": 56.33849999999997, "TestCudaMallocAsync": 30.815499999999993, "TestCudaOptimsCUDA": 0.07300000000000001}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 40.0, "TestCudaMallocAsync": 7.0809999999999995, "TestCudaOptimsCUDA": 0.04699999999999999}, "test_cuda_multigpu": {"TestCudaComm": 0.03300000000000001, "TestCudaMultiGPU": 1.0889999999999997}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.105}, "test_cuda_sanitizer": {"TestArgumentHandler": 1.003, "TestEventHandler": 0.02000000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 6.102999999999999}, "test_custom_ops": {"MiniOpTest": 0.3920000000000001, "MiniOpTestOther": 0.04000000000000001, "TestCustomOp": 16.044999999999995, "TestCustomOpAPI": 0.08800000000000004, "TestCustomOpTestingCUDA": 1.1010000000000002, "TestGenerateOpcheckTests": 0.246}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.001, "TestConcatDataset": 0.007, "TestConvAfterFork": 0.062, "TestCustomPinFn": 0.10400000000000001, "TestDataLoader": 57.538000000000004, "TestDataLoaderDeviceTypeCUDA": 9.119, "TestDataLoaderPersistentWorkers": 89.45400000000001, "TestDatasetRandomSplit": 0.633, "TestDictDataLoader": 0.027, "TestIndividualWorkerQueue": 0.002, "TestNamedTupleDataLoader": 0.003, "TestSetAffinity": 0.035, "TestStackDataset": 0.024000000000000004, "TestStringDataLoader": 0.039, "TestTensorDataset": 0.014}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.006, "TestDataChunk": 0.439, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 2.7939999999999996, "TestFunctionalMapDataPipe": 0.024, "TestGraph": 0.010000000000000002, "TestIterDataPipeCountSampleYielded": 0.009000000000000001, "TestIterDataPipeGraphFastForward": 0.028999999999999998, "TestIterDataPipeSingletonConstraint": 0.014000000000000002, "TestIterableDataPipeBasic": 0.020000000000000004, "TestSerialization": 3.8120000000000003, "TestSharding": 0.192, "TestStreamWrapper": 0.385, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.024, "HasDecompTest": 5.623, "TestDecompCUDA": 5494.200999999992}, "test_deploy": {"TestFreezer": 0.697}, "test_dispatch": {"TestDispatch": 42.81, "TestPythonDispatcher": 0.079}, "test_dlpack": {"TestTorchDlPackCUDA": 0.8170000000000002}, "test_dynamic_shapes": {"TestDimConstraints": 1.381, "TestFloorDiv": 0.04200000000000001, "TestPySymInt": 1.1679999999999997, "TestSymNumberMagicMethods": 0.9400000000000006}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 7.854999999999992, "TestExpandedWeightHelperFunctionCUDA": 3.3219999999999996, "TestExpandedWeightModuleCUDA": 24.653999999999996}, "test_fake_tensor": {"FakeTensorConstHandling": 0.05500000000000001, "FakeTensorConverterTest": 0.016, "FakeTensorDispatchCache": 0.05700000000000002, "FakeTensorOpInfoTestCUDA": 0.10900000000000003, "FakeTensorOperatorInvariants": 0.20700000000000002, "FakeTensorPropTest": 0.051000000000000004, "FakeTensorSerialization": 0.003, "FakeTensorTest": 0.8140000000000003}, "test_flop_counter": {"TestFlopCounter": 4.245}, "test_foreach": {"TestForeachCUDA": 303.98599999999715}, "test_function_schema": {"TestFunctionSchema": 0.949}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 47.705}, "test_functional_optim": {"TestFunctionalOptimParity": 0.30900000000000005}, "test_functionalization": {"TestCrossRefFunctionalization": 2.7349999999999968, "TestFunctionalization": 4.4099999999999975}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 1.796}, "test_futures": {"TestFuture": 1.3699999999999999}, "test_fx": {"AnnotationsTest": 0.010000000000000002, "TestCSEPass": 0.401, "TestCommonPass": 0.13000000000000003, "TestConstFold": 0.16200000000000006, "TestConstParamShapeInControlFlow": 0.025, "TestDCE": 0.019999999999999997, "TestFX": 1.8829999999999933, "TestFXAPIBackwardCompatibility": 0.017, "TestFunctionalTracing": 0.21500000000000016, "TestMatcher": 0.17400000000000002, "TestOperatorSignaturesCUDA": 0.6830000000000005, "TestPassManager": 0.016, "TestSourceMatcher": 0.657, "TestSubgraphRewriter": 0.1920000000000001, "TestVisionTracing": 173.61699999999993, "TypeCheckerTest": 1.635999999999999}, "test_fx_experimental": {"TestFXExperimental": 115.44400000000002, "TestNormalizeOperatorsCUDA": 1.3000000000000007, "TestTranslationValidation": 0.08199999999999999}, "test_fx_passes": {"TestFXGraphPasses": 0.9850000000000001, "TestFXMatcherUtils": 0.05900000000000001}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.8890000000000001}, "test_import_stats": {"TestImportTime": 3.787}, "test_indexing": {"NumpyTestsCUDA": 0.09200000000000001, "TestIndexingCUDA": 2.623999999999993}, "test_itt": {"TestItt": 0.798}, "test_jit": {"TestAliasAnalysis": 0.21800000000000003, "TestAsync": 0.21500000000000002, "TestAtenPow": 0.015, "TestAutodiffJit": 0.11, "TestAutodiffSubgraphSlicing": 0.15000000000000005, "TestAwait": 0.10100000000000003, "TestBackends": 0.001, "TestBackendsWithCompiler": 0.083, "TestBatchMM": 0.046, "TestBuiltins": 0.034, "TestCUDA": 0.499, "TestClassType": 0.4950000000000002, "TestComplex": 0.489, "TestCustomOperators": 0.038000000000000006, "TestDCE": 0.011, "TestDataParallel": 0.0, "TestDataclasses": 2.32, "TestDeviceAnalysis": 2.496, "TestDict": 0.2420000000000001, "TestDtypeAnalysis": 0.19299999999999998, "TestEnum": 0.085, "TestFreezing": 0.7890000000000003, "TestFrontend": 0.032, "TestFrozenOptimizations": 43.94499999999999, "TestFunctionalBlocks": 0.004, "TestFunctionalToInplaceActivation": 2.7249999999999996, "TestGenerator": 0.037000000000000005, "TestGetDefaultAttr": 0.01, "TestGraphRewritePasses": 0.063, "TestHash": 0.044, "TestHooks": 0.3860000000000001, "TestIgnorableArgs": 0.006, "TestIgnoreContextManager": 0.025, "TestInplaceToFunctionalActivation": 3.0789999999999997, "TestIsinstance": 0.11900000000000004, "TestJit": 9.464000000000004, "TestJitGeneratedModule": 36.23599999999979, "TestJitProfiler": 0.001, "TestJitUtils": 0.011000000000000003, "TestList": 0.8190000000000003, "TestLogging": 0.028000000000000004, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.392, "TestMixTracingScripting": 0.8370000000000001, "TestModels": 20.619, "TestModuleAPIs": 0.095, "TestModuleContainers": 0.774, "TestModuleInterface": 0.21700000000000003, "TestModules": 0.008, "TestNamedTuple": 0.039, "TestNnapiBackend": 18.135, "TestOpDecompositions": 0.01, "TestOptimizeForMobilePreserveDebugInfo": 0.25, "TestParametrization": 0.32, "TestPeephole": 0.2500000000000001, "TestProducerVersion": 0.001, "TestProfiler": 0.14700000000000002, "TestPythonBindings": 0.018000000000000002, "TestPythonBuiltinOP": 0.20600000000000004, "TestPythonIr": 0.013000000000000001, "TestRecursiveScript": 0.3490000000000001, "TestRemoveMutation": 0.07100000000000001, "TestSaveLoad": 0.22300000000000003, "TestSaveLoadFlatbuffer": 0.14400000000000002, "TestSaveLoadForOpVersion": 2.0300000000000002, "TestScript": 17.90099999999999, "TestScriptDict": 0.013000000000000001, "TestScriptList": 0.021000000000000005, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.067, "TestScriptProfile": 9.039, "TestSlice": 0.08200000000000005, "TestSparse": 0.15400000000000003, "TestStringFormatting": 0.08700000000000004, "TestSymbolicShapeAnalysis": 3.780999999999999, "TestTensorBuiltins": 0.055999999999999994, "TestTensorCreationOps": 0.024, "TestTensorMethods": 0.007, "TestTorchbind": 0.07300000000000002, "TestTracer": 7.699999999999992, "TestTypeSharing": 0.272, "TestTypesAndAnnotation": 0.061, "TestTyping": 0.21500000000000008, "TestUnion": 0.2380000000000001, "TestUnsupportedOps": 0.022, "TestUpgraders": 0.03700000000000001, "TestWarn": 0.03, "TestWith": 0.16000000000000003}, "test_jit_autocast": {"TestAutocast": 3.6789999999999985, "TestJitTraceAutocast": 13.706000000000001}, "test_jit_disabled": {"TestJitDisabled": 0.887}, "test_jit_fuser_te": {"TestFuserCommon": 0.065, "TestNNCOpInfoCUDA": 12.38899999999909, "TestTEFuserDynamic": 308.75800000000015, "TestTEFuserStatic": 290.051}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.198, "TestFusionPatternCUDA": 0.0, "TestModel": 0.002, "TestOpCUDA": 0.0}, "test_jiterator": {"TestPythonJiteratorCUDA": 18.388999999999964}, "test_legacy_vmap": {"TestVmapAPILegacy": 52.17199999999997, "TestVmapBatchedGradientLegacyCUDA": 0.5010000000000001, "TestVmapOperatorsLegacy": 1.917999999999998}, "test_license": {"TestLicense": 0.772}, "test_linalg": {"TestLinalgCUDA": 1260.0279999999934}, "test_logging": {"LoggingTest": 3.149}, "test_masked": {"TestMaskedCUDA": 20.168999999999972}, "test_maskedtensor": {"TestBasicsCUDA": 0.20900000000000002, "TestBinary": 0.21800000000000017, "TestOperatorsCUDA": 4.184000000000008, "TestReductions": 0.052000000000000005, "TestUnary": 0.8770000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.006, "TestMatmulCudaCUDA": 22.881000000000018, "TestMixedDtypesLinearCudaCUDA": 0.0}, "test_meta": {"TestMetaCUDA": 1778.3819999999414, "TestMetaConverter": 2.126}, "test_mkl_verbose": {"TestMKLVerbose": 4.982}, "test_mkldnn_fusion": {"TestMkldnnFusion": 32.946999999999996}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.872}, "test_mobile_optimizer": {"TestOptimizer": 3.1679999999999997}, "test_model_dump": {"TestModelDump": 1.7129999999999999}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.186}, "test_modules": {"TestModuleCUDA": 910.958999999957}, "test_monitor": {"TestMonitor": 0.724, "TestMonitorTensorboard": 0.127}, "test_multiprocessing": {"TestMultiprocessing": 45.12499999999999}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.396, "SpawnTest": 18.549999999999997}, "test_namedtensor": {"TestNamedTensor": 2.5539999999999954}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.077}, "test_native_functions": {"TestNativeFunctions": 0.8210000000000001}, "test_native_mha": {"TestMHADeviceTypeCUDA": 3.7379999999999955}, "test_nestedtensor": {"TestNestedTensor": 0.6500000000000002, "TestNestedTensorAutogradCUDA": 0.8080000000000004, "TestNestedTensorDeviceTypeCUDA": 5.283999999999987, "TestNestedTensorSubclassCUDA": 0.9190000000000007}, "test_nn": {"TestAddRelu": 0.0035, "TestConstantPadNd": 0.0035, "TestFunctionalPickle": 0.00125, "TestFusionEval": 0.361, "TestFusionUtils": 0.004, "TestNN": 93.81875000000021, "TestNNDeviceTypeCUDA": 291.2372500000048, "TestUtils": 0.0035}, "test_numba_integration": {"TestNumbaIntegration": 0.8300000000000001}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.7450000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 3.767}, "test_ops": {"TestCommonCUDA": 4072.727000000068, "TestCompositeComplianceCUDA": 733.7359999999951, "TestFakeTensorCUDA": 761.8622499999952, "TestMathBitsCUDA": 99.81400000000033, "TestSelfKwarg": 0.7484999999999999, "TestTagsCUDA": 3.662750000000021}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 689.3620000000096}, "test_ops_gradients": {"TestBwdGradientsCUDA": 908.5220000000163}, "test_ops_jit": {"TestJitCUDA": 903.8799999999994}, "test_optim": {"TestDifferentiableOptimizer": 0.7130000000000001, "TestLRScheduler": 0.6550000000000004, "TestOptim": 187.844, "TestOptimRenewedCUDA": 492.67199999999974, "TestSWAUtils": 13.977}, "test_out_dtype_op": {"TestOutDtypeOp": 0.373}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.003, "TestGradCheckOverride": 0.014, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.002, "TestRNN": 0.063, "TestResolveName": 0.073, "TestTorchFunctionMode": 0.025000000000000015, "TestTorchFunctionOverride": 2.2969999999998754, "TestTorchFunctionWarning": 0.008, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.027999999999999997, "ModelTest": 0.0, "TestAnalyze": 0.001, "TestDependencyAPI": 0.032000000000000015, "TestDependencyHooks": 0.006, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.008, "TestLoadBCPackages": 0.032, "TestMangling": 0.011000000000000001, "TestMisc": 0.022, "TestPackageFX": 0.044, "TestPackageScript": 1.1259999999999997, "TestRepackage": 0.004, "TestResources": 0.314, "TestSaveLoad": 0.024000000000000004}, "test_per_overload_api": {"TestPerOverloadAPI": 0.731}, "test_prims": {"TestDecompCUDA": 0.014, "TestPrimsBasic": 0.585, "TestPrimsCUDA": 0.21500000000000002, "TestRefsCUDA": 0.006}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.069, "TestGenericProxyTensorFake": 4.459999999999999, "TestGenericProxyTensorReal": 19.005, "TestGenericProxyTensorSymbolic": 13.436, "TestRealProxyTensor": 0.01, "TestSymbolicTracing": 2.3279999999999994}, "test_pruning_op": {"PruningOpTest": 0.9610000000000001}, "test_public_bindings": {"TestPublicBindings": 0.749}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.099, "TestPythonDispatch": 0.11300000000000006, "TestPythonDispatcher": 0.004, "TestPythonRegistration": 0.125, "TestWrapperSubclassAliasingCUDA": 0.12100000000000002}, "test_pytree": {"TestCxxPytree": 0.012000000000000004, "TestGenericPytree": 0.9570000000000002, "TestPythonPytree": 0.03900000000000003}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000001, "TestAOMigrationNNQuantized": 0.024, "TestAOMigrationQuantization": 0.014, "TestAOMigrationQuantizationFx": 0.013999999999999999, "TestBackendConfig": 0.031000000000000003, "TestBiasCorrectionEager": 65.985, "TestBitsCUDA": 0.021000000000000005, "TestComparatorOps": 53.885999999999996, "TestDeprecatedJitQuantized": 1.952, "TestDistributed": 0.28300000000000003, "TestDuplicateDQPass": 2.411, "TestDynamicQuantizedModule": 182.901, "TestDynamicQuantizedOps": 550.11, "TestEqualizeEager": 6.823999999999999, "TestEqualizeFx": 10.953999999999999, "TestFXGraphMatcher": 0.873, "TestFXGraphMatcherModels": 9.208, "TestFXNumericSuiteCoreAPIs": 31.273, "TestFXNumericSuiteCoreAPIsModels": 53.742999999999995, "TestFXNumericSuiteNShadows": 122.88500000000002, "TestFakeQuantize": 0.34800000000000003, "TestFakeQuantizeOps": 21.753000000000004, "TestFloat8DtypeCUDA": 0.844, "TestFuseEager": 25.542, "TestFuseFx": 4.357, "TestFusedObsFakeQuant": 0.902, "TestFusedObsFakeQuantModule": 0.7060000000000001, "TestFusionPasses": 0.197, "TestFxDetectInputWeightEqualization": 0.8220000000000001, "TestFxDetectOutliers": 6.269, "TestFxModelReportClass": 11.265, "TestFxModelReportDetectDynamicStatic": 1.474, "TestFxModelReportDetector": 1.1469999999999998, "TestFxModelReportObserver": 2.403, "TestFxModelReportVisualizer": 1.557, "TestGenerateNumericDebugHandle": 0.726, "TestGraphUtils": 0.9750000000000001, "TestHistogramObserver": 34.777, "TestMetaDataPorting": 4.436999999999999, "TestModelNumericsEager": 8.83, "TestNumericSuiteEager": 56.403999999999996, "TestObserver": 4.274, "TestPT2ERepresentation": 17.426, "TestPadding": 71.137, "TestQNNPackOps": 32.559000000000005, "TestQuantizationDocs": 0.311, "TestQuantizeDynamicJitOps": 2.733, "TestQuantizeDynamicJitPasses": 4.656999999999999, "TestQuantizeEagerOps": 7.327999999999999, "TestQuantizeEagerPTQDynamic": 48.155, "TestQuantizeEagerPTQStatic": 55.289, "TestQuantizeEagerQAT": 70.001, "TestQuantizeEagerQATNumerics": 150.41299999999998, "TestQuantizeFx": 56.146, "TestQuantizeFxModels": 54.745999999999995, "TestQuantizeFxOps": 144.842, "TestQuantizeJit": 13.120999999999999, "TestQuantizeJitOps": 258.84, "TestQuantizeJitPasses": 22.875, "TestQuantizePT2E": 58.822, "TestQuantizePT2EQATModels": 298.318, "TestQuantizePT2EQAT_ConvBn1d": 499.198, "TestQuantizePT2EQAT_ConvBn2d": 501.83, "TestQuantizePT2EX86Inductor": 111.62, "TestQuantizedConv": 322.894, "TestQuantizedEmbeddingOps": 9.109, "TestQuantizedFunctionalOps": 16.091, "TestQuantizedLinear": 269.519, "TestQuantizedOps": 1402.535, "TestQuantizedTensor": 9.325999999999999, "TestRecordHistogramObserver": 0.019, "TestReferenceQuantizedModule": 1.151, "TestSerialization": 6.772, "TestStaticQuantizedModule": 372.93800000000005, "TestSubgraphRewriter": 0.462, "TestUtils": 0.014000000000000002, "TestXNNPACKQuantizer": 28.272, "TestXNNPACKQuantizerModels": 53.714}, "test_reductions": {"TestReductionsCUDA": 94.93099999999588}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 10.530999999999999}, "test_schema_check": {"TestSchemaCheck": 0.7590000000000002, "TestSchemaCheckModeOpInfoCUDA": 398.94999999999396}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 1.9499999999999986}, "test_serialization": {"TestBothSerializationCUDA": 0.09, "TestOldSerialization": 15.111, "TestSerialization": 7.4229999999999965, "TestSubclassSerialization": 0.009000000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.731}, "test_shape_ops": {"TestShapeOpsCUDA": 18.247000000000007}, "test_show_pickle": {"TestShowPickle": 0.732}, "test_sort_and_select": {"TestSortAndSelectCUDA": 4.097999999999998}, "test_sparse": {"TestSparseAnyCUDA": 349.35099999999704, "TestSparseCUDA": 20.135000000000044, "TestSparseLegacyAndDeprecation": 1.067, "TestSparseMaskedReductionsCUDA": 1.2979999999999998, "TestSparseMeta": 9.240999999999996, "TestSparseOneOff": 0.041, "TestSparseUnaryUfuncsCUDA": 4.479999999999967}, "test_sparse_csr": {"TestSparseCSRCUDA": 155.70499999999532, "TestSparseCSRSampler": 0.544, "TestSparseCompressedCUDA": 102.63300000000001, "TestSparseCompressedTritonKernelsCUDA": 247.53900000000024}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.001, "TestCUSPARSELTCUDA": 0.002, "TestSparseSemiStructuredCUDA": 0.003, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.001, "TestSparseSemiStructuredCUTLASSCUDA": 0.003, "TestSparseSemiStructuredTrainingCUDA": 0.001}, "test_spectral_ops": {"TestFFTCUDA": 155.49800000000005}, "test_stateless": {"TestPythonOptimizeMode": 2.594, "TestStatelessDeprecation": 1.511, "TestStatelessFunctionalAPI": 0.8500000000000001}, "test_subclass": {"TestSubclass": 0.8540000000000001}, "test_sympy_utils": {"TestSingletonInt": 0.004, "TestSympyInterp": 0.4810000000000002, "TestSympySolve": 0.12000000000000002, "TestValueRanges": 11.597999999999997}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.3880000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.43900000000000006, "TestTensorCreationCUDA": 77.58700000000043}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.009000000000000001, "TestTensorBoardFigure": 0.001, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.364, "TestTensorBoardPytorchGraph": 138.47899999999998, "TestTensorBoardSummary": 0.020000000000000007, "TestTensorBoardSummaryWriter": 0.006, "TestTensorBoardUtils": 0.082, "TestTensorBoardWriter": 0.046, "TestTensorProtoSummary": 0.008}, "test_tensorexpr": {"TestTensorExprFuser": 59.338}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.006, "TestTensorExprPyBind": 0.9790000000000001}, "test_testing": {"TestAssertClose": 0.36100000000000004, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.035, "TestAssertCloseMultiDeviceCUDA": 0.005, "TestAssertCloseQuantized": 0.24100000000000002, "TestAssertCloseSparseBSC": 0.011, "TestAssertCloseSparseBSR": 0.011, "TestAssertCloseSparseCOO": 0.21199999999999997, "TestAssertCloseSparseCSC": 0.011, "TestAssertCloseSparseCSR": 0.011, "TestFrameworkUtils": 10.338, "TestImports": 8.219, "TestMakeTensorCUDA": 0.9300000000000007, "TestOpInfoSampleFunctionsCUDA": 2.6789999999999323, "TestOpInfos": 0.003, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCUDA": 2.5409999999999986, "TestTestingCUDA": 0.9340000000000002}, "test_torch": {"TestBasicVitalSigns": 0.264, "TestDevicePrecisionCUDA": 0.08800000000000002, "TestTorch": 6.68649999999999, "TestTorchDeviceTypeCUDA": 165.45700000000045, "TestVitalSignsCudaCUDA": 0.0025}, "test_transformers": {"TestAttnBiasCUDA": 0.022000000000000013, "TestSDPACUDA": 1.3309999999999678, "TestSDPACudaOnlyCUDA": 233.39600000001514, "TestSDPAFailureModesCUDA": 0.10400000000000006, "TestTransformersCUDA": 6.422999999999999}, "test_type_hints": {"TestTypeHints": 0.556}, "test_type_info": {"TestDTypeInfo": 0.741}, "test_type_promotion": {"TestTypePromotionCUDA": 11.616000000000025}, "test_typing": {"TestTyping": 46.357999999999976}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 366.34124999987336}, "test_utils": {"TestAssert": 0.045, "TestBottleneck": 11.78, "TestCheckpoint": 0.5900000000000002, "TestCollectEnv": 0.934, "TestCppExtensionUtils": 0.16199999999999998, "TestDataLoaderUtils": 0.16, "TestDeviceUtilsCUDA": 11.726000000000461, "TestExtensionUtils": 0.009000000000000001, "TestHipify": 0.002, "TestHipifyTrie": 0.009000000000000001, "TestONNXUtils": 0.007, "TestRenderUtils": 0.018, "TestStandaloneCPPJIT": 12.252, "TestTraceback": 0.008}, "test_view_ops": {"TestOldViewOpsCUDA": 10.412999999999998, "TestViewOpsCUDA": 3.983999999999993}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.013000000000000003, "WeakKeyDictionaryTestCase": 0.018000000000000002, "WeakTest": 3.736999999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.001, "TestXNNPACKOps": 13.607999999999999, "TestXNNPACKRewritePass": 4.478999999999999, "TestXNNPACKSerDes": 13.365}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.001}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.391, "TestClassGetItem": 0.002, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.003, "TestPickling": 0.07800000000000001, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 11.122000000000002, "TestEinsumPath": 0.0, "TestMisc": 0.004}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.434, "TestHalf": 0.0, "TestIinfo": 0.447, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.025, "TestBroadcastedAssignments": 0.069, "TestFancyIndexingCast": 0.002, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.7170000000000001, "TestMultiIndexingAutomated": 0.005, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.021000000000000005, "TestArgmax": 0.6820000000000005, "TestArgmaxArgminCommon": 0.034, "TestArgmin": 0.7160000000000005, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.025000000000000005, "TestArrayCreationCopyArgument": 0.001, "TestAssignment": 0.012, "TestAttributes": 0.019000000000000003, "TestBinop": 0.012, "TestBool": 15.36, "TestCequenceMethods": 0.001, "TestChoose": 0.013000000000000001, "TestClip": 0.004, "TestCompress": 0.003, "TestConversion": 0.023, "TestCreation": 0.0, "TestDelMisc": 0.001, "TestDot": 0.04100000000000002, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.018000000000000002, "TestFlag": 0.007, "TestFormat": 0.004, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.401, "TestHashing": 0.002, "TestIO": 0.0, "TestInner": 0.137, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.6080000000000001, "TestMatmulOperator": 0.5090000000000001, "TestMethods": 0.9900000000000004, "TestMinMax": 0.003, "TestMinScalarType": 0.004, "TestNewaxis": 0.003, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.036000000000000004, "TestResize": 0.03, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.02, "TestSortFloatMisc": 0.09600000000000002, "TestStats": 0.183, "TestSubscripting": 0.001, "TestTake": 0.030000000000000002, "TestVdot": 0.023, "TestWarnings": 0.001, "TestWhere": 2.081, "TestWritebackIfCopy": 0.015000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.013000000000000001, "TestArgwhere": 0.018000000000000002, "TestArrayComparisons": 0.014000000000000002, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006, "TestBoolArray": 1.664, "TestBoolCmp": 0.11299999999999999, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.1350000000000001, "TestConvolve": 0.051000000000000004, "TestCorrelate": 0.103, "TestCreationFuncs": 0.7010000000000001, "TestCross": 0.033, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.007, "TestFromiter": 0.0, "TestIndex": 0.004, "TestIndices": 0.026000000000000002, "TestIsclose": 0.054, "TestIsscalar": 0.002, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.011000000000000003, "TestNonarrayArgs": 0.07200000000000004, "TestNonzeroAndCountNonzero": 0.162, "TestOuterMisc": 0.004, "TestRequire": 0.004, "TestResize": 0.402, "TestRoll": 0.020000000000000004, "TestRollaxis": 0.003, "TestSeterr": 0.004, "TestStdVar": 0.019, "TestStdVarComplex": 0.008, "TestStringFunction": 0.001, "TestTensordot": 0.011000000000000001, "TestTypes": 0.008}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.783, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.060000000000000046, "TestFromInt": 0.006, "TestFromString": 0.784}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.731, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.069, "TestBaseMath": 5.838, "TestBitShifts": 0.058, "TestComplexDivision": 0.039, "TestConversion": 0.034, "TestHash": 0.0, "TestModulus": 0.628, "TestMultiply": 0.0, "TestNegative": 0.017, "TestPower": 0.083, "TestRepr": 0.001, "TestScalarOpsMisc": 0.076, "TestScalarSubclassingMisc": 0.002, "TestSubtract": 0.017, "TestTypes": 9.648}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.835, "TestAtleast2d": 0.009000000000000001, "TestAtleast3d": 0.008, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.14400000000000004, "TestHstack": 0.010000000000000002, "TestStackMisc": 0.0, "TestVstack": 0.011000000000000003}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007, "TestFFTShift": 4.577, "TestIRFFTN": 0.006, "TestRFFTFreq": 0.007}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 6.350999999999994, "TestFFTShift": 0.729, "TestFFTThreadSafe": 47.760000000000005}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.8140000000000001}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.002, "TestUnique": 0.47000000000000003}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.004, "TestAmax": 0.004, "TestAmin": 0.004, "TestAngle": 0.006, "TestAny": 0.005, "TestAverage": 0.018000000000000002, "TestBincount": 0.04400000000000001, "TestCheckFinite": 0.002, "TestCopy": 0.005, "TestCorrCoef": 0.022, "TestCov": 0.05200000000000001, "TestCumprod": 0.021, "TestCumsum": 0.027, "TestDelete": 0.016, "TestDiff": 0.395, "TestDigitize": 0.012000000000000004, "TestExtins": 0.004, "TestFilterwindows": 0.5380000000000004, "TestFlip": 0.019000000000000003, "TestGradient": 0.09200000000000001, "TestInsert": 0.009000000000000001, "TestInterp": 0.12700000000000003, "TestKaiser": 0.007, "TestMedian": 0.071, "TestMeshgrid": 0.036000000000000004, "TestMsort": 0.0, "TestPercentile": 0.07400000000000001, "TestPiecewise": 0.008, "TestProd": 0.02, "TestPtp": 0.006, "TestQuantile": 0.01, "TestRot90": 0.524, "TestSelect": 0.006, "TestSinc": 0.006, "TestSortComplex": 0.007, "TestTrapz": 0.004, "TestTrimZeros": 0.009000000000000001, "TestUnique": 0.006, "Test_I0": 0.014}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 1.0809999999999993, "TestHistogramOptimBinNums": 0.032000000000000015, "TestHistogramdd": 3.334}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.007, "TestDiagIndices": 0.003, "TestDiagIndicesFrom": 0.005, "TestFillDiagonal": 0.017, "TestGrid": 0.007, "TestIndexExpression": 0.007, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.809}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.009000000000000001, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.10700000000000001, "TestColumnStack": 0.007, "TestDsplit": 0.007, "TestDstack": 0.010000000000000002, "TestExpandDims": 0.005, "TestHsplit": 0.008, "TestKron": 0.008, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.011, "TestSplit": 0.004, "TestSqueeze": 0.054000000000000006, "TestTakeAlongAxis": 0.838, "TestTile": 0.056999999999999995, "TestVsplit": 0.006}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.022000000000000002, "TestEye": 0.8160000000000001, "TestFliplr": 0.005, "TestFlipud": 0.004, "TestHistogram2d": 0.05600000000000001, "TestTri": 0.549, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.002, "TestTriuIndicesFrom": 0.001, "TestVander": 0.012}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.794, "TestImag": 0.008, "TestIscomplex": 0.003, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.002, "TestIsreal": 0.005, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.009000000000000001, "TestReal": 0.009000000000000001, "TestRealIfClose": 0.003}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.4620000000000001, "TestCond": 0.14400000000000002, "TestDet": 0.09600000000000002, "TestEig": 0.021000000000000005, "TestEigh": 0.029000000000000005, "TestEighCases": 0.0, "TestEigvals": 0.035, "TestEigvalsh": 0.027000000000000003, "TestEigvalshCases": 0.0, "TestInv": 0.035, "TestLstsq": 0.14200000000000002, "TestMatrixRank": 0.233, "TestMisc": 0.023, "TestMisc2": 0.018, "TestMultiDot": 0.07600000000000003, "TestNormDouble": 0.6400000000000001, "TestNormInt64": 0.642, "TestNormSingle": 0.646, "TestNorm_NonSystematic": 0.003, "TestPinv": 0.069, "TestPinvHermitian": 0.023, "TestQR": 0.77, "TestSVD": 0.028000000000000004, "TestSVDHermitian": 0.061000000000000006, "TestSolve": 0.406, "TestTensorinv": 0.020999999999999998, "TestTensorsolve": 0.006}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.008, "TestCtorNested": 0.002, "TestDefaultDtype": 0.005, "TestDivmod": 0.010000000000000002, "TestExport": 0.0, "TestMisc": 2.9459999999999997, "TestNormalizations": 0.004, "TestOneArr": 0.8310000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1340000000000001, "TestOneArrAndShape": 0.0, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.034, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.912}, "torch_np/test_dtype": {"TestConvertDType": 0.865}, "torch_np/test_function_base": {"TestAppend": 0.792}, "torch_np/test_ndarray_methods": {"TestAmax": 0.005, "TestAmin": 0.005, "TestArgmax": 0.6290000000000003, "TestArgmaxArgminCommon": 0.025, "TestArgmin": 0.6810000000000004, "TestContains": 0.001, "TestIndexing": 0.375, "TestIter": 0.003, "TestNoExtraMethods": 0.006, "TestNonzero": 0.095, "TestRavel": 0.004, "TestReshape": 0.003, "TestTranspose": 0.019000000000000003}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.013000000000000001, "TestNEP50Table": 0.001}, "torch_np/test_random": {"TestChoice": 0.008, "TestNumpyGlobal": 0.003, "TestScalarReturn": 0.278, "TestShuffle": 0.010000000000000002}, "torch_np/test_reductions": {"TestAll": 0.007, "TestAny": 0.009000000000000001, "TestFlatnonzero": 0.833, "TestGenericCumSumProd": 0.02, "TestGenericReductions": 1.3549999999999827, "TestMean": 0.053000000000000005, "TestSum": 0.14}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.378, "TestIsScalar": 0.02700000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.35300000000000026, "TestNdarrayDunderVsUfunc": 0.18600000000000008, "TestUfuncDtypeKwd": 0.004, "TestUnaryUfuncs": 0.8210000000000001}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.8940000000000001}}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": {"TestFullyShardAutograd": 33.28}, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormMultiThread": 9.81, "TestClipGradNormWorldSize2": 8.717, "TestClipGradNormWorldSize4": 3.625}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 11.351, "TestFullyShardCollectiveOps": 89.771, "TestFullyShardCommunication": 7.457, "TestFullyShardUnshard": 7.74, "TestFullyShardUnshardMultiProcess": 7.645, "TestFullyShardUnshardMultiThread": 0.043}, "distributed/_composable/fsdp/test_fully_shard_compile": {"TestFullyShardCompileCompute": 9.016}, "distributed/_composable/fsdp/test_fully_shard_extensions": {"TestFullyShardAllGatherExtensionsMultiProcess": 14.95, "TestFullyShardAllGatherExtensionsMultiThread": 4.402}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 35.79}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.259, "TestFullyShardDeviceTensor": 0.343, "TestFullyShardLazyInit": 0.128, "TestFullyShardManagedModulesAndStates": 0.056, "TestFullyShardMeshArg": 0.029, "TestFullyShardMetaDeviceInit": 4.108, "TestFullyShardParamModuleInfos": 0.024, "TestFullyShardShardedParameterDTensor": 0.146, "TestFullyShardShardedParameterTensor": 0.071}, "distributed/_composable/fsdp/test_fully_shard_memory": {"TestFullyShardMemory": 8.595}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionCasts": 19.801000000000002, "TestFullyShardMixedPrecisionTraining": 22.563000000000002}, "distributed/_composable/fsdp/test_fully_shard_overlap": {"TestFullyShardOverlap": 0.277}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.273}, "distributed/_composable/fsdp/test_fully_shard_state_dict": {"TestFullyShardStateDict": 11.835999999999999, "TestFullyShardStateDictMultiProcess": 13.89, "TestFullyShardStateDictMultiThread": 0.481}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 0.003, "TestFullyShard1DTrainingCore": 154.72699999999998, "TestFullyShard2DTraining": 33.344, "TestFullyShardCastAfterInit": 0.457, "TestFullyShardForwardInputs": 0.267, "TestFullyShardGradientAccumulation": 20.63, "TestFullyShardHSDPTraining": 17.876, "TestFullyShardRegisteredParams": 4.118, "TestFullyShardSharedParams": 18.235, "test_fully_shard_training": 0.0}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 50.7}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 25.141999999999996}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 6.405}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 16.773}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 13.322}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 16.353}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 3.708}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 4.0760000000000005}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 57.265}, "distributed/_composable/test_contract": {"TestContract": 0.202}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 6.354, "ReplicateTest": 29.169}, "distributed/_composable/test_replicate_with_compiler": {"DDP_TP_Test": 4.431, "ReplicateTest": 103.75}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 14.347999999999999}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.992}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 14.753, "TestShardingSpec": 0.072}, "distributed/_shard/test_sharder": {"TestCustomSharder": 9.978}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 3.0999999999999996}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.385}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 13.353}, "distributed/_tensor/test_api": {"DTensorAPITest": 23.092000000000002}, "distributed/_tensor/test_attention": {"RingAttentionTest": 4.654000000000001}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 29.073000000000004}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 37.093}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 23.758, "DTensorTest": 70.946, "TestDTensorPlacementTypes": 2.858}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 10.247, "TestDTensorCompileE2E": 11.693999999999999}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 17.479}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 16.677}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 17.019, "DTensorInitOpsTest": 3.829}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 32.797000000000004}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 57.787000000000006}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.072, "TestEinsumDims": 0.215, "TestEinsumStrategies": 0.08900000000000001}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 74.455}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.5840000000000001}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 5.716, "DistTensorRandomOpTest": 30.681}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 2.958, "RedistributeTest": 25.929}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 217.74800000000008}, "distributed/_tensor/test_utils": {"Test2DStridedLocalShard": 5.6739999999999995, "UtilTest": 6.215999999999999}, "distributed/_tensor/test_view_ops": {"TestViewOps": 8.928}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 1.2510000000000001}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 6.868}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 35.549}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 38.698}, "distributed/algorithms/test_join": {"TestJoin": 32.087}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ESaveAndLoad": 28.415, "TestNoCPU": 3.624}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 4.612}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 2.903}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 5.591}, "distributed/checkpoint/fsdp/test_fsdp_dsd": {"TestFullyShardWithDistributedStateDict": 13.739999999999998}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 10.82, "TestDistributedFailure": 27.995999999999995}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.39}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.184}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 5.995}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 16.679000000000002, "TestDTensorReshardPlacementChange": 6.936}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 25.432000000000002, "TestDistributedStateDictSaveLoad": 0.574, "TestDistributedStateDictSaveLoadWithSharedTensor": 5.638}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 23.785, "TestDistributedStateDictSaveLoad": 0.397, "TestDistributedStateDictSaveLoadWithSharedTensor": 5.946}, "distributed/checkpoint/test_format_utils": {"TestFormatUtils": 15.555}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 9.638}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 14.256}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 7.503}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.556, "TestFSSpecWithDist": 7.341}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 11.475}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.19}, "distributed/checkpoint/test_planner": {"TestPlannerHelpers": 0.001, "TestSavePlan": 0.20600000000000002}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 4.593}, "distributed/checkpoint/test_state_dict": {"TestStateDict": 89.94399999999999}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 24.016000000000002}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 11.248000000000001}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.2}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.197}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.992, "RdzvEventLibTest": 0.009000000000000001}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.999}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 1.362, "StartProcessesListTest": 18.791000000000004, "StartProcessesTest": 14.221, "StdTest": 0.006}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 8.648}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.14200000000000002, "LocalTimerTest": 4.101, "MultiprocessingRequestQueueTest": 1.4580000000000002}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 3.4729999999999994}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.945}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.99, "UtilTest": 0.006}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 1.2789999999999997}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.188}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 11.754999999999999}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 7.315}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 112.006, "TestFSDPCheckpointSubmodule": 6.534}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 43.638999999999996}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 53.517}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 172.42700000000002}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 8.137, "TestHooks": 48.028, "TestNoGrad": 13.960999999999999, "TestParamInit": 13.461, "TestParityWithDDP": 1414.417}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 95.901}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 52.629000000000005}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 42.527}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 61.705000000000005}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 222.56499999999997}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.29}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 42.254000000000005}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 42.872}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 86.29899999999999}, "distributed/fsdp/test_fsdp_input": {"TestInput": 12.93}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 18.725}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 47.01699999999999}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 87.80199999999999, "TestFSDPMiscMultiThread": 0.9960000000000002, "TestFSDPMiscWorldSize1": 0.664}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 37.489999999999995, "TestFSDPMixedPrecisionIgnoredModules": 5.624, "TestFSDPMixedPrecisionSharded": 357.77200000000005, "TestFSDPMixedPrecisionUnsharded": 17.271, "TestFSDPTrainEval": 8.235}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 6.894}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 6.614}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 440.874}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 20.524, "TestForwardOverlapWorldSizeTwo": 30.364}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 13.249}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.5479999999999999, "TestShardedGradScalerParityWithDDP": 136.849}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 980.7859999999997, "TestFSDPStateDict4GPUs": 5.539}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 10.856}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 5.687}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 6.717}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 55.649, "TestUnshardParamsErrors": 22.635, "TestUnshardParamsNoShard": 10.747}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 6.533, "TestFSDPUseOrigParamsInit": 5.832, "TestFSDPUseOrigParamsMultipleParamGroups": 73.18100000000001, "TestFSDPUseOrigParamsNoSync": 12.966000000000001, "TestFSDPUseOrigParamsParamAccess": 7.134, "TestFSDPUseOrigParamsUnshardReshard": 36.25099999999999, "TestFSDPUseOrigParamsWriteback": 32.871, "TestMultiTensorApply": 0.044}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 35.937}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 3.913, "TestShardUtilsDistributedDTensor": 3.624}, "distributed/fsdp/test_utils": {"TestUtils": 1.2009999999999998}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 4.93, "TestFSDPWrap": 145.704, "TestWrapUtils": 0.016}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 1.3989999999999998}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 175.98099999999997, "TestZeroRedundancyOptimizerSingleRank": 40.754000000000005}, "distributed/pipeline/sync/skip/test_api": {"test_api": 0.006}, "distributed/pipeline/sync/skip/test_gpipe": {"test_gpipe": 4.49}, "distributed/pipeline/sync/skip/test_inspect_skip_layout": {"test_inspect_skip_layout": 0.007}, "distributed/pipeline/sync/skip/test_leak": {"test_leak": 0.31700000000000006}, "distributed/pipeline/sync/skip/test_portal": {"TestTensorLife": 0.006, "test_portal": 0.291}, "distributed/pipeline/sync/skip/test_stash_pop": {"test_stash_pop": 0.009000000000000001}, "distributed/pipeline/sync/skip/test_tracker": {"test_tracker": 0.36}, "distributed/pipeline/sync/skip/test_verify_skippables": {"test_verify_skippables": 0.011000000000000003}, "distributed/pipeline/sync/test_balance": {"test_balance": 7.9159999999999995}, "distributed/pipeline/sync/test_bugs": {"test_bugs": 2.13}, "distributed/pipeline/sync/test_checkpoint": {"test_checkpoint": 0.568}, "distributed/pipeline/sync/test_copy": {"test_copy": 1.011}, "distributed/pipeline/sync/test_deferred_batch_norm": {"test_deferred_batch_norm": 1.9380000000000002}, "distributed/pipeline/sync/test_dependency": {"test_dependency": 0.31}, "distributed/pipeline/sync/test_inplace": {"test_inplace": 0.133}, "distributed/pipeline/sync/test_microbatch": {"test_microbatch": 0.011000000000000003}, "distributed/pipeline/sync/test_phony": {"test_phony": 0.007}, "distributed/pipeline/sync/test_pipe": {"test_pipe": 3.925999999999999}, "distributed/pipeline/sync/test_pipeline": {"test_pipeline": 0.002}, "distributed/pipeline/sync/test_stream": {"TestCurrentStream": 0.002, "TestDefaultStream": 0.002, "TestGetDevice": 0.002, "TestNewStream": 0.004, "TestRecordStream": 0.542, "TestUseDevice": 0.002, "TestUseStream": 0.002, "TestWaitStream": 0.7250000000000001}, "distributed/pipeline/sync/test_transparency": {"test_transparency": 0.241}, "distributed/pipeline/sync/test_worker": {"test_worker": 0.032}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 4.586}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 19.259, "TestNew2dParallelTraining": 14.003}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 28.336999999999996}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 44.484}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 2.91}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 47.033}, "distributed/test_c10d_common": {"CommTest": 4.713, "ComputeBucketAssignmentTest": 1.212, "LocalRankTest": 9.778, "ProcessGroupWithDispatchedCollectivesTests": 9.236, "PythonProcessGroupExtensionTest": 38.163000000000004, "ReduceOpTest": 1.18, "TimeoutTest": 31.344}, "distributed/test_c10d_functional_native": {"C10DFunctionalNativeCompileTest": 143.446, "C10DFunctionalNativeTest": 57.74100000000001, "CompileTest": 148.48499999999999, "TestWithNCCL": 68.643}, "distributed/test_c10d_gloo": {"CommTest": 43.543000000000006, "CompilerTest": 47.647000000000006, "DistributedDataParallelTest": 206.714, "GlooProcessGroupWithDispatchedCollectivesTests": 28.66, "LargeCommTest": 13.133, "ProcessGroupGlooTest": 211.77800000000002, "ReducerTest": 0.36, "RendezvousEnvTest": 0.325, "TimeoutTest": 3.262}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 15.069}, "distributed/test_c10d_nccl": {"CommTest": 82.34, "CompilerTest": 57.67099999999999, "DistributedDataParallelTest": 410.7589999999999, "LargeCommTest": 50.391, "NCCLTraceTest": 92.37, "NCCLTraceTestDumpOnTimeout": 11.169, "NCCLTraceTestTimeoutDumpOnStuckRanks": 8.597, "NcclErrorDumpTest": 0.008, "NcclErrorHandlingTest": 25.298, "NcclProcessGroupWithDispatchedCollectivesTests": 22.578, "ProcessGroupNCCLNoGPUTest": 0.001, "ProcessGroupNCCLTest": 189.31899999999996, "RendezvousEnvTest": 0.035, "SparseCollective": 6.534, "TimeoutTest": 3.051, "WorkHookTest": 24.991}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 45.999}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 116.08399999999999, "TestDDPWithWorkWrapper": 115.60300000000002}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 4.134, "ProcessGroupShareTensorTest": 22.031, "TestDistributedNNFunctionsGloo": 41.156}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 17.195999999999998, "TestDistributedNNFunctionsNccl": 34.685}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.003, "TestDistributedNNFunctionsUcc": 0.006}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 2.9079999999999995}, "distributed/test_data_parallel": {"TestDataParallel": 9.220000000000002, "TestDataParallelDeviceTypeCUDA": 0.14700000000000005}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 8.983, "DeviceMeshTest": 21.252, "DeviceMeshTestNDim": 9.079, "InitDeviceMeshTest": 8.870000000000001, "TestDeviceMeshGetItem": 14.881999999999998, "TestMeshEnv": 14.301}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 3786.2259999999987}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 14.690999999999999, "TestMultiProc": 73.66999999999999, "TestSingleProc": 26.334}, "distributed/test_fake_pg": {"TestFakePG": 3.3599999999999994}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 23.556, "TestExpand": 0.24500000000000002, "TestFunctionalAutograd": 1.4290000000000003, "TestFunctionalAutogradWithNCCL": 3.728, "TestGradCollectives": 0.006, "TestMakeFx": 0.027, "TestMetaCollectives": 0.003, "TestNCCLCollectivesWithWorldSize4": 20.177000000000003, "TestOpWaitiness": 19.80966666666667, "TestPgTag": 0.06, "TestTraceableCollectives": 0.169}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 3.9379999999999997, "TestCollectivesMultiProc": 133.11200000000002}, "distributed/test_launcher": {"TestDistributedLaunch": 2.028}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.6440000000000001, "TestCollectivesWithWrapper": 0.4170000000000001}, "distributed/test_nccl": {"TestNCCLCUDA": 1.1939999999999995}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 48.00399999999999, "ProcessGroupNCCLWrapperTest": 48.692}, "distributed/test_store": {"FileStoreTest": 2.998, "HashStoreTest": 1.647, "InitPgWithUvStore": 1.47, "LibUvTCPStoreTest": 12.987000000000002, "PrefixFileStoreTest": 2.33, "PrefixStoreTest": 0.003, "PrefixTCPStoreTest": 1.762, "PythonStoreTest": 0.224, "RendezvousEnvTest": 0.214, "RendezvousFileTest": 0.429, "RendezvousTCPTest": 21.83, "RendezvousTest": 0.428, "TCPStoreTest": 8.488999999999999, "TestMultiThreadedWait": 1.5370000000000001, "TestPythonStore": 1.5450000000000002, "TimeoutTest": 5.223}}, "slow": {"backends/xeon/test_launch": {"TestTorchrun": 2.2840000000000003}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 305.3249999999999}, "distributions/test_constraints": {"test_constraints": 3.2700000000000005}, "distributions/test_distributions": {"TestAgainstScipy": 0.004, "TestConstraints": 0.002, "TestDistributionShapes": 0.04300000000000003, "TestDistributions": 0.5790000000000001, "TestFunctors": 0.004, "TestJit": 0.008, "TestKL": 0.013000000000000005, "TestLazyLogitsInitialization": 0.002, "TestNumericalStability": 0.010000000000000002, "TestRsample": 0.007, "TestValidation": 0.004}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.17400000000000002}, "dynamo/test_after_aot": {"TestAfterAot": 0.197}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 0.23200000000000004}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 0.17800000000000002}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0, "NormalizeIRTests": 0.001, "TestCustomBackendAPI": 0.003, "TestExplainWithBackend": 0.001, "TestOptimizations": 0.156}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 0.227}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 0.189}, "dynamo/test_compile": {"InPlaceCompilationTests": 0.199, "PublicTorchCompilerTests": 0.001}, "dynamo/test_comptime": {"ComptimeTests": 0.199}, "dynamo/test_config": {"ConfigTests": 0.217}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.003, "CppGuardManagerFuncTorchHigherOrderOpTests": 0.07400000000000005, "CppGuardManagerFunctionTests": 0.2800000000000002, "CppGuardManagerHigherOrderOpTests": 0.09700000000000007, "CppGuardManagerMiscTests": 0.45700000000000035, "CppGuardManagerReproTests": 0.21000000000000016}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.04900000000000003}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 0.219}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.155}, "dynamo/test_decorators": {"DecoratorTests": 0.23500000000000001}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.001, "TestDeviceGuard": 0.009999999999999998}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 0.03200000000000002, "DynamicShapesCtxManagerTests": 0.03900000000000003, "DynamicShapesExportTests": 40.72699999999997, "DynamicShapesFuncTorchHigherOrderOpTests": 0.07400000000000005, "DynamicShapesFunctionTests": 0.2800000000000002, "DynamicShapesHigherOrderOpTests": 0.09700000000000007, "DynamicShapesMiscTests": 0.45600000000000035, "DynamicShapesNNModuleTests": 0.07400000000000005, "DynamicShapesReproTests": 0.21000000000000016, "DynamicShapesSubGraphTests": 0.04400000000000003, "DynamicShapesTestSDPA": 0.004}, "dynamo/test_exc": {"ExcTests": 0.01}, "dynamo/test_export": {"ExportTests": 0.18600000000000014}, "dynamo/test_export_mutations": {"MutationExportTests": 0.203}, "dynamo/test_frame_init": {"FrameInitTests": 0.208}, "dynamo/test_functions": {"DefaultsTests": 0.01900000000000001, "FunctionTests": 0.40600000000000025}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.188}, "dynamo/test_global": {"TestGlobals": 0.201}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.234}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.010000000000000002, "FuncTorchHigherOrderOpTests": 0.07400000000000005, "HigherOrderOpTests": 0.24700000000000008, "HigherOrderOpVmapGuardTests": 0.013000000000000001}, "dynamo/test_hooks": {"HooksTests": 0.22400000000000003}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 0.202}, "dynamo/test_interop": {"InteropTests": 0.199}, "dynamo/test_logging": {"LoggingTests": 0.17900000000000005}, "dynamo/test_minifier": {"MinifierTests": 0.227}, "dynamo/test_misc": {"MiscTests": 0.5630000000000004, "TestTracer": 0.001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0}, "dynamo/test_modules": {"NNModuleTests": 0.19600000000000006, "OptimizedModuleTest": 0.02900000000000002}, "dynamo/test_nops": {"NopTests": 0.198}, "dynamo/test_optimizers": {"End2EndTests": 0.197}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.193}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.223}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.198}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.203}, "dynamo/test_recompiles": {"RecompileTests": 0.201}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.22}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.20099999999999998}, "dynamo/test_repros": {"ReproTests": 0.22100000000000017}, "dynamo/test_sdpa": {"TestSDPA": 0.197}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.202}, "dynamo/test_sources": {"SourceTests": 0.195}, "dynamo/test_structured_trace": {"StructuredTraceTest": 0.137}, "dynamo/test_subclasses": {"SubclassTests": 0.18600000000000003, "TestNestedTensor": 0.024000000000000014}, "dynamo/test_subgraphs": {"SubGraphTests": 0.23400000000000004}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.001, "TraceRuleTests": 0.199}, "dynamo/test_triton_kernels": {"KernelTests": 0.3440000000000001, "MutationTests": 0.024000000000000014, "NoOptimizationKernelTests": 0.3420000000000001, "no_opt_test_class": 0.12600000000000008}, "dynamo/test_unspec": {"UnspecTests": 0.23400000000000004}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.195}, "export/test_db": {"ExampleTests": 0.22500000000000003}, "export/test_experimental": {"TestExperiment": 0.194}, "export/test_export": {"TestDynamismExpression": 0.003, "TestExport": 0.12800000000000009, "TestExportCustomClass": 0.11299999999999999, "TestOneOffModelExportResult": 0.012000000000000004}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.003, "NonStrictExportTestExport": 0.1310000000000001}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.003, "PreDispatchExportTestExport": 0.1300000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.642}, "export/test_hop": {"TestHOPCUDA": 0.014000000000000005, "TestHOPGeneric": 0.001}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.001, "TestLift": 0.078, "TestLiftUnlift": 0.117}, "export/test_pass_infra": {"TestPassInfra": 0.199}, "export/test_passes": {"TestPasses": 0.232}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.003, "RetraceExportTestExport": 0.1310000000000001}, "export/test_safeguard": {"TestSafeguard": 0.214}, "export/test_schema": {"TestSchema": 0.219}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.003, "SerDesExportPreDispatchTestExport": 0.12800000000000009, "SerDesExportTestDynamismExpression": 0.003, "SerDesExportTestExport": 0.12800000000000009}, "export/test_serialize": {"TestDeserialize": 9.355999999999998, "TestOpVersioning": 0.003, "TestSaveLoad": 0.006, "TestSchemaVersioning": 0.001, "TestSerialize": 0.21000000000000002, "TestSerializeCustomClass": 0.047}, "export/test_torchbind": {"TestExportTorchbind": 1.1270000000000002, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.192}, "export/test_unflatten": {"TestUnflatten": 0.20900000000000002}, "export/test_upgrade": {"TestUpgrade": 0.233}, "export/test_verifier": {"TestVerifier": 0.2}, "functorch/test_aotdispatch": {"TestAOTAutograd": 0.11100000000000008, "TestAOTDispatch": 0.008, "TestAOTExport": 0.02900000000000002, "TestAOTModuleSimplified": 0.007, "TestPartitioning": 0.010000000000000002}, "functorch/test_control_flow": {"TestControlFlow": 0.20500000000000002, "TestControlFlowTraced": 0.21700000000000016}, "functorch/test_dims": {"TestMin": 0.24600000000000002, "TestMinFunctorchOnly": 0.03400000000000002}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.02900000000000002, "TestAutogradFunctionVmapAPICUDA": 0.009000000000000001, "TestCompileTransformsCUDA": 0.002, "TestComposabilityCUDA": 0.04500000000000003, "TestExamplesCorrectnessCUDA": 0.02000000000000001, "TestFunctionalizeCUDA": 0.01800000000000001, "TestGradTransformCUDA": 0.06300000000000004, "TestHelpersCUDA": 0.005, "TestHessianCUDA": 0.004, "TestHigherOrderOperatorInteractionCUDA": 0.009000000000000001, "TestJacCUDA": 0.08200000000000006, "TestJvpCUDA": 0.022000000000000013, "TestLinearizeCUDA": 0.005, "TestMakeFunctional": 0.02000000000000001, "TestSliceArgnums": 0.009000000000000001, "TestVmapJvpInplaceViewCUDA": 0.005, "TestVmapOfGradCUDA": 0.007}, "functorch/test_logging": {"TestAOTLogging": 0.191}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.005, "RandomOpTestCase": 0.001, "ReduceTestCase": 0.009000000000000001, "TestMemoryEfficientOpAuthoring": 0.192}, "functorch/test_minifier": {"TestMinifier": 0.199}, "functorch/test_ops": {"TestOperatorsCUDA": 132.4200000000122}, "functorch/test_parsing": {"TestAnonymousAxis": 0.716, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.655}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.2700000000000002, "TestTransformFailureCUDA": 0.007, "TestVmapAPI": 0.549, "TestVmapBatchedGradientCUDA": 0.03100000000000002, "TestVmapDeviceTypeCUDA": 0.005, "TestVmapNestedTensorCUDA": 0.013000000000000005, "TestVmapOperators": 0.16500000000000012, "TestVmapOperatorsOpInfoCUDA": 6.926000000000383}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.430999999999854}, "higher_order_ops/test_with_effects": {"TestWithEffects": 4.3629999999999995}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.12000000000000009, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.09500000000000007, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.06500000000000004, "AOTInductorTestABICompatibleCuda": 0.10100000000000008, "AOTInductorTestNonABICompatibleCpu": 0.1240000000000001, "AOTInductorTestNonABICompatibleCuda": 0.10100000000000008}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 0.007, "BenchmarkFusionCudaTest": 0.007, "BenchmarkMultiTemplateFusionCudaTest": 0.003}, "inductor/test_binary_folding": {"FreezingCpuTests": 0.002, "FreezingCudaTests": 0.002}, "inductor/test_codecache": {"TestFxGraphCache": 0.028000000000000018, "TestFxGraphCacheHashing": 0.005, "TestUtils": 0.001, "test_codecache": 6.381}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.144}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 0.32500000000000023, "TestAutogradWithCompiledAutograd": 0.2960000000000002, "TestCompiledAutograd": 0.03800000000000003, "TestCustomOpWithCompiledAutograd": 0.08800000000000006}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 0.026000000000000016, "CompiledOptimizerTests": 0.21700000000000016}, "inductor/test_config": {"TestInductorConfig": 0.16}, "inductor/test_control_flow": {"CondTests": 0.17600000000000002, "WhileLoopTests": 0.01800000000000001}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 0.151}, "inductor/test_cpu_repro": {"CPUReproTests": 711.4809999999974}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 0.027000000000000017, "TestCudaWrapper": 0.027000000000000017}, "inductor/test_cuda_repro": {"CudaReproTests": 0.046000000000000034}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 0.07700000000000005}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.146}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 0.155}, "inductor/test_debug_trace": {"TestDebugTrace": 0.001}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.14900000000000002}, "inductor/test_dependencies": {"TestDependencies": 0.143}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 0.161}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.001, "EfficientConvBNEvalCudaTests": 0.001}, "inductor/test_extension_backend": {"ExtensionBackendTests": 21.97}, "inductor/test_foreach": {"ForeachTests": 0.20100000000000015}, "inductor/test_fp8": {"TestFP8Types": 0.002}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 0.12200000000000001, "SDPAPatternRewriterCpuTests": 0.01800000000000001, "SDPAPatternRewriterCudaDynamicTests": 0.024000000000000014, "SDPAPatternRewriterCudaTests": 0.03500000000000002}, "inductor/test_fx_fusion": {"TestFxFusion": 0.126}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.002, "TestGroupBatchFusion": 0.148, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.009000000000000001, "TestIndexingSimplification": 0.245}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 0.02100000000000001, "FreezingCudaTests": 0.02100000000000001}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 0.13}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 0.166}, "inductor/test_layout_optim": {"TestLayoutOptim": 0.02500000000000001}, "inductor/test_max_autotune": {"TestMaxAutotune": 0.17, "TestTuningProcess": 0.002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.003}, "inductor/test_metrics": {"TestMetrics": 0.006}, "inductor/test_minifier": {"MinifierTests": 0.155}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 0.133}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 0.008, "TestPatternMatcher": 0.3320000000000001}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.02000000000000001}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 0.015000000000000003}, "inductor/test_multi_kernel": {"MultiKernelTest": 0.162}, "inductor/test_pad_mm": {"PadMMTest": 0.135}, "inductor/test_padding": {"PaddingTest": 0.009000000000000001, "PerfTestBetweenGoodAndBadShape": 0.001, "PerfTestWithAndWithoutPadding": 0.147}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 0.04000000000000002}, "inductor/test_perf": {"FusionTests": 0.01800000000000001, "InplacingTests": 0.008, "MinCutPartitioningTests": 0.009000000000000001, "NoopTests": 0.006, "NumBytesMetricTests": 0.156, "SchedulerFusionTests": 0.004, "TilingTests": 0.002}, "inductor/test_profiler": {"DynamoProfilerTests": 0.151}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 0.14800000000000002}, "inductor/test_smoke": {"SmokeTest": 0.134}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 0.007, "MemoryBoundedTests": 0.004, "TestCommAnalysis": 0.009000000000000001, "UnsupportedTests": 0.129}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 0.136}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 0.161}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.002}, "inductor/test_torchinductor": {"GPUTests": 0.5770000000000004, "NanCheckerTest": 0.002, "RNNTest": 0.001, "SweepInputsGPUTest": 0.06400000000000004, "TritonCodeGenTests": 0.02100000000000001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 0.9410000000000004, "DynamicShapesCodegenGPUTests": 0.6680000000000005}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 33.382999999998944, "DynamicShapesGPUTests": 0.5710000000000004, "TestInductorDynamicCUDA": 0.047000000000000035}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 11.069999999998863}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.001}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.147}, "inductor/test_triton_kernels": {"KernelTests": 0.27300000000000013, "MutationTests": 0.026000000000000016, "NoOptimizationKernelTests": 0.1440000000000001, "no_opt_test_class": 0.1500000000000001}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 0.146}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 0.009000000000000001}, "inductor/test_utils": {"TestUtils": 0.207}, "lazy/test_debug_util": {"DebugUtilTest": 0.632}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.651}, "lazy/test_generator": {"LazyGeneratorTest": 0.641}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.635}, "lazy/test_step_closures": {"ClosuresTest": 0.651}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.002, "TestLazyTensor": 0.477}, "nn/test_convolution": {"TestConvolutionNN": 0.48800000000000004, "TestConvolutionNNDeviceTypeCUDA": 0.6370000000000005}, "nn/test_dropout": {"TestDropoutNN": 0.518, "TestDropoutNNDeviceTypeCUDA": 0.005}, "nn/test_embedding": {"TestEmbeddingNN": 0.5690000000000001, "TestEmbeddingNNDeviceTypeCUDA": 0.1310000000000001}, "nn/test_init": {"TestNNInit": 0.8170000000000001}, "nn/test_lazy_modules": {"TestLazyModules": 0.621}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.56, "TestLoadStateDictSwap": 0.002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.007, "TestModuleHookNN": 0.016000000000000007, "TestModuleHooks": 0.525, "TestStateDictHooks": 0.006}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 0.517, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.012000000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.646}, "nn/test_parametrization": {"TestNNParametrization": 0.5660000000000001, "TestNNParametrizationDeviceCUDA": 0.002}, "nn/test_pooling": {"TestAvgPool": 0.506, "TestPoolingNN": 0.014000000000000005, "TestPoolingNNDeviceTypeCUDA": 3.932999999999993}, "nn/test_pruning": {"TestPruningNN": 0.553}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.015000000000000003}, "profiler/test_memory_profiler": {"TestDataFlow": 0.010000000000000002, "TestIdentifyGradients": 0.005, "TestMemoryProfiler": 0.623, "TestMemoryProfilerE2E": 0.017000000000000008}, "profiler/test_profiler": {"TestExecutionTrace": 0.011000000000000003, "TestExperimentalUtils": 0.01900000000000001, "TestProfiler": 0.465, "TestProfilerCUDA": 0.463, "TestProfilerITT": 0.001, "TestRecordFunction": 0.004, "TestTorchTidyProfiler": 0.023000000000000013}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.642}, "profiler/test_record_function": {"TestRecordFunction": 0.65}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 0.641}, "test_ao_sparsity": {"TestActivationSparsifier": 0.001, "TestBaseDataScheduler": 0.004, "TestBaseDataSparsifier": 0.003, "TestBaseSparsifier": 0.009000000000000001, "TestBaseStructuredSparsifier": 0.01800000000000001, "TestComposability": 0.007, "TestCubicScheduler": 0.003, "TestFPGMPruner": 0.002, "TestFakeSparsity": 0.004, "TestFxComposability": 0.005, "TestNearlyDiagonalSparsifier": 0.005, "TestNormDataSparsifiers": 0.006, "TestQuantizationUtils": 0.002, "TestQuantizedSparseKernels": 0.205, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.002, "TestScheduler": 0.004, "TestSparsityUtilFunctions": 0.008, "TestWeightNormSparsifier": 0.006}, "test_autocast": {"TestAutocastCPU": 0.631, "TestAutocastGPU": 0.002, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.012000000000000004, "TestAutograd": 7.8770000000000895, "TestAutogradComplex": 0.002, "TestAutogradDeviceTypeCUDA": 0.06600000000000004, "TestAutogradForwardMode": 0.02900000000000002, "TestAutogradForwardModeBatchedGrad": 0.005, "TestAutogradFunctional": 0.1240000000000001, "TestAutogradInferenceMode": 0.01900000000000001, "TestAutogradLogging": 0.002, "TestAutogradMultipleDispatchCUDA": 0.008, "TestMultithreadAutograd": 0.012000000000000004, "TestNestedCheckpoint": 0.014000000000000005}, "test_autograd_fallback": {"TestAutogradFallback": 0.6880000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 18.32199999999813}, "test_bundled_inputs": {"TestBundledInputs": 0.663}, "test_comparison_utils": {"TestComparisonUtils": 0.636}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.524}, "test_content_store": {"TestContentStoreCUDA": 0.004}, "test_cpp_api_parity": {"TestCppApiParity": 0.9640000000000004}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.38, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.38, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 0.393}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.435}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 25.055}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.436}, "test_cuda": {"TestBlockStateAbsorption": 0.0, "TestCuda": 3.3369999999999886, "TestCudaMallocAsync": 0.017000000000000008, "TestCudaOptimsCUDA": 0.009000000000000001}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 3.3589999999999995, "TestCudaMallocAsync": 0.016000000000000007, "TestCudaOptimsCUDA": 0.009000000000000001}, "test_cuda_multigpu": {"TestCudaComm": 0.013000000000000005, "TestCudaMultiGPU": 0.516}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 1.9729999999999999}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.631, "TestEventHandler": 0.016000000000000007, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 6.8549999999999995}, "test_custom_ops": {"MiniOpTest": 0.06700000000000005, "MiniOpTestOther": 0.012000000000000004, "TestCustomOp": 0.08800000000000006, "TestCustomOpAPI": 0.028000000000000018, "TestCustomOpTestingCUDA": 0.028000000000000018, "TestGenerateOpcheckTests": 0.009000000000000001}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.001, "TestConcatDataset": 0.006, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.002, "TestDataLoader": 0.06800000000000005, "TestDataLoaderDeviceTypeCUDA": 0.003, "TestDataLoaderPersistentWorkers": 0.06800000000000005, "TestDatasetRandomSplit": 0.5, "TestDictDataLoader": 0.004, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.001, "TestSetAffinity": 0.001, "TestStackDataset": 0.009000000000000001, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.005}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.002, "TestDataChunk": 0.452, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 0.01900000000000001, "TestFunctionalMapDataPipe": 0.009000000000000001, "TestGraph": 0.006, "TestIterDataPipeCountSampleYielded": 0.005, "TestIterDataPipeGraphFastForward": 0.005, "TestIterDataPipeSingletonConstraint": 0.005, "TestIterableDataPipeBasic": 0.022, "TestSerialization": 0.002, "TestSharding": 0.008, "TestStreamWrapper": 0.212, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCUDA": 0.011000000000000003, "HasDecompTest": 0.003, "TestDecompCUDA": 96.97800000002815}, "test_deploy": {"TestFreezer": 0.616}, "test_dispatch": {"TestDispatch": 0.5780000000000001, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCUDA": 0.6250000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 0.004, "TestFloorDiv": 0.009000000000000001, "TestPySymInt": 0.47100000000000003, "TestSymNumberMagicMethods": 0.20400000000000015}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 0.08900000000000007, "TestExpandedWeightHelperFunctionCUDA": 0.506, "TestExpandedWeightModuleCUDA": 0.1230000000000001}, "test_fake_tensor": {"FakeTensorConstHandling": 0.010000000000000002, "FakeTensorConverterTest": 0.010000000000000002, "FakeTensorDispatchCache": 0.02000000000000001, "FakeTensorOpInfoTestCUDA": 0.011000000000000003, "FakeTensorOperatorInvariants": 0.012000000000000004, "FakeTensorPropTest": 0.004, "FakeTensorSerialization": 0.002, "FakeTensorTest": 0.05300000000000004}, "test_flop_counter": {"TestFlopCounter": 0.02300000000000001}, "test_foreach": {"TestForeachCUDA": 2.676999999999818}, "test_function_schema": {"TestFunctionSchema": 0.656}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 54.105000000000004}, "test_functional_optim": {"TestFunctionalOptimParity": 0.202}, "test_functionalization": {"TestCrossRefFunctionalization": 0.05600000000000004, "TestFunctionalization": 0.685}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 0.014000000000000005}, "test_futures": {"TestFuture": 0.645}, "test_fx": {"AnnotationsTest": 0.007, "TestCSEPass": 0.015000000000000006, "TestCommonPass": 0.016000000000000007, "TestConstFold": 0.02000000000000001, "TestConstParamShapeInControlFlow": 0.006, "TestDCE": 0.007, "TestFX": 0.18600000000000014, "TestFXAPIBackwardCompatibility": 0.005, "TestFunctionalTracing": 0.1240000000000001, "TestMatcher": 0.008, "TestOperatorSignaturesCUDA": 0.8620000000000005, "TestPassManager": 0.006, "TestSourceMatcher": 0.004, "TestSubgraphRewriter": 0.027000000000000017, "TestVisionTracing": 175.15499999999994, "TypeCheckerTest": 0.03100000000000002}, "test_fx_experimental": {"TestFXExperimental": 0.04100000000000003, "TestNormalizeOperatorsCUDA": 0.6640000000000005, "TestTranslationValidation": 0.004}, "test_fx_passes": {"TestFXGraphPasses": 0.666, "TestFXMatcherUtils": 0.016000000000000007}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.644}, "test_import_stats": {"TestImportTime": 0.626}, "test_indexing": {"NumpyTestsCUDA": 0.02100000000000001, "TestIndexingCUDA": 1.0649999999999928}, "test_itt": {"TestItt": 0.633}, "test_jit": {"TestAliasAnalysis": 0.004, "TestAsync": 0.02200000000000001, "TestAtenPow": 0.001, "TestAutodiffJit": 0.005, "TestAutodiffSubgraphSlicing": 0.01800000000000001, "TestAwait": 0.017000000000000008, "TestBackends": 0.0, "TestBackendsWithCompiler": 0.002, "TestBatchMM": 0.008, "TestBuiltins": 0.004, "TestCUDA": 0.004, "TestClassType": 0.04500000000000003, "TestComplex": 0.014000000000000005, "TestCustomOperators": 0.014000000000000005, "TestDCE": 0.002, "TestDataParallel": 0.0, "TestDataclasses": 0.007, "TestDeviceAnalysis": 0.016000000000000007, "TestDict": 0.028000000000000018, "TestDtypeAnalysis": 0.30200000000000005, "TestEnum": 0.017000000000000008, "TestFreezing": 0.05400000000000004, "TestFrontend": 0.002, "TestFrozenOptimizations": 0.03400000000000002, "TestFunctionalBlocks": 0.001, "TestFunctionalToInplaceActivation": 0.004, "TestGenerator": 0.005, "TestGetDefaultAttr": 0.003, "TestGraphRewritePasses": 0.001, "TestHash": 0.009000000000000001, "TestHooks": 0.023000000000000013, "TestIgnorableArgs": 0.002, "TestIgnoreContextManager": 0.003, "TestInplaceToFunctionalActivation": 0.002, "TestIsinstance": 0.02900000000000002, "TestJit": 4.4360000000000195, "TestJitGeneratedModule": 7.470000000000016, "TestJitProfiler": 0.001, "TestJitUtils": 0.008, "TestList": 0.08100000000000006, "TestLogging": 0.006, "TestMKLDNNReinplacing": 0.003, "TestMisc": 0.024000000000000014, "TestMixTracingScripting": 0.022000000000000013, "TestModels": 61.82599999999999, "TestModuleAPIs": 0.003, "TestModuleContainers": 0.01800000000000001, "TestModuleInterface": 0.016000000000000007, "TestModules": 0.001, "TestNamedTuple": 0.013000000000000005, "TestNnapiBackend": 18.286, "TestOpDecompositions": 0.002, "TestOptimizeForMobilePreserveDebugInfo": 0.007, "TestPDT": 0.01800000000000001, "TestParametrization": 0.002, "TestPeephole": 0.03900000000000003, "TestProducerVersion": 0.001, "TestProfiler": 0.14900000000000002, "TestPythonBindings": 0.008, "TestPythonBuiltinOP": 0.015000000000000006, "TestPythonIr": 0.004, "TestRecursiveScript": 0.03200000000000002, "TestRemoveMutation": 0.008, "TestSaveLoad": 0.015000000000000006, "TestSaveLoadFlatbuffer": 0.010000000000000002, "TestSaveLoadForOpVersion": 0.011000000000000003, "TestScript": 0.5910000000000004, "TestScriptDict": 0.010000000000000002, "TestScriptList": 0.016000000000000007, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.014000000000000005, "TestScriptProfile": 0.005, "TestSlice": 0.01800000000000001, "TestSparse": 0.004, "TestStringFormatting": 0.022000000000000013, "TestSymbolicShapeAnalysis": 0.025000000000000015, "TestTensorBuiltins": 0.006, "TestTensorCreationOps": 0.006, "TestTensorMethods": 0.002, "TestTorchbind": 0.08100000000000002, "TestTracer": 0.1300000000000001, "TestTypeSharing": 0.025000000000000015, "TestTypesAndAnnotation": 0.016000000000000007, "TestTyping": 0.03900000000000003, "TestUnion": 0.04900000000000004, "TestUnsupportedOps": 0.002, "TestUpgraders": 0.014000000000000005, "TestWarn": 0.007, "TestWith": 0.006}, "test_jit_autocast": {"TestAutocast": 0.043000000000000024, "TestJitTraceAutocast": 0.008}, "test_jit_disabled": {"TestJitDisabled": 0.613}, "test_jit_fuser_te": {"TestFuserCommon": 0.001, "TestNNCOpInfoCUDA": 12.026000000000016, "TestTEFuserDynamic": 0.09500000000000007, "TestTEFuserStatic": 0.09400000000000007}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCUDA": 0.0, "TestModel": 0.004, "TestOpCUDA": 0.001}, "test_jiterator": {"TestPythonJiteratorCUDA": 0.8030000000000003}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.549, "TestVmapBatchedGradientLegacyCUDA": 0.02900000000000002, "TestVmapOperatorsLegacy": 0.05200000000000004}, "test_license": {"TestLicense": 0.634}, "test_linalg": {"TestLinalgCUDA": 27.734000000000613}, "test_logging": {"LoggingTest": 0.634}, "test_masked": {"TestMaskedCUDA": 0.6010000000000001}, "test_maskedtensor": {"TestBasicsCUDA": 0.016000000000000007, "TestBinary": 0.06800000000000005, "TestOperatorsCUDA": 0.8490000000000005, "TestReductions": 0.01900000000000001, "TestUnary": 0.5960000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.001, "TestMatmulCudaCUDA": 0.527, "TestMixedDtypesLinearCudaCUDA": 0.0}, "test_meta": {"TestMetaCUDA": 49.226999999977394, "TestMetaConverter": 0.40800000000000003}, "test_mkl_verbose": {"TestMKLVerbose": 0.636}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.651}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 0.634}, "test_mobile_optimizer": {"TestOptimizer": 0.198}, "test_model_dump": {"TestModelDump": 0.663}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.216}, "test_modules": {"TestModuleCUDA": 4.550999999999843}, "test_monitor": {"TestMonitor": 0.615, "TestMonitorTensorboard": 0.089}, "test_multiprocessing": {"TestMultiprocessing": 0.531}, "test_multiprocessing_spawn": {"ErrorTest": 0.001, "ForkTest": 0.008, "SpawnTest": 0.636}, "test_namedtensor": {"TestNamedTensor": 0.5870000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 0.623}, "test_native_functions": {"TestNativeFunctions": 0.652}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.552}, "test_nestedtensor": {"TestNestedTensor": 0.04900000000000004, "TestNestedTensorAutogradCUDA": 0.05600000000000004, "TestNestedTensorDeviceTypeCUDA": 0.1490000000000001, "TestNestedTensorSubclassCUDA": 0.21300000000000016}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.001, "TestFusionUtils": 0.002, "TestNN": 1.455999999999951, "TestNNDeviceTypeCUDA": 1.3079999999999676, "TestUtils": 0.001}, "test_numba_integration": {"TestNumbaIntegration": 0.507}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.5730000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 0.626}, "test_ops": {"TestCommonCUDA": 222.40900000010032, "TestCompositeComplianceCUDA": 230.32000000001185, "TestFakeTensorCUDA": 627.1089999999962, "TestMathBitsCUDA": 3.4209999999998475, "TestSelfKwarg": 0.389, "TestTagsCUDA": 1.009}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 15.083999999999454}, "test_ops_gradients": {"TestBwdGradientsCUDA": 14.258999999998009}, "test_ops_jit": {"TestJitCUDA": 1.7519999999999423}, "test_optim": {"TestDifferentiableOptimizer": 0.481, "TestLRScheduler": 0.16600000000000012, "TestOptim": 1.155999999999999, "TestOptimRenewedCUDA": 0.5000000000000003, "TestSWAUtils": 0.013000000000000005}, "test_out_dtype_op": {"TestOutDtypeOp": 0.020000000000000007}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.001, "TestGradCheckOverride": 0.001, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.001, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 2.0729999999998916, "TestTorchFunctionWarning": 0.001, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.007, "ModelTest": 0.0, "TestAnalyze": 0.001, "TestDependencyAPI": 0.017000000000000008, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006, "TestLoadBCPackages": 0.004, "TestMangling": 0.010000000000000002, "TestMisc": 0.011000000000000003, "TestPackageFX": 0.006, "TestPackageScript": 0.023000000000000013, "TestRepackage": 0.001, "TestResources": 0.244, "TestSaveLoad": 0.011000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.67}, "test_prims": {"TestDecompCUDA": 0.002, "TestPrimsBasic": 0.471, "TestPrimsCUDA": 0.012000000000000004, "TestRefsCUDA": 0.005}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.006, "TestGenericProxyTensorFake": 0.13500000000000004, "TestGenericProxyTensorReal": 0.035000000000000024, "TestGenericProxyTensorSymbolic": 0.035000000000000024, "TestRealProxyTensor": 0.001, "TestSymbolicTracing": 0.05900000000000004}, "test_pruning_op": {"PruningOpTest": 0.687}, "test_public_bindings": {"TestPublicBindings": 0.672}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.001, "TestPythonDispatch": 0.07000000000000005, "TestPythonDispatcher": 0.002, "TestPythonRegistration": 0.01800000000000001, "TestWrapperSubclassAliasingCUDA": 0.01900000000000001}, "test_pytree": {"TestCxxPytree": 0.009000000000000001, "TestGenericPytree": 0.733, "TestPythonPytree": 0.03000000000000002}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.01800000000000001, "TestAOMigrationQuantization": 0.011000000000000003, "TestAOMigrationQuantizationFx": 0.012000000000000004, "TestBackendConfig": 0.01900000000000001, "TestBiasCorrectionEager": 0.002, "TestBitsCUDA": 0.003, "TestComparatorOps": 0.002, "TestDeprecatedJitQuantized": 0.004, "TestDistributed": 0.004, "TestDuplicateDQPass": 0.004, "TestDynamicQuantizedModule": 0.010000000000000002, "TestDynamicQuantizedOps": 0.016000000000000007, "TestEqualizeEager": 0.005, "TestEqualizeFx": 0.010000000000000002, "TestFXGraphMatcher": 0.014000000000000005, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 0.06600000000000003, "TestFXNumericSuiteCoreAPIsModels": 0.013000000000000005, "TestFXNumericSuiteNShadows": 0.024000000000000014, "TestFakeQuantize": 0.003, "TestFakeQuantizeOps": 0.03200000000000002, "TestFloat8DtypeCUDA": 0.013000000000000005, "TestFuseEager": 0.010000000000000002, "TestFuseFx": 0.016000000000000007, "TestFusedObsFakeQuant": 0.004, "TestFusedObsFakeQuantModule": 0.008, "TestFusionPasses": 0.001, "TestFxDetectInputWeightEqualization": 0.003, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.007, "TestFxModelReportObserver": 0.004, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.003, "TestHistogramObserver": 0.007, "TestMetaDataPorting": 0.006, "TestModelNumericsEager": 0.004, "TestNumericSuiteEager": 0.02000000000000001, "TestObserver": 0.014000000000000005, "TestPT2ERepresentation": 0.008, "TestPadding": 0.003, "TestQNNPackOps": 0.012000000000000004, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 0.003, "TestQuantizeDynamicJitPasses": 0.010000000000000002, "TestQuantizeEagerOps": 0.011000000000000003, "TestQuantizeEagerPTQDynamic": 0.013000000000000005, "TestQuantizeEagerPTQStatic": 0.02100000000000001, "TestQuantizeEagerQAT": 0.014000000000000005, "TestQuantizeEagerQATNumerics": 0.008, "TestQuantizeFx": 0.1590000000000001, "TestQuantizeFxModels": 0.008, "TestQuantizeFxOps": 0.05500000000000004, "TestQuantizeJit": 0.008, "TestQuantizeJitOps": 0.02900000000000002, "TestQuantizeJitPasses": 0.03900000000000003, "TestQuantizePT2E": 0.03900000000000003, "TestQuantizePT2EQATModels": 0.002, "TestQuantizePT2EQAT_ConvBn1d": 484.01699999999994, "TestQuantizePT2EQAT_ConvBn2d": 489.828, "TestQuantizePT2EX86Inductor": 0.03100000000000002, "TestQuantizedConv": 0.033000000000000015, "TestQuantizedEmbeddingOps": 0.006, "TestQuantizedFunctionalOps": 0.005, "TestQuantizedLinear": 0.015000000000000006, "TestQuantizedOps": 0.07700000000000004, "TestQuantizedTensor": 0.07900000000000004, "TestRecordHistogramObserver": 0.002, "TestReferenceQuantizedModule": 0.004, "TestSerialization": 0.01900000000000001, "TestStaticQuantizedModule": 0.03200000000000002, "TestSubgraphRewriter": 0.014000000000000005, "TestUtils": 0.006, "TestXNNPACKQuantizer": 0.025000000000000015, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCUDA": 5.241000000000008}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 0.5910000000000001}, "test_schema_check": {"TestSchemaCheck": 0.42400000000000004, "TestSchemaCheckModeOpInfoCUDA": 10.51399999999873}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 0.5830000000000001}, "test_serialization": {"TestBothSerializationCUDA": 0.002, "TestOldSerialization": 0.5700000000000001, "TestSerialization": 0.5740000000000001, "TestSubclassSerialization": 0.006}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.633}, "test_shape_ops": {"TestShapeOpsCUDA": 0.5850000000000001}, "test_show_pickle": {"TestShowPickle": 0.622}, "test_sort_and_select": {"TestSortAndSelectCUDA": 0.797}, "test_sparse": {"TestSparseAnyCUDA": 1.4749999999999497, "TestSparseCUDA": 0.2750000000000002, "TestSparseLegacyAndDeprecation": 0.487, "TestSparseMaskedReductionsCUDA": 0.04200000000000003, "TestSparseMeta": 0.03000000000000002, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCUDA": 1.3489999999999633}, "test_sparse_csr": {"TestSparseCSRCUDA": 1.9069999999999023, "TestSparseCSRSampler": 0.001, "TestSparseCompressedCUDA": 3.170999999999764, "TestSparseCompressedTritonKernelsCUDA": 0.07400000000000005}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.001, "TestCUSPARSELTCUDA": 0.003, "TestSparseSemiStructuredCUDA": 0.005, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.002, "TestSparseSemiStructuredCUTLASSCUDA": 0.002, "TestSparseSemiStructuredTrainingCUDA": 0.001}, "test_spectral_ops": {"TestFFTCUDA": 0.7290000000000003}, "test_stateless": {"TestPythonOptimizeMode": 0.001, "TestStatelessDeprecation": 0.002, "TestStatelessFunctionalAPI": 0.557}, "test_subclass": {"TestSubclass": 0.7520000000000001}, "test_sympy_utils": {"TestSingletonInt": 0.001, "TestSympyInterp": 0.058000000000000045, "TestSympySolve": 0.028000000000000018, "TestValueRanges": 0.39000000000000007}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.1440000000000001, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.024000000000000014, "TestTensorCreationCUDA": 0.9770000000000003}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.002, "TestTensorBoardFigure": 0.0, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.131, "TestTensorBoardPytorchGraph": 0.006, "TestTensorBoardSummary": 0.01800000000000001, "TestTensorBoardSummaryWriter": 0.003, "TestTensorBoardUtils": 0.004, "TestTensorBoardWriter": 0.001, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 0.7200000000000001}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.001, "TestTensorExprPyBind": 0.639}, "test_testing": {"TestAssertClose": 0.03300000000000002, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.014000000000000005, "TestAssertCloseMultiDeviceCUDA": 0.002, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.004, "TestAssertCloseSparseBSR": 0.004, "TestAssertCloseSparseCOO": 0.006, "TestAssertCloseSparseCSC": 0.004, "TestAssertCloseSparseCSR": 0.004, "TestFrameworkUtils": 0.001, "TestImports": 0.005, "TestMakeTensorCUDA": 0.7310000000000005, "TestOpInfoSampleFunctionsCUDA": 1.2519999999999738, "TestOpInfos": 0.002, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCUDA": 0.027000000000000017, "TestTestingCUDA": 0.534}, "test_torch": {"TestBasicVitalSigns": 0.003, "TestDevicePrecisionCUDA": 0.02000000000000001, "TestTorch": 0.21200000000000016, "TestTorchDeviceTypeCUDA": 22.681000000000854, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 0.01800000000000001, "TestSDPACUDA": 2.1999999999999, "TestSDPACudaOnlyCUDA": 41.11199999999842, "TestSDPAFailureModesCUDA": 0.02900000000000002, "TestTransformersCUDA": 3.360999999999997}, "test_type_hints": {"TestTypeHints": 0.642}, "test_type_info": {"TestDTypeInfo": 0.638}, "test_type_promotion": {"TestTypePromotionCUDA": 0.8780000000000003}, "test_typing": {"TestTyping": 49.16399999999997}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 25.83500000000863}, "test_utils": {"TestAssert": 0.002, "TestBottleneck": 0.001, "TestCheckpoint": 0.21200000000000002, "TestCollectEnv": 0.001, "TestCppExtensionUtils": 0.002, "TestDataLoaderUtils": 0.004, "TestDeviceUtilsCUDA": 6.3530000000003835, "TestExtensionUtils": 0.002, "TestHipify": 0.001, "TestHipifyTrie": 0.003, "TestONNXUtils": 0.002, "TestRenderUtils": 0.001, "TestStandaloneCPPJIT": 0.001, "TestTraceback": 0.005}, "test_view_ops": {"TestOldViewOpsCUDA": 0.11500000000000009, "TestViewOpsCUDA": 0.6660000000000001}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.015000000000000005, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 0.64}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 751.848, "TestXNNPACKOps": 0.652, "TestXNNPACKRewritePass": 0.002, "TestXNNPACKSerDes": 0.003}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.001}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.22, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.003, "TestPickling": 0.017000000000000008, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 0.23600000000000004, "TestEinsumPath": 0.0, "TestMisc": 0.001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.511, "TestHalf": 0.0, "TestIinfo": 0.211, "TestMisc": 0.001, "TestPythonFloat": 0.001, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.003, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.001, "TestFloatNonIntegerArgument": 0.004, "TestIndexing": 0.23000000000000004, "TestMultiIndexingAutomated": 0.003, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.012000000000000004, "TestArgmax": 0.06300000000000004, "TestArgmaxArgminCommon": 0.013000000000000005, "TestArgmin": 0.06300000000000004, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.203, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.002, "TestAttributes": 0.017, "TestBinop": 0.001, "TestBool": 503.32399999999996, "TestCequenceMethods": 0.001, "TestChoose": 0.012, "TestClip": 0.002, "TestCompress": 0.003, "TestConversion": 0.002, "TestCreation": 0.0, "TestDelMisc": 0.001, "TestDot": 2.186, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.006, "TestFlag": 0.009000000000000001, "TestFormat": 0.003, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.228, "TestHashing": 0.002, "TestIO": 0.001, "TestInner": 0.004, "TestLexsort": 0.012000000000000004, "TestMatmul": 0.6130000000000002, "TestMatmulOperator": 0.013000000000000005, "TestMethods": 0.11400000000000009, "TestMinMax": 0.002, "TestMinScalarType": 0.004, "TestNewaxis": 0.001, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.035, "TestResize": 0.008, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.021, "TestSortFloatMisc": 0.016000000000000007, "TestStats": 0.20500000000000002, "TestSubscripting": 0.001, "TestTake": 0.008, "TestVdot": 0.004, "TestWarnings": 0.001, "TestWhere": 0.008, "TestWritebackIfCopy": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.005, "TestArgwhere": 0.005, "TestArrayComparisons": 0.004, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006, "TestBoolArray": 0.003, "TestBoolCmp": 0.002, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.05300000000000004, "TestConvolve": 0.004, "TestCorrelate": 0.004, "TestCreationFuncs": 0.005, "TestCross": 0.005, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006, "TestFromiter": 0.0, "TestIndex": 0.002, "TestIndices": 0.016000000000000007, "TestIsclose": 0.008, "TestIsscalar": 0.001, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.005, "TestNonarrayArgs": 0.037000000000000026, "TestNonzeroAndCountNonzero": 0.023000000000000013, "TestOuterMisc": 0.001, "TestRequire": 0.004, "TestResize": 0.22, "TestRoll": 0.003, "TestRollaxis": 0.002, "TestSeterr": 0.004, "TestStdVar": 0.005, "TestStdVarComplex": 0.002, "TestStringFunction": 0.001, "TestTensordot": 0.003, "TestTypes": 0.005}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.65, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06100000000000005, "TestFromInt": 0.002, "TestFromString": 0.625}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.628, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.010000000000000002, "TestBaseMath": 0.002, "TestBitShifts": 0.010000000000000002, "TestComplexDivision": 0.002, "TestConversion": 0.006, "TestHash": 0.0, "TestModulus": 37.946, "TestMultiply": 0.0, "TestNegative": 0.002, "TestPower": 0.004, "TestRepr": 0.001, "TestScalarOpsMisc": 0.027000000000000017, "TestScalarSubclassingMisc": 0.002, "TestSubtract": 0.002, "TestTypes": 0.644}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.648, "TestAtleast2d": 0.005, "TestAtleast3d": 0.004, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.047000000000000035, "TestHstack": 0.007, "TestStackMisc": 0.0, "TestVstack": 0.007}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.001, "TestFFTShift": 0.64, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.07400000000000005, "TestFFTShift": 0.623, "TestFFTThreadSafe": 0.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.64}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.004, "TestUnique": 0.24100000000000002}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.002, "TestAmax": 0.001, "TestAmin": 0.001, "TestAngle": 0.001, "TestAny": 0.002, "TestAverage": 0.003, "TestBincount": 0.013000000000000005, "TestCheckFinite": 0.002, "TestCopy": 0.002, "TestCorrCoef": 0.010000000000000002, "TestCov": 0.013000000000000005, "TestCumprod": 0.001, "TestCumsum": 0.001, "TestDelete": 0.013000000000000001, "TestDiff": 0.006, "TestDigitize": 0.011000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.12000000000000009, "TestFlip": 0.007, "TestGradient": 0.01800000000000001, "TestInsert": 0.005, "TestInterp": 0.02900000000000002, "TestKaiser": 0.002, "TestMedian": 0.015000000000000006, "TestMeshgrid": 0.011000000000000003, "TestMsort": 0.0, "TestPercentile": 0.016000000000000007, "TestPiecewise": 0.008, "TestProd": 0.001, "TestPtp": 0.001, "TestQuantile": 0.004, "TestRot90": 0.193, "TestSelect": 0.006, "TestSinc": 0.002, "TestSortComplex": 0.007, "TestTrapz": 0.002, "TestTrimZeros": 0.008, "TestUnique": 0.002, "Test_I0": 0.002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.9109999999999999, "TestHistogramOptimBinNums": 0.017000000000000008, "TestHistogramdd": 0.017000000000000008}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.001, "TestDiagIndicesFrom": 0.003, "TestFillDiagonal": 0.007, "TestGrid": 0.007, "TestIndexExpression": 0.002, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.635}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.009000000000000001, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.009000000000000001, "TestColumnStack": 0.004, "TestDsplit": 0.005, "TestDstack": 0.006, "TestExpandDims": 0.004, "TestHsplit": 0.004, "TestKron": 0.001, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.002, "TestSplit": 0.002, "TestSqueeze": 0.005, "TestTakeAlongAxis": 0.628, "TestTile": 0.004, "TestVsplit": 0.004}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.005, "TestEye": 0.637, "TestFliplr": 0.001, "TestFlipud": 0.001, "TestHistogram2d": 0.006, "TestTri": 0.007, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.63, "TestImag": 0.002, "TestIscomplex": 0.002, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.003, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.003, "TestReal": 0.002, "TestRealIfClose": 0.001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.02100000000000001, "TestCond": 0.229, "TestDet": 0.14900000000000002, "TestEig": 0.03900000000000001, "TestEigh": 0.007, "TestEighCases": 0.0, "TestEigvals": 0.05800000000000001, "TestEigvalsh": 0.007, "TestEigvalshCases": 0.0, "TestInv": 0.060000000000000005, "TestLstsq": 0.012000000000000004, "TestMatrixRank": 0.003, "TestMisc": 0.25, "TestMisc2": 0.001, "TestMultiDot": 0.011000000000000003, "TestNormDouble": 0.010000000000000002, "TestNormInt64": 0.010000000000000002, "TestNormSingle": 0.010000000000000002, "TestNorm_NonSystematic": 0.001, "TestPinv": 0.20700000000000002, "TestPinvHermitian": 0.044, "TestQR": 0.006, "TestSVD": 0.03900000000000001, "TestSVDHermitian": 0.113, "TestSolve": 0.274, "TestTensorinv": 0.007, "TestTensorsolve": 0.002}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.003, "TestCtorNested": 0.001, "TestDefaultDtype": 0.004, "TestDivmod": 0.005, "TestExport": 0.0, "TestMisc": 0.002, "TestNormalizations": 0.003, "TestOneArr": 0.6780000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1320000000000001, "TestOneArrAndShape": 0.02, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.005, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.68}, "torch_np/test_dtype": {"TestConvertDType": 0.6930000000000001}, "torch_np/test_function_base": {"TestAppend": 0.631}, "torch_np/test_ndarray_methods": {"TestAmax": 0.001, "TestAmin": 0.001, "TestArgmax": 0.07500000000000005, "TestArgmaxArgminCommon": 0.013000000000000003, "TestArgmin": 0.07500000000000005, "TestContains": 0.001, "TestIndexing": 0.217, "TestIter": 0.002, "TestNoExtraMethods": 0.006, "TestNonzero": 0.005, "TestRavel": 0.002, "TestReshape": 0.002, "TestTranspose": 0.002}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.011, "TestNEP50Table": 0.0}, "torch_np/test_random": {"TestChoice": 0.002, "TestNumpyGlobal": 0.001, "TestScalarReturn": 0.264, "TestShuffle": 0.006}, "torch_np/test_reductions": {"TestAll": 0.003, "TestAny": 0.003, "TestFlatnonzero": 0.637, "TestGenericCumSumProd": 0.008, "TestGenericReductions": 0.9340000000000007, "TestMean": 0.004, "TestSum": 0.010000000000000002}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.20400000000000001, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3080000000000002, "TestNdarrayDunderVsUfunc": 0.03000000000000002, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.662}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.77}}}, "linux-focal-rocm6.1-py3.8": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 2.11}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 3.8256666666666668}, "distributions/test_constraints": {"test_constraints": 1.2309999999999977}, "distributions/test_distributions": {"TestAgainstScipy": 0.8985000000000001, "TestConstraints": 0.1835, "TestDistributionShapes": 0.15900000000000006, "TestDistributions": 33.0275, "TestFunctors": 0.0075, "TestJit": 10.506499999999999, "TestKL": 2.7514999999999996, "TestLazyLogitsInitialization": 0.01, "TestNumericalStability": 0.06150000000000001, "TestRsample": 0.679, "TestValidation": 0.3340000000000001}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 34.446666666666665}, "dynamo/test_after_aot": {"TestAfterAot": 5.724333333333334}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 21.522666666666666}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.14300000000000002, "AOTAutogradCacheTests": 10.253666666666666}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.931999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0006666666666666666, "NormalizeIRTests": 0.028999999999999998, "TestCustomBackendAPI": 1.5006666666666666, "TestExplainWithBackend": 8.197333333333335, "TestOptimizations": 1.738333333333333}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 11.342333333333334}, "dynamo/test_base_output": {"TestBaseOutput": 0.001}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 4.364333333333334}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 5.082666666666666, "BytecodeTests": 0.375}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.422666666666667, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.5026666666666667}, "dynamo/test_config": {"ConfigTests": 0.48633333333333334}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.2675, "CppGuardManagerFuncTorchHigherOrderOpTests": 8.619499999999999, "CppGuardManagerFunctionTests": 18.073500000000006, "CppGuardManagerHigherOrderOpTests": 5.949999999999999, "CppGuardManagerMiscTests": 51.44950000000007, "CppGuardManagerReproTests": 46.60350000000004}, "dynamo/test_ctx_manager": {"CtxManagerTests": 15.921666666666667}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 3.9466666666666668}, "dynamo/test_debug_utils": {"TestDebugUtils": 15.573999999999998}, "dynamo/test_decorators": {"DecoratorTests": 5.036666666666668}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0026666666666666666, "TestDeviceGuard": 0.013666666666666667}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 48.67566666666667, "DynamicShapesCtxManagerTests": 19.580000000000002, "DynamicShapesExportTests": 22.71000000000001, "DynamicShapesFuncTorchHigherOrderOpTests": 92.60666666666668, "DynamicShapesFunctionTests": 67.89899999999996, "DynamicShapesHigherOrderOpTests": 13.382666666666665, "DynamicShapesMiscTests": 103.76700000000011, "DynamicShapesNNModuleTests": 6.587999999999998, "DynamicShapesReproTests": 117.07100000000007, "DynamicShapesSubGraphTests": 10.359666666666667, "DynamicShapesTestSDPA": 0.292}, "dynamo/test_exc": {"ExcTests": 1.6289999999999998}, "dynamo/test_exceptions": {"ExceptionTests": 0.4353333333333334}, "dynamo/test_export": {"ExportTests": 27.536666666666672}, "dynamo/test_export_mutations": {"MutationExportTests": 0.48033333333333333}, "dynamo/test_frame_init": {"FrameInitTests": 0.26166666666666666}, "dynamo/test_functions": {"DefaultsTests": 0.6446666666666668, "FunctionTests": 22.03266666666669}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.0963333333333332}, "dynamo/test_global": {"TestGlobals": 0.462}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.379}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 19.030500000000004, "FuncTorchHigherOrderOpTests": 7.427000000000001, "HigherOrderOpTests": 5.421499999999996, "HigherOrderOpVmapGuardTests": 2.7649999999999997}, "dynamo/test_hooks": {"HooksTests": 24.23166666666667}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 18.826666666666664, "InlineInbuiltNNModulesExportTests": 33.79566666666667, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 8.134333333333332, "InlineInbuiltNNModulesFunctionTests": 17.5036666666667, "InlineInbuiltNNModulesHigherOrderOpTests": 5.561, "InlineInbuiltNNModulesMiscTests": 77.72966666666683, "InlineInbuiltNNModulesNNModuleTests": 18.186666666666657}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 6.885333333333333}, "dynamo/test_interop": {"InteropTests": 0.5473333333333333}, "dynamo/test_logging": {"LoggingTests": 39.681000000000004}, "dynamo/test_minifier": {"MinifierTests": 16.129333333333335}, "dynamo/test_misc": {"MiscTests": 89.1955000000001, "TestTracer": 0.042499999999999996}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.002}, "dynamo/test_modules": {"NNModuleTests": 22.173999999999992, "OptimizedModuleTest": 25.62566666666666}, "dynamo/test_nops": {"NopTests": 0.3193333333333333}, "dynamo/test_optimizers": {"End2EndTests": 0.6123333333333333}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.47266666666666673}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.2943333333333331}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.5553333333333333}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.0176666666666667}, "dynamo/test_recompiles": {"RecompileTests": 0.7150000000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.43900000000000006}, "dynamo/test_repros": {"ReproTests": 50.712666666666685}, "dynamo/test_resume": {"ResumeFunctionTests": 0.40199999999999997}, "dynamo/test_sdpa": {"TestSDPA": 0.4253333333333334}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.42100000000000004}, "dynamo/test_sources": {"SourceTests": 0.42333333333333334}, "dynamo/test_structured_trace": {"StructuredTraceTest": 29.23466666666667}, "dynamo/test_subclasses": {"SubclassTests": 3.8429999999999986, "TestNestedTensor": 11.698333333333332}, "dynamo/test_subgraphs": {"SubGraphTests": 1.7693333333333328}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.08333333333333333, "TraceRuleTests": 0.984}, "dynamo/test_unspec": {"UnspecTests": 10.766333333333334}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.6196666666666667}, "dynamo/test_view": {"ViewTests": 0.5156666666666667}, "export/test_converter": {"TestConverter": 5.875}, "export/test_db": {"ExampleTests": 2.329333333333333}, "export/test_experimental": {"TestExperiment": 0.8293333333333334}, "export/test_export": {"TestDynamismExpression": 0.9855, "TestExport": 41.74099999999999, "TestExportCustomClass": 0.0925, "TestOneOffModelExportResult": 1.497}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.3606666666666667, "NonStrictExportTestExport": 21.16666666666666}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.38400000000000006, "PreDispatchExportTestExport": 30.14866666666667}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.3415}, "export/test_hop": {"TestHOPCUDA": 2.078333333333333, "TestHOPGeneric": 0.0023333333333333335}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.276}, "export/test_pass_infra": {"TestPassInfra": 0.6690000000000002}, "export/test_passes": {"TestPasses": 10.579333333333333}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.761, "RetraceExportTestExport": 33.83366666666666}, "export/test_safeguard": {"TestSafeguard": 0.8213333333333335}, "export/test_schema": {"TestSchema": 0.25766666666666665}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.19133333333333333, "SerDesExportPreDispatchTestExport": 19.844000000000005, "SerDesExportTestDynamismExpression": 0.6709999999999999, "SerDesExportTestExport": 34.237}, "export/test_serialize": {"TestDeserialize": 6.839333333333333, "TestOpVersioning": 0.0030000000000000005, "TestSaveLoad": 0.22233333333333336, "TestSchemaVersioning": 0.02266666666666667, "TestSerialize": 0.9623333333333335, "TestSerializeCustomClass": 0.065}, "export/test_sparse": {"TestSparseProp": 127.67400000000023}, "export/test_tools": {"TestExportTools": 0.5183333333333334}, "export/test_torchbind": {"TestCompileTorchbind": 1.1703333333333334, "TestExportTorchbind": 2.135666666666666, "TestRegisterFakeClass": 0.0026666666666666666}, "export/test_tree_utils": {"TestTreeUtils": 0.258}, "export/test_unflatten": {"TestUnflatten": 2.472}, "export/test_upgrade": {"TestUpgrade": 0.3583333333333334}, "export/test_verifier": {"TestVerifier": 0.7469999999999999}, "functorch/test_ac": {"MemoryBudgetTest": 3.1565000000000003}, "functorch/test_aotdispatch": {"TestAOTAutograd": 26.23066666666666, "TestAOTAutogradWithDynamo": 12.296666666666665, "TestAOTDispatch": 0.551, "TestAOTExport": 1.7486666666666668, "TestAOTModuleSimplified": 1.615, "TestPartitioning": 18.424333333333333}, "functorch/test_control_flow": {"TestControlFlow": 0.8790000000000001, "TestControlFlowTraced": 77.68533333333338}, "functorch/test_dims": {"TestMin": 21.809, "TestMinFunctorchOnly": 22.09466666666667}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.0606666666666667, "TestAutogradFunctionVmapAPICUDA": 0.012666666666666668, "TestCompileTransformsCUDA": 0.2283333333333333, "TestComposabilityCUDA": 0.11700000000000005, "TestExamplesCorrectnessCUDA": 10.972333333333331, "TestFunctionalizeCUDA": 0.08333333333333336, "TestGradTransformCUDA": 14.360666666666681, "TestHelpersCUDA": 0.008666666666666668, "TestHessianCUDA": 0.059666666666666666, "TestHigherOrderOperatorInteractionCUDA": 0.024000000000000004, "TestJacCUDA": 0.5216666666666668, "TestJvpCUDA": 0.04066666666666668, "TestLinearizeCUDA": 0.18600000000000003, "TestMakeFunctional": 0.9076666666666663, "TestSliceArgnums": 0.010333333333333335, "TestVmapJvpInplaceViewCUDA": 0.013666666666666667, "TestVmapOfGradCUDA": 0.39666666666666667}, "functorch/test_logging": {"TestAOTLogging": 0.2806666666666667}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.2435, "RandomOpTestCase": 0.1775, "ReduceTestCase": 0.0525, "TestMemoryEfficientOpAuthoring": 9.685500000000001}, "functorch/test_minifier": {"TestMinifier": 0.38833333333333336}, "functorch/test_ops": {"TestOperatorsCUDA": 3997.70766666664}, "functorch/test_parsing": {"TestAnonymousAxis": 0.24, "TestParsedExpression": 0.0035, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.25300000000000006}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.6830000000000005, "TestTransformFailureCUDA": 0.05700000000000001, "TestVmapAPI": 14.4675, "TestVmapBatchedGradientCUDA": 0.18400000000000008, "TestVmapDeviceTypeCUDA": 0.019000000000000003, "TestVmapNestedTensorCUDA": 0.21450000000000005, "TestVmapOperators": 18.358500000000003, "TestVmapOperatorsOpInfoCUDA": 296.74049999999875}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.0583333333332283}, "higher_order_ops/test_with_effects": {"TestWithEffects": 7.502333333333333}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 583.4523333333333, "AOTInductorTestABICompatibleCpuWithStackAllocation": 426.9783333333333, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 209.41633333333334, "AOTInductorTestABICompatibleCuda": 1609.814, "AOTInductorTestNonABICompatibleCpu": 1368.6286666666667, "AOTInductorTestNonABICompatibleCuda": 2339.2923333333333}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 6.47, "BenchmarkFusionCudaTest": 95.388, "BenchmarkMultiTemplateFusionCudaTest": 51.2915}, "inductor/test_binary_folding": {"FreezingCpuTests": 31.935499999999998, "FreezingCudaTests": 2.276, "FreezingGpuTests": 2.074}, "inductor/test_codecache": {"TestFxGraphCache": 114.37199999999999, "TestFxGraphCacheHashing": 0.6355, "TestUtils": 2.9370000000000003, "test_codecache": 15.9085}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.22949999999999998}, "inductor/test_compile_worker": {"TestCompileWorker": 11.719666666666667}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 246.80900000000034, "TestCompiledAutograd": 104.10233333333336, "TestCustomOpWithCompiledAutograd": 17.132333333333328}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 915.4900000000001, "CompiledOptimizerTests": 2235.5226666666663}, "inductor/test_config": {"TestInductorConfig": 4.434666666666666}, "inductor/test_control_flow": {"CondTests": 97.44466666666666, "WhileLoopTests": 57.43333333333334}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 3.999333333333334}, "inductor/test_cpu_repro": {"CPUReproTests": 806.4836666666666}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 852.835, "TestCudaWrapper": 770.2049999999999}, "inductor/test_cuda_repro": {"CudaReproTests": 234.89300000000003}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 102.49550000000002}, "inductor/test_custom_lowering": {"TestCustomLowering": 3.8914999999999997}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 9.970333333333334}, "inductor/test_debug_trace": {"TestDebugTrace": 33.35633333333333}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 71.14999999999999}, "inductor/test_dependencies": {"TestDependencies": 0.20650000000000002}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 30.933000000000003}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 274.0076666666667, "EfficientConvBNEvalCudaTests": 227.297}, "inductor/test_extension_backend": {"ExtensionBackendTests": 35.065}, "inductor/test_flex_attention": {"TestFlexAttention": 1001.5949999999997, "TestTemplatedSDPA": 0.004333333333333333}, "inductor/test_foreach": {"ForeachTests": 443.8265}, "inductor/test_fp8": {"TestFP8Types": 0.007000000000000001}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 22.502000000000006, "SDPAPatternRewriterCpuTests": 26.034666666666663, "SDPAPatternRewriterCudaDynamicTests": 42.674333333333344, "SDPAPatternRewriterCudaTests": 57.866666666666696}, "inductor/test_fx_fusion": {"TestFxFusion": 0.40466666666666673}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.0115}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.017, "TestGroupBatchFusion": 289.74600000000004, "TestPostGradBatchLinearFusion": 2.712}, "inductor/test_indexing": {"ExprPrinterTests": 0.03150000000000001, "TestIndexingSimplification": 2.508}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 38.018, "FreezingCudaTests": 45.462500000000006}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 6.050000000000001}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 281.72499999999997}, "inductor/test_layout_optim": {"TestLayoutOptim": 25.566666666666666}, "inductor/test_loop_ordering": {"LoopOrderingTest": 19.8715}, "inductor/test_max_autotune": {"TestMaxAutotune": 287.205, "TestTuningProcess": 11.9695}, "inductor/test_memory_planning": {"TestMemoryPlanning": 34.159}, "inductor/test_metrics": {"TestMetrics": 4.663}, "inductor/test_minifier": {"MinifierTests": 27.132666666666665}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 55.196333333333335}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 27.259, "TestPatternMatcher": 266.407}, "inductor/test_mmdecomp": {"TestDecompCUDA": 20.14066666666667}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 13.219}, "inductor/test_multi_kernel": {"MultiKernelTest": 109.37933333333332}, "inductor/test_pad_mm": {"PadMMTest": 170.31133333333332}, "inductor/test_padding": {"PaddingTest": 24.791, "PerfTestBetweenGoodAndBadShape": 0.001, "PerfTestWithAndWithoutPadding": 17.431}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 127.03600000000002}, "inductor/test_perf": {"FusionTests": 25.607, "InplacingTests": 13.343666666666666, "MinCutPartitioningTests": 21.11966666666667, "NoopTests": 1.5743333333333336, "NumBytesMetricTests": 53.425333333333334, "SchedulerFusionTests": 11.095666666666668, "TilingTests": 3.6413333333333333}, "inductor/test_profiler": {"DynamoProfilerTests": 7.613999999999999}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 137.25333333333333}, "inductor/test_smoke": {"SmokeTest": 18.448999999999998}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 16.455333333333332, "MemoryBoundedTests": 3.8823333333333334, "TestCommAnalysis": 6.060666666666666, "UnsupportedTests": 0.6016666666666667}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 108.67666666666666}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 16.73633333333333}, "inductor/test_torchbind": {"TestTorchbind": 6.554000000000001}, "inductor/test_torchinductor": {"CpuTests": 1463.5025000000003, "GPUTests": 1450.1416666666667, "NanCheckerTest": 1.6135, "RNNTest": 4.2428333333333335, "SweepInputsCpuTest": 99.74183333333333, "SweepInputsGPUTest": 45.151833333333336, "TestFull": 10.139833333333334, "TritonCodeGenTests": 42.2575}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1515.189333333333, "DynamicShapesCodegenGPUTests": 1566.1033333333335}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1751.0119999999997, "DynamicShapesGPUTests": 2005.134, "TestInductorDynamicCUDA": 60.99700000000001}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 20872.327333333338}, "inductor/test_torchinductor_strided_blocks": {"TritonBlockPointerTest": 20.432000000000002}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 1.0170000000000001}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 31.769999999999996}, "inductor/test_triton_kernels": {"KernelTests": 163.08249999999995, "MutationTests": 0.2675000000000001}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 10.865}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 36.317}, "inductor/test_utils": {"TestUtils": 0.2545}, "lazy/test_debug_util": {"DebugUtilTest": 0.261}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.27166666666666667}, "lazy/test_generator": {"LazyGeneratorTest": 0.26566666666666666}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 2.1216666666666666}, "lazy/test_step_closures": {"ClosuresTest": 2.219}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.16266666666666665, "TestLazyTensor": 0.04766666666666667}, "nn/test_convolution": {"TestConvolutionNN": 147.1835, "TestConvolutionNNDeviceTypeCUDA": 86.31399999999948}, "nn/test_dropout": {"TestDropoutNN": 0.3256666666666667, "TestDropoutNNDeviceTypeCUDA": 0.496}, "nn/test_embedding": {"TestEmbeddingNN": 0.49433333333333335, "TestEmbeddingNNDeviceTypeCUDA": 9.957999999999986}, "nn/test_init": {"TestNNInit": 3.664333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 6.782666666666664}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.254499999999999, "TestLoadStateDictSwap": 0.037000000000000005}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.10550000000000001, "TestModuleHookNN": 0.08650000000000001, "TestModuleHooks": 0.05550000000000001, "TestStateDictHooks": 0.021000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 385.0786666666666, "TestMultiheadAttentionNNDeviceTypeCUDA": 13.752333333333334}, "nn/test_packed_sequence": {"PackedSequenceTest": 2.4479999999999995}, "nn/test_parametrization": {"TestNNParametrization": 21.94966666666667, "TestNNParametrizationDeviceCUDA": 14.025333333333334}, "nn/test_pooling": {"TestAvgPool": 0.3355, "TestPoolingNN": 0.8210000000000001, "TestPoolingNNDeviceTypeCUDA": 12.645}, "nn/test_pruning": {"TestPruningNN": 0.06900000000000003}, "profiler/test_execution_trace": {"TestExecutionTrace": 16.015}, "profiler/test_memory_profiler": {"TestDataFlow": 0.8065, "TestIdentifyGradients": 0.1865, "TestMemoryProfiler": 0.316, "TestMemoryProfilerE2E": 2.1825}, "profiler/test_profiler": {"TestExperimentalUtils": 14.403666666666666, "TestProfiler": 44.106666666666676, "TestProfilerCUDA": 3.2399999999999998, "TestProfilerITT": 0.002}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.395}, "profiler/test_record_function": {"TestRecordFunction": 0.35250000000000004}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 3.0805}, "test_ao_sparsity": {"TestActivationSparsifier": 1.4656666666666667, "TestBaseDataScheduler": 0.7106666666666667, "TestBaseDataSparsifier": 0.5760000000000001, "TestBaseSparsifier": 0.016666666666666666, "TestBaseStructuredSparsifier": 33.73666666666667, "TestComposability": 1.5786666666666667, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.156, "TestFakeSparsity": 0.05000000000000001, "TestFxComposability": 1.3593333333333335, "TestNearlyDiagonalSparsifier": 0.48233333333333334, "TestNormDataSparsifiers": 12.285000000000002, "TestQuantizationUtils": 0.482, "TestQuantizedSparseKernels": 0.4603333333333333, "TestQuantizedSparseLayers": 0.6583333333333333, "TestSaliencyPruner": 0.018333333333333337, "TestScheduler": 0.034333333333333334, "TestSparsityUtilFunctions": 0.02366666666666667, "TestWeightNormSparsifier": 8.915000000000001}, "test_autocast": {"TestAutocastCPU": 1.1025, "TestAutocastGPU": 12.421, "TestTorchAutocast": 0.09}, "test_autograd": {"TestAllowMutationOnSaved": 0.019333333333333338, "TestAutograd": 60.68666666666661, "TestAutogradComplex": 0.0033333333333333335, "TestAutogradDeviceTypeCUDA": 5.117166666666667, "TestAutogradForwardMode": 0.08850000000000002, "TestAutogradForwardModeBatchedGrad": 0.011333333333333332, "TestAutogradFunctional": 9.202, "TestAutogradInferenceMode": 0.019833333333333345, "TestAutogradLogging": 0.009333333333333332, "TestAutogradMultipleDispatchCUDA": 0.012499999999999999, "TestMultithreadAutograd": 0.21100000000000005, "TestNestedCheckpoint": 0.32000000000000006, "TestSelectiveActivationCheckpoint": 0.06616666666666667}, "test_autograd_fallback": {"TestAutogradFallback": 0.36750000000000005}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 178.7922000000025}, "test_bundled_inputs": {"TestBundledInputs": 3.0226666666666664}, "test_comparison_utils": {"TestComparisonUtils": 0.329}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0005}, "test_complex": {"TestComplexTensorCUDA": 0.09250000000000001}, "test_content_store": {"TestContentStoreCUDA": 3.9414999999999996}, "test_cpp_api_parity": {"TestCppApiParity": 21.430500000000045}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.2395, "TestMAIATensor": 0.0915, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.033}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.2395, "TestMAIATensor": 0.092, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.002, "TestTorchLibrary": 0.0325}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 293.71000000000004}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0005}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 29.34050000000001}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0}, "test_cuda": {"TestBlockStateAbsorption": 0.0, "TestCuda": 62.935166666666674, "TestCudaMallocAsync": 22.565333333333342, "TestCudaOptimsCUDA": 1.6238333333333326}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 58.211666666666694, "TestCudaMallocAsync": 21.941666666666674, "TestCudaOptimsCUDA": 1.723999999999999}, "test_cuda_multigpu": {"TestCudaComm": 0.016500000000000008, "TestCudaMultiGPU": 0.4466666666666666}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.003}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.518, "TestEventHandler": 0.02000000000000001, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 1.9849999999999999}, "test_custom_ops": {"MiniOpTest": 0.43950000000000017, "MiniOpTestOther": 0.04500000000000001, "TestCustomOp": 21.80100000000001, "TestCustomOpAPI": 0.11050000000000004, "TestCustomOpTestingCUDA": 1.6055000000000001, "TestGenerateOpcheckTests": 4.4915}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 48.086000000000006, "TestConcatDataset": 0.007666666666666666, "TestConvAfterFork": 0.08633333333333333, "TestCustomPinFn": 0.157, "TestDataLoader": 51.124, "TestDataLoaderDeviceTypeCUDA": 0.07066666666666667, "TestDataLoaderPersistentWorkers": 79.04899999999999, "TestDatasetRandomSplit": 0.022999999999999996, "TestDictDataLoader": 0.08166666666666668, "TestIndividualWorkerQueue": 0.0013333333333333333, "TestNamedTupleDataLoader": 0.005, "TestSetAffinity": 0.057999999999999996, "TestStackDataset": 0.123, "TestStringDataLoader": 0.08533333333333333, "TestTensorDataset": 0.016}, "test_datapipe": {"TestCaptureDataFrame": 0.0030000000000000005, "TestCircularSerialization": 0.009666666666666665, "TestDataChunk": 0.006000000000000001, "TestDataFramesPipes": 0.36400000000000005, "TestFunctionalIterDataPipe": 2.7999999999999994, "TestFunctionalMapDataPipe": 0.023333333333333334, "TestGraph": 0.008333333333333333, "TestIterDataPipeCountSampleYielded": 0.005666666666666667, "TestIterDataPipeGraphFastForward": 0.028999999999999998, "TestIterDataPipeSingletonConstraint": 0.016333333333333335, "TestIterableDataPipeBasic": 0.022333333333333334, "TestSerialization": 6.0249999999999995, "TestSharding": 0.21233333333333335, "TestStreamWrapper": 0.147, "TestTyping": 0.0026666666666666666}, "test_decomp": {"DecompOneOffTestsCUDA": 0.02566666666666667, "HasDecompTest": 0.10433333333333333, "TestDecompCUDA": 9325.51099999999}, "test_deploy": {"TestFreezer": 0.22133333333333335}, "test_dispatch": {"TestDispatch": 41.451000000000015, "TestPythonDispatcher": 0.0395}, "test_dlpack": {"TestTorchDlPackCUDA": 0.2330000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 1.3855, "TestFloorDiv": 0.009500000000000001, "TestGuardsExpressions": 0.019, "TestPySymInt": 0.9420000000000004, "TestSymNumberMagicMethods": 1.2764999999999977}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 17.131333333333334, "TestExpandedWeightHelperFunctionCUDA": 13.643, "TestExpandedWeightModuleCUDA": 41.27066666666667}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04433333333333334, "FakeTensorConverterTest": 0.015000000000000001, "FakeTensorDispatchCache": 0.05000000000000002, "FakeTensorOpInfoTestCUDA": 0.10266666666666668, "FakeTensorOperatorInvariants": 0.20566666666666666, "FakeTensorPropTest": 0.04800000000000001, "FakeTensorSerialization": 0.0030000000000000005, "FakeTensorTest": 0.7440000000000002, "PropagateRealTensorsFakeTensorConstHandling": 0.06433333333333334, "PropagateRealTensorsFakeTensorConverterTest": 0.013000000000000003, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.11833333333333335, "PropagateRealTensorsFakeTensorPropTest": 0.032333333333333325, "PropagateRealTensorsFakeTensorTest": 14.080000000000004}, "test_flop_counter": {"TestFlopCounter": 20.02733333333333}, "test_foreach": {"TestForeachCUDA": 110.57350000000088}, "test_function_schema": {"TestFunctionSchema": 0.5295000000000001}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 128.44033333333334}, "test_functional_optim": {"TestFunctionalOptimParity": 0.29200000000000004}, "test_functionalization": {"TestCrossRefFunctionalization": 5.432999999999997, "TestFunctionalization": 5.9209999999999985}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 1.8286666666666667}, "test_futures": {"TestFuture": 0.9470000000000001}, "test_fx": {"AnnotationsTest": 0.009000000000000001, "TestCSEPass": 0.19766666666666668, "TestCommonPass": 0.1246666666666667, "TestConstFold": 0.15400000000000005, "TestConstParamShapeInControlFlow": 0.025333333333333336, "TestDCE": 0.018, "TestFX": 2.2853333333333308, "TestFXAPIBackwardCompatibility": 0.018333333333333337, "TestFunctionalTracing": 0.2153333333333335, "TestMatcher": 0.25533333333333336, "TestOperatorSignaturesCUDA": 0.7976666666666672, "TestPassManager": 0.01466666666666667, "TestSourceMatcher": 1.0586666666666666, "TestSubgraphRewriter": 0.18100000000000013, "TestVisionTracing": 181.07900000000004, "TypeCheckerTest": 1.524666666666665}, "test_fx_experimental": {"TestFXExperimental": 272.19666666666654, "TestNormalizeOperatorsCUDA": 1.3110000000000006, "TestTranslationValidation": 0.11066666666666665}, "test_fx_passes": {"TestFXGraphPasses": 0.47250000000000014, "TestFXMatcherUtils": 0.057000000000000016}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.43900000000000006}, "test_import_stats": {"TestImportTime": 3.3994999999999997}, "test_indexing": {"NumpyTestsCUDA": 0.029666666666666678, "TestIndexingCUDA": 1.6856666666666635}, "test_itt": {"TestItt": 0.23666666666666666}, "test_jit": {"TestAliasAnalysis": 0.22066666666666668, "TestAsync": 0.19766666666666668, "TestAtenPow": 0.005, "TestAutodiffJit": 0.08966666666666666, "TestAutodiffSubgraphSlicing": 0.15200000000000005, "TestAwait": 0.0996666666666667, "TestBackends": 0.002, "TestBackendsWithCompiler": 0.07933333333333333, "TestBatchMM": 0.04666666666666667, "TestBuiltins": 0.034, "TestCUDA": 0.56, "TestClassType": 0.48900000000000016, "TestComplex": 0.525, "TestCustomOperators": 0.03400000000000001, "TestDCE": 0.011000000000000001, "TestDataParallel": 0.0, "TestDataclasses": 2.303, "TestDeviceAnalysis": 2.5206666666666666, "TestDict": 0.23533333333333342, "TestDtypeAnalysis": 0.14366666666666666, "TestEnum": 0.08, "TestFreezing": 0.769666666666667, "TestFrontend": 0.030666666666666665, "TestFrozenOptimizations": 42.194333333333326, "TestFunctionalBlocks": 0.0036666666666666666, "TestFunctionalToInplaceActivation": 4.8, "TestGenerator": 0.03566666666666667, "TestGetDefaultAttr": 0.009666666666666667, "TestGraphRewritePasses": 0.058666666666666666, "TestHash": 0.042, "TestHooks": 0.3653333333333335, "TestIgnorableArgs": 0.005666666666666667, "TestIgnoreContextManager": 0.025000000000000005, "TestInplaceToFunctionalActivation": 4.582333333333334, "TestIsinstance": 0.11300000000000003, "TestJit": 9.137666666666668, "TestJitGeneratedModule": 30.217666666666485, "TestJitProfiler": 0.001, "TestJitUtils": 0.009666666666666669, "TestList": 0.7473333333333336, "TestLogging": 0.026000000000000006, "TestMKLDNNReinplacing": 0.0036666666666666666, "TestMisc": 0.4736666666666667, "TestMixTracingScripting": 0.7446666666666667, "TestModels": 37.733333333333334, "TestModuleAPIs": 0.09100000000000001, "TestModuleContainers": 0.7416666666666667, "TestModuleInterface": 0.211, "TestModules": 0.008333333333333333, "TestNamedTuple": 0.036, "TestNnapiBackend": 18.24, "TestOpDecompositions": 0.009333333333333334, "TestOptimizeForMobilePreserveDebugInfo": 0.24633333333333338, "TestParametrization": 0.4696666666666666, "TestPeephole": 0.24533333333333343, "TestProducerVersion": 0.001, "TestProfiler": 0.14633333333333334, "TestPythonBindings": 0.016, "TestPythonBuiltinOP": 0.2026666666666667, "TestPythonIr": 0.011000000000000001, "TestRecursiveScript": 0.3440000000000001, "TestRemoveMutation": 0.07, "TestSaveLoad": 65.24166666666667, "TestSaveLoadFlatbuffer": 0.13, "TestSaveLoadForOpVersion": 1.386333333333333, "TestScript": 19.549333333333337, "TestScriptDict": 0.012000000000000002, "TestScriptList": 0.445, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.07166666666666667, "TestScriptProfile": 10.526333333333334, "TestSlice": 0.0816666666666667, "TestSparse": 0.16333333333333333, "TestStringFormatting": 0.06433333333333335, "TestSymbolicShapeAnalysis": 3.423333333333332, "TestTensorBuiltins": 0.055999999999999994, "TestTensorCreationOps": 0.026333333333333334, "TestTensorMethods": 0.006333333333333334, "TestTorchbind": 0.07333333333333336, "TestTracer": 17.78433333333333, "TestTypeSharing": 0.26866666666666666, "TestTypesAndAnnotation": 0.05933333333333335, "TestTyping": 0.20166666666666674, "TestUnion": 0.23666666666666678, "TestUnsupportedOps": 0.023333333333333334, "TestUpgraders": 0.037666666666666675, "TestWarn": 0.027, "TestWith": 0.15800000000000003}, "test_jit_autocast": {"TestAutocast": 14.513999999999992, "TestJitTraceAutocast": 13.983000000000002}, "test_jit_disabled": {"TestJitDisabled": 0.5355000000000001}, "test_jit_fuser_te": {"TestFuserCommon": 0.107, "TestNNCOpInfoCUDA": 10.207333333332665, "TestTEFuserDynamic": 428.1966666666667, "TestTEFuserStatic": 469.03399999999993}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0003333333333333333, "TestEnableDisableLlgaFuser": 0.19333333333333333, "TestFusionPatternCUDA": 0.0, "TestModel": 0.001, "TestOpCUDA": 0.0013333333333333333}, "test_jiterator": {"TestPythonJiteratorCUDA": 23.711000000000013}, "test_legacy_vmap": {"TestVmapAPILegacy": 203.73350000000016, "TestVmapBatchedGradientLegacyCUDA": 0.5485000000000002, "TestVmapOperatorsLegacy": 6.792999999999999}, "test_license": {"TestLicense": 0.2365}, "test_linalg": {"TestLinalgCUDA": 997.5079999999911}, "test_logging": {"LoggingTest": 2.613}, "test_masked": {"TestMaskedCUDA": 24.140000000000015}, "test_maskedtensor": {"TestBasicsCUDA": 0.21800000000000005, "TestBinary": 0.24000000000000013, "TestOperatorsCUDA": 4.388999999999997, "TestReductions": 0.05133333333333334, "TestUnary": 0.31266666666666676}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.111, "TestMatmulCudaCUDA": 28.910000000000018, "TestMixedDtypesLinearCudaCUDA": 0.0}, "test_meta": {"TestMetaCUDA": 1849.5699999998712, "TestMetaConverter": 0.09066666666666667}, "test_mkl_verbose": {"TestMKLVerbose": 4.2915}, "test_mkldnn_fusion": {"TestMkldnnFusion": 209.79100000000003}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.892333333333333}, "test_mobile_optimizer": {"TestOptimizer": 3.1935000000000002}, "test_model_dump": {"TestModelDump": 2.0736666666666665}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.15133333333333332}, "test_module_tracker": {"TestModuleTracker": 0.23966666666666667}, "test_modules": {"TestModuleCUDA": 1608.8069999999773}, "test_monitor": {"TestMonitor": 0.24933333333333332, "TestMonitorTensorboard": 0.11399999999999999}, "test_multiprocessing": {"TestMultiprocessing": 53.056}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.674, "SpawnTest": 30.862000000000002}, "test_namedtensor": {"TestNamedTensor": 1.3676666666666646}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.5034999999999998}, "test_native_functions": {"TestNativeFunctions": 0.4543333333333333}, "test_native_mha": {"TestMHADeviceTypeCUDA": 12.554999999999989}, "test_nestedtensor": {"TestNestedTensor": 0.9220000000000003, "TestNestedTensorAutogradCUDA": 1.1033333333333333, "TestNestedTensorDeviceTypeCUDA": 16.62366666666665, "TestNestedTensorSubclassCUDA": 6.560666666666666}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.2854, "TestFusionUtils": 0.004, "TestNN": 147.87999999999994, "TestNNDeviceTypeCUDA": 269.6136000000042, "TestUtils": 0.0024000000000000002}, "test_numba_integration": {"TestNumbaIntegration": 0.274}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.2240000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 3.9730000000000003}, "test_ops": {"TestCommonCUDA": 3159.1828333332855, "TestCompositeComplianceCUDA": 820.9983333333313, "TestFakeTensorCUDA": 579.7689999999989, "TestMathBitsCUDA": 81.11650000000006, "TestSelfKwarg": 0.020166666666666666, "TestTagsCUDA": 1.8631666666666675}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 698.1089999999955}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1980.993333333261}, "test_ops_jit": {"TestJitCUDA": 921.1706666666663}, "test_optim": {"TestDifferentiableOptimizer": 0.138, "TestLRScheduler": 0.6740000000000003, "TestOptimRenewedCUDA": 356.55299999999954, "TestSWAUtils": 22.6755}, "test_out_dtype_op": {"TestOutDtypeOp": 0.6570000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.002, "TestGradCheckOverride": 0.015, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.048, "TestResolveName": 0.088, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 1.74449999999992, "TestTorchFunctionWarning": 0.008, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.028999999999999998, "ModelTest": 0.0, "TestAnalyze": 0.15966666666666665, "TestDependencyAPI": 0.03400000000000001, "TestDependencyHooks": 0.005333333333333333, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006666666666666667, "TestLoadBCPackages": 0.038, "TestMangling": 0.011333333333333334, "TestMisc": 0.021000000000000005, "TestPackageFX": 0.042666666666666665, "TestPackageScript": 1.1946666666666665, "TestRepackage": 0.004333333333333334, "TestResources": 0.007333333333333333, "TestSaveLoad": 0.025000000000000005}, "test_per_overload_api": {"TestPerOverloadAPI": 0.347}, "test_prims": {"TestDecompCUDA": 0.065, "TestPrimsBasic": 0.018666666666666668, "TestPrimsCUDA": 0.34966666666666674, "TestRefsCUDA": 0.007333333333333333}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.08133333333333333, "TestGenericProxyTensorFake": 18.592000000000002, "TestGenericProxyTensorReal": 22.62833333333333, "TestGenericProxyTensorSymbolic": 33.82200000000001, "TestRealProxyTensor": 0.010666666666666666, "TestSymbolicTracing": 2.6956666666666655}, "test_pruning_op": {"PruningOpTest": 0.501}, "test_public_bindings": {"TestPublicBindings": 4.839333333333333}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.004, "TestPythonDispatch": 0.17350000000000004, "TestPythonDispatcher": 0.008, "TestPythonRegistration": 0.30750000000000005, "TestWrapperSubclassAliasingCUDA": 0.20100000000000007}, "test_pytree": {"TestCxxPytree": 0.013333333333333338, "TestGenericPytree": 0.5363333333333334, "TestPythonPytree": 0.042666666666666686}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.01, "TestAOMigrationNNQuantized": 0.019333333333333338, "TestAOMigrationQuantization": 0.011000000000000001, "TestAOMigrationQuantizationFx": 0.012666666666666666, "TestBackendConfig": 0.03666666666666667, "TestBiasCorrectionEager": 61.520999999999994, "TestBitsCUDA": 0.016, "TestComparatorOps": 73.66, "TestDeprecatedJitQuantized": 1.1073333333333333, "TestDistributed": 0.37333333333333335, "TestDuplicateDQPass": 2.545, "TestDynamicQuantizedModule": 228.7936666666667, "TestDynamicQuantizedOps": 560.073, "TestEqualizeEager": 7.006, "TestEqualizeFx": 16.445000000000004, "TestFXGraphMatcher": 1.5170000000000001, "TestFXGraphMatcherModels": 9.822999999999999, "TestFXNumericSuiteCoreAPIs": 30.569333333333333, "TestFXNumericSuiteCoreAPIsModels": 59.23733333333333, "TestFXNumericSuiteNShadows": 132.73333333333332, "TestFakeQuantize": 0.2956666666666667, "TestFakeQuantizeOps": 24.718, "TestFloat8DtypeCUDA": 1.0490000000000002, "TestFuseEager": 27.605333333333334, "TestFuseFx": 5.642333333333333, "TestFusedObsFakeQuant": 1.585, "TestFusedObsFakeQuantModule": 1.5506666666666666, "TestFusionPasses": 0.18699999999999997, "TestFxDetectInputWeightEqualization": 0.5043333333333333, "TestFxDetectOutliers": 6.890666666666667, "TestFxModelReportClass": 6.191, "TestFxModelReportDetectDynamicStatic": 0.632, "TestFxModelReportDetector": 1.6836666666666664, "TestFxModelReportObserver": 4.115333333333333, "TestFxModelReportVisualizer": 2.422333333333333, "TestGenerateNumericDebugHandle": 0.6443333333333334, "TestGraphUtils": 1.5236666666666665, "TestHistogramObserver": 74.10566666666666, "TestMetaDataPorting": 5.458666666666666, "TestModelNumericsEager": 7.401000000000001, "TestNumericSuiteEager": 84.43466666666666, "TestObserver": 5.103333333333333, "TestPT2ERepresentation": 18.866333333333333, "TestPadding": 72.32233333333333, "TestQNNPackOps": 33.22966666666667, "TestQuantizationDocs": 0.004666666666666667, "TestQuantizeDynamicJitOps": 2.6329999999999996, "TestQuantizeDynamicJitPasses": 5.421333333333334, "TestQuantizeEagerOps": 10.449666666666666, "TestQuantizeEagerPTQDynamic": 75.954, "TestQuantizeEagerPTQStatic": 89.71766666666667, "TestQuantizeEagerQAT": 79.89333333333333, "TestQuantizeEagerQATNumerics": 109.16433333333332, "TestQuantizeFx": 66.96233333333333, "TestQuantizeFxModels": 77.839, "TestQuantizeFxOps": 162.348, "TestQuantizeJit": 12.854, "TestQuantizeJitOps": 292.5876666666666, "TestQuantizeJitPasses": 22.326333333333334, "TestQuantizePT2E": 55.19966666666667, "TestQuantizePT2EQATModels": 301.134, "TestQuantizePT2EQAT_ConvBn1d": 411.9293333333333, "TestQuantizePT2EQAT_ConvBn2d": 436.66033333333326, "TestQuantizePT2EX86Inductor": 208.40900000000002, "TestQuantizedConv": 345.3316666666667, "TestQuantizedEmbeddingOps": 14.814666666666668, "TestQuantizedFunctionalOps": 15.980666666666666, "TestQuantizedLinear": 393.30199999999996, "TestQuantizedOps": 2261.4203333333335, "TestQuantizedTensor": 11.983666666666664, "TestRecordHistogramObserver": 0.016999999999999998, "TestReferenceQuantizedModule": 3.2953333333333332, "TestSerialization": 7.614333333333334, "TestStaticQuantizedModule": 709.4423333333334, "TestSubgraphRewriter": 0.9289999999999999, "TestUtils": 0.04033333333333333, "TestXNNPACKQuantizer": 32.383, "TestXNNPACKQuantizerModels": 59.51433333333333}, "test_reductions": {"TestReductionsCUDA": 98.0354999999963}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 11.557666666666668}, "test_schema_check": {"TestSchemaCheck": 0.5640000000000001, "TestSchemaCheckModeOpInfoCUDA": 367.89749999999134}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 1.721666666666667}, "test_serialization": {"TestBothSerializationCUDA": 0.0775, "TestOldSerialization": 14.3925, "TestSerialization": 5.6519999999999975, "TestSubclassSerialization": 0.0175}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.33099999999999996}, "test_shape_ops": {"TestShapeOpsCUDA": 29.313000000000006}, "test_show_pickle": {"TestShowPickle": 0.223}, "test_sort_and_select": {"TestSortAndSelectCUDA": 3.543999999999996}, "test_sparse": {"TestSparseAnyCUDA": 439.62250000000006, "TestSparseCUDA": 14.593499999999985, "TestSparseLegacyAndDeprecation": 0.3085, "TestSparseMaskedReductionsCUDA": 1.6735000000000002, "TestSparseMeta": 5.686499999999999, "TestSparseOneOff": 0.10300000000000001, "TestSparseUnaryUfuncsCUDA": 4.211499999999946}, "test_sparse_csr": {"TestSparseCSRCUDA": 151.78366666666716, "TestSparseCSRSampler": 0.4366666666666667, "TestSparseCompressedCUDA": 88.01233333333323, "TestSparseCompressedTritonKernelsCUDA": 455.52566666666604}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.001, "TestSparseSemiStructuredCUDA": 0.011333333333333336, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.004666666666666667, "TestSparseSemiStructuredCUTLASSCUDA": 0.0023333333333333335, "TestSparseSemiStructuredTrainingCUDA": 0.0036666666666666666}, "test_spectral_ops": {"TestFFTCUDA": 219.35600000000017}, "test_stateless": {"TestPythonOptimizeMode": 2.7413333333333334, "TestStatelessDeprecation": 1.534, "TestStatelessFunctionalAPI": 0.3383333333333334}, "test_subclass": {"TestSubclass": 0.4825000000000001}, "test_sympy_utils": {"TestNumbers": 0.03, "TestSingletonInt": 0.004, "TestSympyInterp": 6.347, "TestSympySolve": 0.12333333333333336, "TestValueRanges": 4.707999999999998}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.3810000000000003, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.15400000000000003, "TestTensorCreationCUDA": 78.98750000000038}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.011000000000000001, "TestTensorBoardFigure": 0.9293333333333332, "TestTensorBoardNumpy": 0.0030000000000000005, "TestTensorBoardPyTorchNumpy": 0.4976666666666667, "TestTensorBoardPytorchGraph": 158.69266666666667, "TestTensorBoardSummary": 0.020000000000000007, "TestTensorBoardSummaryWriter": 0.006666666666666667, "TestTensorBoardUtils": 0.11666666666666665, "TestTensorBoardWriter": 0.055, "TestTensorProtoSummary": 0.007666666666666666}, "test_tensorexpr": {"TestTensorExprFuser": 62.754999999999995}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.008, "TestTensorExprPyBind": 0.618}, "test_testing": {"TestAssertClose": 1.0109999999999997, "TestAssertCloseContainer": 0.006666666666666667, "TestAssertCloseErrorMessage": 0.06633333333333334, "TestAssertCloseMultiDeviceCUDA": 0.010666666666666666, "TestAssertCloseQuantized": 0.68, "TestAssertCloseSparseBSC": 0.016333333333333335, "TestAssertCloseSparseBSR": 0.014333333333333332, "TestAssertCloseSparseCOO": 0.6176666666666666, "TestAssertCloseSparseCSC": 0.019, "TestAssertCloseSparseCSR": 0.019, "TestFrameworkUtils": 18.82, "TestImports": 10.735333333333335, "TestMakeTensorCUDA": 0.9923333333333307, "TestOpInfoSampleFunctionsCUDA": 3.4753333333333383, "TestOpInfos": 0.005333333333333333, "TestTestParametrization": 0.025000000000000012, "TestTestParametrizationDeviceTypeCUDA": 3.952666666666667, "TestTestingCUDA": 0.5413333333333334}, "test_torch": {"TestBasicVitalSigns": 0.005, "TestDevicePrecisionCUDA": 0.049000000000000016, "TestTorch": 5.83599999999999, "TestTorchDeviceTypeCUDA": 202.93200000000087, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 0.01950000000000001, "TestSDPACUDA": 1.343499999999967, "TestSDPACudaOnlyCUDA": 472.8379999998307, "TestSDPAFailureModesCUDA": 0.06250000000000003, "TestTransformersCUDA": 16.214500000000008}, "test_type_hints": {"TestTypeHints": 0.23299999999999998}, "test_type_info": {"TestDTypeInfo": 0.35833333333333334}, "test_type_promotion": {"TestTypePromotionCUDA": 5.403999999999983}, "test_typing": {"TestTyping": 53.290666666666645}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 652.4051666666754}, "test_utils": {"TestAssert": 0.0455, "TestBottleneck": 25.423000000000002, "TestCheckpoint": 0.24300000000000002, "TestCollectEnv": 1.3655, "TestCppExtensionUtils": 0.24, "TestDataLoaderUtils": 0.2915, "TestDeviceUtilsCUDA": 7.510000000000293, "TestExtensionUtils": 0.0055, "TestHipify": 0.002, "TestHipifyTrie": 0.008, "TestONNXUtils": 0.006, "TestRenderUtils": 0.019, "TestStandaloneCPPJIT": 12.6615, "TestTraceback": 0.013000000000000001}, "test_view_ops": {"TestOldViewOpsCUDA": 12.711999999999996, "TestViewOpsCUDA": 0.8969999999999985}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.014333333333333337, "WeakKeyDictionaryTestCase": 0.016, "WeakTest": 3.6409999999999987}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 432.05733333333336, "TestXNNPACKOps": 14.067333333333332, "TestXNNPACKRewritePass": 5.712, "TestXNNPACKSerDes": 15.592333333333334}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.001}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.21133333333333337, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.0030000000000000005, "TestPickling": 0.07900000000000001, "TestPromotion": 0.0}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 13.097999999999999, "TestEinsumPath": 0.0023333333333333335, "TestMisc": 0.006333333333333333}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.33033333333333337, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.0030000000000000005, "TestBroadcastedAssignments": 0.02766666666666667, "TestFancyIndexingCast": 0.002, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.5393333333333334, "TestMultiIndexingAutomated": 0.005, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.013000000000000003, "TestArgmax": 0.7236666666666672, "TestArgmaxArgminCommon": 0.11133333333333335, "TestArgmin": 0.7530000000000006, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.032333333333333346, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.006000000000000001, "TestAttributes": 0.11766666666666666, "TestBinop": 0.012000000000000002, "TestBool": 16.072333333333333, "TestCequenceMethods": 0.001, "TestChoose": 0.012000000000000002, "TestClip": 0.0036666666666666666, "TestCompress": 0.0030000000000000005, "TestConversion": 0.023000000000000003, "TestCreation": 0.0013333333333333333, "TestDelMisc": 0.001, "TestDot": 0.043333333333333356, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.018000000000000002, "TestFlag": 0.008, "TestFormat": 0.004, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.14566666666666667, "TestHashing": 0.002, "TestIO": 0.0013333333333333333, "TestInner": 0.139, "TestLexsort": 0.012333333333333337, "TestMatmul": 0.3043333333333334, "TestMatmulOperator": 0.19133333333333336, "TestMethods": 0.9760000000000003, "TestMinMax": 0.0030000000000000005, "TestMinScalarType": 0.004, "TestNewaxis": 0.0030000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.042666666666666665, "TestResize": 0.028999999999999998, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.013666666666666669, "TestSortFloatMisc": 0.10833333333333338, "TestStats": 0.19666666666666668, "TestSubscripting": 0.001, "TestTake": 0.023333333333333334, "TestVdot": 0.02466666666666667, "TestWarnings": 0.001, "TestWhere": 3.935333333333334, "TestWritebackIfCopy": 0.016}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.013000000000000003, "TestArgwhere": 0.017, "TestArrayComparisons": 0.011333333333333334, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006000000000000001, "TestBoolArray": 1.8193333333333335, "TestBoolCmp": 0.11699999999999999, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.13433333333333342, "TestConvolve": 0.045000000000000005, "TestCorrelate": 0.11933333333333335, "TestCreationFuncs": 0.7126666666666667, "TestCross": 0.03333333333333333, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006333333333333334, "TestFromiter": 0.001, "TestIndex": 0.004, "TestIndices": 0.026000000000000006, "TestIsclose": 0.05433333333333334, "TestIsscalar": 0.09033333333333333, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.005666666666666667, "TestNonarrayArgs": 0.07133333333333337, "TestNonzeroAndCountNonzero": 0.162, "TestOuterMisc": 0.0036666666666666666, "TestRequire": 0.004, "TestResize": 0.23233333333333336, "TestRoll": 0.02066666666666667, "TestRollaxis": 0.0030000000000000005, "TestSeterr": 0.004, "TestStdVar": 0.019, "TestStdVarComplex": 0.008333333333333333, "TestStringFunction": 0.001, "TestTensordot": 0.009333333333333334, "TestTypes": 0.008333333333333333}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.21833333333333335, "TestDocStrings": 0.0, "TestIsSubDType": 0.006000000000000001, "TestScalarTypeNames": 0.021000000000000008}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.060000000000000046, "TestFromInt": 0.014, "TestFromString": 0.313}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.215, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.07, "TestBaseMath": 6.216333333333334, "TestBitShifts": 0.06033333333333333, "TestComplexDivision": 0.03966666666666666, "TestConversion": 0.035, "TestHash": 0.0, "TestModulus": 0.6553333333333333, "TestMultiply": 0.0, "TestNegative": 0.012000000000000002, "TestPower": 0.08700000000000001, "TestRepr": 0.001, "TestScalarOpsMisc": 0.026000000000000013, "TestScalarSubclassingMisc": 0.0023333333333333335, "TestSubtract": 0.012000000000000002, "TestTypes": 9.613}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.22866666666666668, "TestAtleast2d": 0.010333333333333335, "TestAtleast3d": 0.009333333333333334, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.19100000000000006, "TestHstack": 0.011333333333333336, "TestStackMisc": 0.0016666666666666668, "TestVstack": 0.012333333333333335}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.007333333333333333, "TestFFTShift": 4.456333333333333, "TestIRFFTN": 0.015666666666666666, "TestRFFTFreq": 0.007333333333333333}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.9843333333333333, "TestFFTShift": 0.3243333333333333, "TestFFTThreadSafe": 27.546000000000003}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.25433333333333336}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0015, "TestUnique": 0.35150000000000003}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.005666666666666667, "TestAmax": 0.005, "TestAmin": 0.004666666666666667, "TestAngle": 0.007333333333333333, "TestAny": 0.005333333333333333, "TestAverage": 0.02033333333333333, "TestBincount": 0.03166666666666666, "TestCheckFinite": 0.002, "TestCopy": 0.005666666666666667, "TestCorrCoef": 0.024666666666666667, "TestCov": 0.047333333333333345, "TestCumprod": 0.024000000000000004, "TestCumsum": 0.03, "TestDelete": 0.015666666666666666, "TestDiff": 0.312, "TestDigitize": 0.011333333333333336, "TestExtins": 0.004333333333333334, "TestFilterwindows": 0.44133333333333363, "TestFlip": 0.02366666666666667, "TestGradient": 0.109, "TestInsert": 0.007, "TestInterp": 0.08333333333333336, "TestKaiser": 0.008333333333333333, "TestMedian": 0.08133333333333335, "TestMeshgrid": 0.04133333333333334, "TestMsort": 0.0, "TestPercentile": 0.048666666666666684, "TestPiecewise": 0.008, "TestProd": 0.022333333333333334, "TestPtp": 0.007, "TestQuantile": 0.012333333333333335, "TestRot90": 0.387, "TestSelect": 0.006000000000000001, "TestSinc": 0.006666666666666667, "TestSortComplex": 0.007333333333333333, "TestTrapz": 0.004, "TestTrimZeros": 0.008, "TestUnique": 0.0030000000000000005, "Test_I0": 0.011000000000000001}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.546, "TestHistogramOptimBinNums": 0.018333333333333344, "TestHistogramdd": 2.559333333333333}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006000000000000001, "TestDiagIndices": 0.0036666666666666666, "TestDiagIndicesFrom": 0.005333333333333333, "TestFillDiagonal": 0.018333333333333333, "TestGrid": 0.007, "TestIndexExpression": 0.007333333333333333, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.236}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.01, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.11800000000000001, "TestColumnStack": 0.006500000000000001, "TestDsplit": 0.0075, "TestDstack": 0.011000000000000001, "TestExpandDims": 0.005, "TestHsplit": 0.009000000000000001, "TestKron": 0.0085, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.0075, "TestSplit": 0.0045000000000000005, "TestSqueeze": 0.04750000000000001, "TestTakeAlongAxis": 0.34099999999999997, "TestTile": 0.0605, "TestVsplit": 0.006500000000000001}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.11633333333333334, "TestEye": 0.25833333333333336, "TestFliplr": 0.004, "TestFlipud": 0.0036666666666666666, "TestHistogram2d": 0.050666666666666665, "TestTri": 0.5850000000000001, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.0023333333333333335, "TestTriuIndicesFrom": 0.001, "TestVander": 0.013999999999999999}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.24766666666666667, "TestImag": 0.008666666666666668, "TestIscomplex": 0.0033333333333333335, "TestIscomplexobj": 0.0030000000000000005, "TestIsfinite": 0.007, "TestIsinf": 0.006000000000000001, "TestIsnan": 0.007, "TestIsneginf": 0.0013333333333333333, "TestIsposinf": 0.0016666666666666668, "TestIsreal": 0.005666666666666667, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.0030000000000000005, "TestNanToNum": 0.009666666666666667, "TestReal": 0.009666666666666667, "TestRealIfClose": 0.0030000000000000005}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.48433333333333334, "TestCond": 0.15433333333333335, "TestDet": 0.10566666666666667, "TestEig": 0.023333333333333334, "TestEigh": 0.017666666666666667, "TestEighCases": 0.0, "TestEigvals": 0.03833333333333334, "TestEigvalsh": 0.015666666666666666, "TestEigvalshCases": 0.0, "TestInv": 0.034, "TestLstsq": 0.23966666666666667, "TestMatrixRank": 0.257, "TestMisc": 0.022333333333333334, "TestMisc2": 0.016333333333333335, "TestMultiDot": 0.07733333333333335, "TestNormDouble": 0.5636666666666668, "TestNormInt64": 0.5653333333333334, "TestNormSingle": 0.5806666666666667, "TestNorm_NonSystematic": 0.0026666666666666666, "TestPinv": 0.07600000000000001, "TestPinvHermitian": 0.02666666666666667, "TestQR": 0.7976666666666666, "TestSVD": 0.03266666666666667, "TestSVDHermitian": 0.06833333333333334, "TestSolve": 0.26033333333333336, "TestTensorinv": 0.012000000000000002, "TestTensorsolve": 0.002}, "torch_np/test_basic": {"TestArrayToSequence": 0.006000000000000001, "TestCopyTo": 0.102, "TestCtorNested": 0.0023333333333333335, "TestDefaultDtype": 0.004333333333333334, "TestDivmod": 0.01066666666666667, "TestExport": 0.0, "TestMisc": 13.459000000000001, "TestNormalizations": 0.0036666666666666666, "TestOneArr": 0.24266666666666684, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.0033333333333333335, "TestOneArrToScalar": 0.009666666666666669, "TestPythonArgsToArray": 0.024666666666666667, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.2930000000000001}, "torch_np/test_dtype": {"TestConvertDType": 0.25433333333333336}, "torch_np/test_function_base": {"TestAppend": 0.3419999999999999}, "torch_np/test_ndarray_methods": {"TestAmax": 0.005333333333333333, "TestAmin": 0.005333333333333333, "TestArgmax": 0.7213333333333338, "TestArgmaxArgminCommon": 0.03500000000000001, "TestArgmin": 0.7783333333333339, "TestContains": 0.001, "TestIndexing": 0.21533333333333335, "TestIter": 0.0033333333333333335, "TestNoExtraMethods": 0.006000000000000001, "TestNonzero": 0.10266666666666667, "TestRavel": 0.004666666666666667, "TestReshape": 0.0033333333333333335, "TestTranspose": 0.09933333333333334}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.0115, "TestNEP50Table": 0.0}, "torch_np/test_random": {"TestChoice": 0.008333333333333333, "TestNumpyGlobal": 0.0030000000000000005, "TestScalarReturn": 0.24700000000000003, "TestShuffle": 0.009000000000000001}, "torch_np/test_reductions": {"TestAll": 0.008333333333333333, "TestAny": 0.009333333333333334, "TestFlatnonzero": 0.18133333333333335, "TestGenericCumSumProd": 0.014333333333333335, "TestGenericReductions": 1.6359999999999666, "TestMean": 0.054, "TestSum": 0.15566666666666665}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.23900000000000002, "TestIsScalar": 0.11566666666666668}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.37133333333333357, "TestNdarrayDunderVsUfunc": 0.25333333333333347, "TestUfuncDtypeKwd": 0.0036666666666666666, "TestUnaryUfuncs": 0.26066666666666666}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.3010000000000001}}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": {"TestFullyShardAutograd": 83.28999999999999}, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize2": 29.235, "TestClipGradNormWorldSize4": 6.037000000000001}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 29.8885, "TestFullyShardCollectiveOps": 78.04050000000001, "TestFullyShardCommunication": 54.29, "TestFullyShardUnshardMultiProcess": 27.3285, "TestFullyShardUnshardMultiThread": 0.0345}, "distributed/_composable/fsdp/test_fully_shard_compile": {"TestFullyShardCompileCompute": 31.781}, "distributed/_composable/fsdp/test_fully_shard_extensions": {"TestFullyShardAllGatherExtensionsMultiProcess": 30.9485, "TestFullyShardAllGatherExtensionsMultiThread": 21.4475}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 86.739}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.1825, "TestFullyShardDeviceTensor": 0.3985, "TestFullyShardHSDPBroadcast": 0.675, "TestFullyShardLazyInit": 0.08349999999999999, "TestFullyShardManagedModulesAndStates": 0.048, "TestFullyShardMeshArg": 0.0125, "TestFullyShardMetaDeviceInit": 25.749499999999998, "TestFullyShardParamModuleInfos": 0.0215, "TestFullyShardProcessGroupInit": 1.0939999999999999, "TestFullyShardShardedParameterDTensor": 0.1065, "TestFullyShardShardedParameterTensor": 0.089}, "distributed/_composable/fsdp/test_fully_shard_memory": {"TestFullyShardMemory": 32.735}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionCasts": 68.38550000000001, "TestFullyShardMixedPrecisionTraining": 86.3835}, "distributed/_composable/fsdp/test_fully_shard_overlap": {"TestFullyShardOverlap": 0.309}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.43200000000000005}, "distributed/_composable/fsdp/test_fully_shard_state_dict": {"TestFullyShardStateDictMultiProcess": 61.5445, "TestFullyShardStateDictMultiThread": 0.5535}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 0.003, "TestFullyShard1DTrainingCore": 314.77599999999995, "TestFullyShard2DTraining": 6.385999999999999, "TestFullyShardCastAfterInit": 0.754, "TestFullyShardCustomForwardMethod": 35.69, "TestFullyShardForwardInputs": 0.43699999999999994, "TestFullyShardGradientAccumulation": 65.08099999999999, "TestFullyShardHSDPTraining": 0.003, "TestFullyShardNDTraining": 6.3765, "TestFullyShardRegisteredParams": 20.6605, "TestFullyShardSharedParams": 28.9825, "test_fully_shard_training": 0.0}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 106.08350000000002}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 57.235499999999995}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 26.7385}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 27.8285}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 53.763999999999996}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 58.675999999999995}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 6.357}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 20.621499999999997}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 200.49849999999998}, "distributed/_composable/test_contract": {"TestContract": 0.3325}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 10.0445, "ReplicateTest": 96.4245}, "distributed/_composable/test_replicate_with_compiler": {"DDP_TP_Test": 4.538, "ReplicateTest": 95.86}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 24.000499999999995}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.3215}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 14.992, "TestShardingSpec": 0.037500000000000006}, "distributed/_shard/test_sharder": {"TestCustomSharder": 9.7455}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 19.0925}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.556}, "distributed/_tensor/experimental/test_local_map": {"TestLocalMap": 106.23949999999999}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 53.6465}, "distributed/_tensor/test_api": {"DTensorAPITest": 40.4185}, "distributed/_tensor/test_attention": {"RingAttentionTest": 5.370000000000002}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 49.972}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 42.286500000000004}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 43.867, "DTensorTest": 116.383, "TestDTensorPlacementTypes": 4.364}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 36.55499999999999, "TestDTensorCompileE2E": 25.616}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 18.887}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 18.583}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 29.9745, "DTensorInitOpsTest": 6.289}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 65.48949999999999}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 174.31900000000002}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.134, "TestEinsumDims": 0.3045, "TestEinsumStrategies": 0.08700000000000001}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 271.46750000000003}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.9440000000000001}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 6.297, "DistTensorRandomOpTest": 33.2785}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 6.660500000000001, "RedistributeTest": 49.473000000000006}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 365.971}, "distributed/_tensor/test_utils": {"Test2DStridedLocalShard": 9.8855, "UtilTest": 19.0505}, "distributed/_tensor/test_view_ops": {"TestViewOps": 31.244}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.308}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 26.4045}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 57.650999999999996}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 60.94699999999999}, "distributed/algorithms/test_join": {"TestJoin": 45.741}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ESaveAndLoad": 56.88249999999999, "TestNoCPU": 6.042}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 4.8885}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 4.889}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 6.302}, "distributed/checkpoint/fsdp/test_fsdp_dsd": {"TestFullyShardWithDistributedStateDict": 33.324}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 12.1985, "TestDistributedFailure": 28.882499999999997}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.6535}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.3155}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 6.7135}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 27.1965, "TestDTensorReshardPlacementChange": 11.331}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 25.8575, "TestDistributedStateDictSaveLoad": 0.654, "TestDistributedStateDictSaveLoadWithSharedTensor": 6.3495}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 39.506, "TestDistributedStateDictSaveLoad": 0.6585, "TestDistributedStateDictSaveLoadWithSharedTensor": 9.679499999999999}, "distributed/checkpoint/test_format_utils": {"TestFormatUtils": 16.662}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 31.666}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 52.908}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 27.1855}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.6585, "TestFSSpecWithDist": 33.269}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 19.049500000000002}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.3225}, "distributed/checkpoint/test_planner": {"TestLoadPlanner": 0.34450000000000003, "TestPlannerHelpers": 0.0015, "TestSavePlan": 0.333}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 4.8415}, "distributed/checkpoint/test_state_dict": {"TestNoComm": 5.5255, "TestStateDict": 330.59799999999996}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 24.894}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 33.718}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.321}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.3255}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.33, "RdzvEventLibTest": 0.0975}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.324}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.3295, "StartProcessesListTest": 26.48, "StartProcessesTest": 20.3085, "StdTest": 0.0045000000000000005}, "distributed/elastic/test_control_plane": {"WorkerServerTest": 5.9505}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 17.188499999999998}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.20700000000000002, "LocalTimerTest": 4.875000000000001, "MultiprocessingRequestQueueTest": 2.188}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 3.4189999999999996}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.34650000000000003}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.337, "UtilTest": 0.0945}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 19.494}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.3135}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 19.642500000000002}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 27.8435}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 423.69250000000005, "TestFSDPCheckpointSubmodule": 25.924}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 129.493}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 213.373, "TestExplicitUnshard": 53.0515}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 478.46900000000016}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 27.5715, "TestHooks": 190.16950000000003, "TestNoGrad": 54.0495, "TestParamInit": 53.546499999999995, "TestParityWithDDP": 2362.3385}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 381.03450000000004}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 211.1605}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 122.4355}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 123.30350000000001}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 868.0690000000001}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.3335}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 149.86700000000002}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 84.208}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 265.69249999999994}, "distributed/fsdp/test_fsdp_input": {"TestInput": 51.0335}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 66.8905}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 169.26900000000003}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 248.569, "TestFSDPMiscMultiThread": 1.1840000000000002, "TestFSDPMiscWorldSize1": 19.376}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 158.575, "TestFSDPMixedPrecisionIgnoredModules": 25.359, "TestFSDPMixedPrecisionSharded": 1264.4139999999998, "TestFSDPMixedPrecisionUnsharded": 76.4845, "TestFSDPTrainEval": 28.872}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 26.889}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 26.336999999999996}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 1532.8085}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 31.399, "TestForwardOverlapWorldSizeTwo": 45.9}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 52.5685}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.7515000000000001, "TestShardedGradScalerParityWithDDP": 478.44000000000005}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 2078.8085, "TestFSDPStateDict4GPUs": 5.895}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 18.093}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 6.304}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 26.3925}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 98.8365, "TestUnshardParamsErrors": 44.095, "TestUnshardParamsNoShard": 12.0545}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 26.624000000000002, "TestFSDPUseOrigParamsInit": 6.335, "TestFSDPUseOrigParamsMultipleParamGroups": 372.0695, "TestFSDPUseOrigParamsNoSync": 53.335499999999996, "TestFSDPUseOrigParamsParamAccess": 26.872, "TestFSDPUseOrigParamsUnshardReshard": 115.1625, "TestFSDPUseOrigParamsWriteback": 92.66449999999999, "TestMultiTensorApply": 0.042499999999999996}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 36.805499999999995}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 6.346499999999999, "TestShardUtilsDistributedDTensor": 5.9945}, "distributed/fsdp/test_utils": {"TestUtils": 0.654}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 23.837000000000003, "TestFSDPWrap": 389.16949999999997, "TestWrapUtils": 0.013499999999999998}, "distributed/launcher/test_run": {"ElasticLaunchTest": 56.51049999999999}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.3345}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 308.1094999999999, "TestZeroRedundancyOptimizerSingleRank": 37.696000000000005}, "distributed/pipeline/sync/skip/test_api": {"test_api": 0.015}, "distributed/pipeline/sync/skip/test_gpipe": {"test_gpipe": 9.348}, "distributed/pipeline/sync/skip/test_inspect_skip_layout": {"test_inspect_skip_layout": 0.021}, "distributed/pipeline/sync/skip/test_leak": {"test_leak": 1.2210000000000005}, "distributed/pipeline/sync/skip/test_portal": {"TestTensorLife": 0.018000000000000002, "test_portal": 0.741}, "distributed/pipeline/sync/skip/test_stash_pop": {"test_stash_pop": 0.027000000000000003}, "distributed/pipeline/sync/skip/test_tracker": {"test_tracker": 0.879}, "distributed/pipeline/sync/skip/test_verify_skippables": {"test_verify_skippables": 0.030000000000000006}, "distributed/pipeline/sync/test_balance": {"test_balance": 18.534}, "distributed/pipeline/sync/test_bugs": {"test_bugs": 6.918}, "distributed/pipeline/sync/test_checkpoint": {"test_checkpoint": 2.0100000000000002}, "distributed/pipeline/sync/test_copy": {"test_copy": 3.2729999999999997}, "distributed/pipeline/sync/test_deferred_batch_norm": {"test_deferred_batch_norm": 3.819}, "distributed/pipeline/sync/test_dependency": {"test_dependency": 0.747}, "distributed/pipeline/sync/test_inplace": {"test_inplace": 0.303}, "distributed/pipeline/sync/test_microbatch": {"test_microbatch": 0.03300000000000001}, "distributed/pipeline/sync/test_phony": {"test_phony": 0.018000000000000002}, "distributed/pipeline/sync/test_pipe": {"test_pipe": 7.748999999999997}, "distributed/pipeline/sync/test_pipeline": {"test_pipeline": 0.006}, "distributed/pipeline/sync/test_stream": {"TestCurrentStream": 0.006, "TestDefaultStream": 0.0, "TestGetDevice": 0.0, "TestNewStream": 0.08100000000000002, "TestRecordStream": 2.085, "TestUseDevice": 0.003, "TestUseStream": 0.003, "TestWaitStream": 2.7569999999999997}, "distributed/pipeline/sync/test_transparency": {"test_transparency": 0.873}, "distributed/pipeline/sync/test_worker": {"test_worker": 0.03300000000000001}, "distributed/pipelining/test_backward": {"StageBackwardTests": 0.374}, "distributed/pipelining/test_chunkspec": {"ChunkSpecTests": 1.08}, "distributed/pipelining/test_microbatch": {"MicrobatchTests": 0.7555000000000001}, "distributed/pipelining/test_pipe": {"PipeTests": 1.3384999999999998}, "distributed/pipelining/test_schedule": {"ScheduleTest": 45.88099999999999, "TestSchedulePlan": 0.87}, "distributed/pipelining/test_stage": {"StageTest": 42.6065}, "distributed/pipelining/test_stage_backward": {"StageBackwardTests": 0.216}, "distributed/pipelining/test_transformer": {"TransformerTests": 1.0150000000000001}, "distributed/pipelining/test_unflatten": {"UnflattenTests": 1.1905000000000001}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 4.885}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 32.54, "TestNew2dParallelTraining": 23.759}, "distributed/tensor/parallel/test_micro_pipeline_tp": {"MicroPipelineTPTest": 33.3955, "test_micro_pipeline_tp": 0.0}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 49.308499999999995}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 113.57600000000001}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 4.786}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 137.058}, "distributed/test_c10d_common": {"CommTest": 4.6505, "ComputeBucketAssignmentTest": 1.269, "LocalRankTest": 19.448999999999998, "ProcessGroupWithDispatchedCollectivesTests": 9.296, "PythonProcessGroupExtensionTest": 39.2315, "ReduceOpTest": 1.278, "TimeoutTest": 46.8705}, "distributed/test_c10d_functional_native": {"CompileTest": 171.252, "TestWithNCCL": 67.689}, "distributed/test_c10d_gloo": {"CommTest": 54.92100000000001, "CompilerTest": 58.58, "DistributedDataParallelTest": 603.6780000000001, "GlooProcessGroupWithDispatchedCollectivesTests": 32.314, "LargeCommTest": 15.2455, "ProcessGroupGlooTest": 272.67600000000004, "ReducerTest": 0.597, "RendezvousEnvTest": 0.35150000000000003, "TimeoutTest": 4.890499999999999}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 24.031999999999996}, "distributed/test_c10d_nccl": {"CommTest": 101.366, "CompilerTest": 80.1045, "DistributedDataParallelTest": 1130.377, "LargeCommTest": 73.6995, "NCCLTraceTest": 143.02700000000002, "NCCLTraceTestDumpOnTimeout": 15.59, "NCCLTraceTestTimeoutDumpOnStuckRanks": 8.6075, "NcclErrorDumpTest": 0.012, "NcclErrorHandlingTest": 34.144999999999996, "NcclProcessGroupWithDispatchedCollectivesTests": 40.956, "ProcessGroupNCCLGroupTest": 122.1395, "ProcessGroupNCCLNoGPUTest": 0.0015, "ProcessGroupNCCLTest": 273.624, "RendezvousEnvTest": 0.049, "SparseCollective": 25.5805, "TimeoutTest": 4.539, "WorkHookTest": 52.375}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 58.517}, "distributed/test_c10d_ops_nccl": {"ProcessGroupNCCLOpTest": 7.565999999999998}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 397.1745000000001, "TestDDPWithWorkWrapper": 396.90849999999995}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 43.695, "ProcessGroupShareTensorTest": 23.247, "TestDistributedNNFunctionsGloo": 43.3705}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 27.648000000000003, "TestDistributedNNFunctionsNccl": 49.2505}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.0045000000000000005, "TestDistributedNNFunctionsUcc": 0.009000000000000001}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 4.793999999999999}, "distributed/test_control_collectives": {"TestCollectives": 0.3835}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 27.735999999999997}, "distributed/test_data_parallel": {"TestDataParallel": 43.135999999999996, "TestDataParallelDeviceTypeCUDA": 0.10650000000000004}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 31.543, "DeviceMeshTest": 61.37100000000001, "DeviceMeshTestNDim": 27.6265, "InitDeviceMeshTest": 16.057000000000002, "TestDeviceMeshGetItem": 32.216499999999996, "TestMeshEnv": 23.9785}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 9307.648000000045}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 15.5185, "TestMultiProc": 170.44199999999998, "TestSingleProc": 44.927}, "distributed/test_fake_pg": {"TestFakePG": 19.476}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 40.885, "TestExpand": 0.37450000000000006, "TestFunctionalAutograd": 13.0, "TestFunctionalAutogradWithNCCL": 5.8975, "TestGradCollectives": 0.006, "TestMakeFx": 0.0565, "TestMetaCollectives": 0.0025, "TestNCCLCollectivesWithWorldSize4": 32.400499999999994, "TestPgTag": 0.051000000000000004, "TestTraceableCollectives": 0.18850000000000006}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 5.632, "TestCollectivesMultiProc": 258.91150000000005}, "distributed/test_launcher": {"TestDistributedLaunch": 1.941}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.5730000000000001, "TestCollectivesWithWrapper": 0.4035}, "distributed/test_nccl": {"TestNCCLCUDA": 0.661}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 46.1295, "ProcessGroupNCCLWrapperTest": 52.804}, "distributed/test_store": {"FileStoreTest": 4.548, "HashStoreTest": 2.513, "InitPgWithNonUvStore": 0.758, "InitPgWithUvStore": 0.531, "LibUvTCPStoreTest": 13.196500000000002, "PrefixFileStoreTest": 3.6679999999999997, "PrefixStoreTest": 0.006, "PrefixTCPStoreTest": 2.9234999999999998, "PythonStoreTest": 0.34950000000000003, "RendezvousEnvTest": 0.36, "RendezvousFileTest": 0.7585, "RendezvousTCPTest": 32.24100000000001, "RendezvousTest": 0.7170000000000001, "TCPStoreTest": 13.133500000000002, "TestMultiThreadedWait": 2.577, "TestPythonStore": 2.532, "TimeoutTest": 7.8740000000000006}}, "slow": {"backends/xeon/test_launch": {"TestTorchrun": 1.918}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 390.81199999999984}, "distributions/test_constraints": {"test_constraints": 0.8880000000000002}, "distributions/test_distributions": {"TestAgainstScipy": 0.004, "TestConstraints": 0.002, "TestDistributionShapes": 0.04300000000000003, "TestDistributions": 0.1370000000000001, "TestFunctors": 0.004, "TestJit": 0.008, "TestKL": 0.013000000000000005, "TestLazyLogitsInitialization": 0.002, "TestNumericalStability": 0.010000000000000002, "TestRsample": 0.007, "TestValidation": 0.004}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.499}, "dynamo/test_after_aot": {"TestAfterAot": 0.228}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 0.274}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.267}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 0.5770000000000001}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.001, "TestCustomBackendAPI": 0.003, "TestExplainWithBackend": 0.001, "TestOptimizations": 0.24000000000000002}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 0.244}, "dynamo/test_base_output": {"TestBaseOutput": 0.004}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 0.211}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 0.001, "BytecodeTests": 0.246}, "dynamo/test_compile": {"InPlaceCompilationTests": 0.248, "PublicTorchCompilerTests": 0.001}, "dynamo/test_comptime": {"ComptimeTests": 0.249}, "dynamo/test_config": {"ConfigTests": 0.246}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.003, "CppGuardManagerFuncTorchHigherOrderOpTests": 0.07400000000000005, "CppGuardManagerFunctionTests": 0.4210000000000002, "CppGuardManagerHigherOrderOpTests": 0.09700000000000007, "CppGuardManagerMiscTests": 0.46100000000000035, "CppGuardManagerReproTests": 0.21300000000000016}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.054000000000000034}, "dynamo/test_cudagraphs": {"TestAotCudagraphs": 0.28500000000000003}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.243}, "dynamo/test_decorators": {"DecoratorTests": 0.259}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.002, "TestDeviceGuard": 0.009999999999999998}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 0.03200000000000002, "DynamicShapesCtxManagerTests": 0.06200000000000003, "DynamicShapesExportTests": 2613.8890000000224, "DynamicShapesFuncTorchHigherOrderOpTests": 0.09500000000000006, "DynamicShapesFunctionTests": 0.3060000000000002, "DynamicShapesHigherOrderOpTests": 0.11200000000000009, "DynamicShapesMiscTests": 0.47100000000000036, "DynamicShapesNNModuleTests": 0.07900000000000006, "DynamicShapesReproTests": 0.2960000000000002, "DynamicShapesSubGraphTests": 0.04400000000000003, "DynamicShapesTestSDPA": 0.017}, "dynamo/test_exc": {"ExcTests": 0.011}, "dynamo/test_exceptions": {"ExceptionTests": 0.244}, "dynamo/test_export": {"ExportTests": 0.18800000000000014}, "dynamo/test_export_mutations": {"MutationExportTests": 0.305}, "dynamo/test_frame_init": {"FrameInitTests": 0.247}, "dynamo/test_functions": {"DefaultsTests": 0.02000000000000001, "FunctionTests": 0.5140000000000002}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.24}, "dynamo/test_global": {"TestGlobals": 0.24000000000000002}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.272}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.010000000000000002, "FuncTorchHigherOrderOpTests": 0.07700000000000005, "HigherOrderOpTests": 0.3780000000000001, "HigherOrderOpVmapGuardTests": 0.013000000000000001}, "dynamo/test_hooks": {"HooksTests": 0.276}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 0.03200000000000002, "InlineInbuiltNNModulesExportTests": 0.18100000000000013, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 0.07400000000000005, "InlineInbuiltNNModulesFunctionTests": 0.2900000000000002, "InlineInbuiltNNModulesHigherOrderOpTests": 0.09800000000000007, "InlineInbuiltNNModulesMiscTests": 0.46400000000000036, "InlineInbuiltNNModulesNNModuleTests": 0.07500000000000005}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 0.255}, "dynamo/test_interop": {"InteropTests": 0.247}, "dynamo/test_logging": {"LoggingTests": 0.335}, "dynamo/test_minifier": {"MinifierTests": 0.321}, "dynamo/test_misc": {"MiscTests": 0.7090000000000005, "TestTracer": 0.001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.003}, "dynamo/test_modules": {"NNModuleTests": 0.30300000000000005, "OptimizedModuleTest": 0.03800000000000003}, "dynamo/test_nops": {"NopTests": 0.215}, "dynamo/test_optimizers": {"End2EndTests": 0.249}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.23}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.251}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.289}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.251}, "dynamo/test_recompiles": {"RecompileTests": 0.22}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.251}, "dynamo/test_repros": {"ReproTests": 0.4510000000000003}, "dynamo/test_resume": {"ResumeFunctionTests": 0.258}, "dynamo/test_sdpa": {"TestSDPA": 0.245}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.245}, "dynamo/test_sources": {"SourceTests": 0.256}, "dynamo/test_structured_trace": {"StructuredTraceTest": 0.28900000000000003}, "dynamo/test_subclasses": {"SubclassTests": 0.546, "TestNestedTensor": 0.041000000000000016}, "dynamo/test_subgraphs": {"SubGraphTests": 0.28200000000000003}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.001, "TraceRuleTests": 0.249}, "dynamo/test_unspec": {"UnspecTests": 0.277}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.357}, "dynamo/test_view": {"ViewTests": 0.249}, "export/test_converter": {"TestConverter": 0.277}, "export/test_db": {"ExampleTests": 0.34500000000000003}, "export/test_experimental": {"TestExperiment": 0.259}, "export/test_export": {"TestDynamismExpression": 0.005, "TestExport": 0.1540000000000001, "TestExportCustomClass": 0.275, "TestOneOffModelExportResult": 0.012000000000000004}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.005, "NonStrictExportTestExport": 0.1510000000000001}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.004, "PreDispatchExportTestExport": 0.1410000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.242}, "export/test_hop": {"TestHOPCUDA": 0.02000000000000001, "TestHOPGeneric": 0.001}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.001, "TestLift": 0.09899999999999999}, "export/test_pass_infra": {"TestPassInfra": 0.247}, "export/test_passes": {"TestPasses": 0.262}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.005, "RetraceExportTestExport": 0.1510000000000001}, "export/test_safeguard": {"TestSafeguard": 0.301}, "export/test_schema": {"TestSchema": 0.25}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.004, "SerDesExportPreDispatchTestExport": 0.1410000000000001, "SerDesExportTestDynamismExpression": 0.005, "SerDesExportTestExport": 0.1510000000000001}, "export/test_serialize": {"TestDeserialize": 0.05500000000000004, "TestOpVersioning": 0.003, "TestSaveLoad": 0.006, "TestSchemaVersioning": 0.001, "TestSerialize": 0.259, "TestSerializeCustomClass": 0.002}, "export/test_sparse": {"TestSparseProp": 0.3870000000000001}, "export/test_tools": {"TestExportTools": 0.229}, "export/test_torchbind": {"TestCompileTorchbind": 0.9020000000000001, "TestExportTorchbind": 1.5039999999999991, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.246}, "export/test_unflatten": {"TestUnflatten": 0.253}, "export/test_upgrade": {"TestUpgrade": 0.281}, "export/test_verifier": {"TestVerifier": 0.226}, "functorch/test_aotdispatch": {"TestAOTAutograd": 0.11900000000000009, "TestAOTAutogradWithDynamo": 0.11900000000000009, "TestAOTDispatch": 0.009000000000000001, "TestAOTExport": 0.02900000000000002, "TestAOTModuleSimplified": 0.007, "TestPartitioning": 0.011000000000000003}, "functorch/test_control_flow": {"TestControlFlow": 0.184, "TestControlFlowTraced": 0.21900000000000017}, "functorch/test_dims": {"TestMin": 0.25, "TestMinFunctorchOnly": 0.03400000000000002}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.02900000000000002, "TestAutogradFunctionVmapAPICUDA": 0.009000000000000001, "TestCompileTransformsCUDA": 0.002, "TestComposabilityCUDA": 0.04500000000000003, "TestExamplesCorrectnessCUDA": 0.02000000000000001, "TestFunctionalizeCUDA": 0.01800000000000001, "TestGradTransformCUDA": 0.06300000000000004, "TestHelpersCUDA": 0.005, "TestHessianCUDA": 0.004, "TestHigherOrderOperatorInteractionCUDA": 0.009000000000000001, "TestJacCUDA": 0.08200000000000006, "TestJvpCUDA": 0.022000000000000013, "TestLinearizeCUDA": 0.005, "TestMakeFunctional": 0.02000000000000001, "TestSliceArgnums": 0.009000000000000001, "TestVmapJvpInplaceViewCUDA": 0.005, "TestVmapOfGradCUDA": 0.007}, "functorch/test_logging": {"TestAOTLogging": 0.262}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.005, "RandomOpTestCase": 0.001, "ReduceTestCase": 0.009000000000000001, "TestMemoryEfficientOpAuthoring": 0.216}, "functorch/test_minifier": {"TestMinifier": 0.224}, "functorch/test_ops": {"TestOperatorsCUDA": 911.2139999999466}, "functorch/test_parsing": {"TestAnonymousAxis": 0.27, "TestParsedExpression": 0.003, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.262}, "functorch/test_vmap": {"TestRandomnessCUDA": 0.2710000000000002, "TestTransformFailureCUDA": 0.007, "TestVmapAPI": 0.06400000000000004, "TestVmapBatchedGradientCUDA": 0.03100000000000002, "TestVmapDeviceTypeCUDA": 0.005, "TestVmapNestedTensorCUDA": 0.013000000000000005, "TestVmapOperators": 0.16500000000000012, "TestVmapOperatorsOpInfoCUDA": 19.1930000000014}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 1.8569999999999074}, "higher_order_ops/test_with_effects": {"TestWithEffects": 6.032000000000001}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 0.12800000000000009, "AOTInductorTestABICompatibleCpuWithStackAllocation": 0.10300000000000008, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 0.07200000000000005, "AOTInductorTestABICompatibleCuda": 0.11300000000000009, "AOTInductorTestNonABICompatibleCpu": 0.1340000000000001, "AOTInductorTestNonABICompatibleCuda": 67.80700000000044}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 0.006, "BenchmarkFusionCudaTest": 0.007, "BenchmarkMultiTemplateFusionCudaTest": 0.003}, "inductor/test_binary_folding": {"FreezingCpuTests": 0.002, "FreezingCudaTests": 0.002}, "inductor/test_codecache": {"TestFxGraphCache": 0.04700000000000003, "TestFxGraphCacheHashing": 0.005, "TestUtils": 0.001, "test_codecache": 21.219}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.131}, "inductor/test_compile_worker": {"TestCompileWorker": 0.123}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 0.32700000000000023, "TestCompiledAutograd": 0.06200000000000005, "TestCustomOpWithCompiledAutograd": 0.08900000000000007}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCUDA": 140.48000000000005, "CompiledOptimizerTests": 0.5310000000000004}, "inductor/test_config": {"TestInductorConfig": 0.16}, "inductor/test_control_flow": {"CondTests": 0.18000000000000002, "WhileLoopTests": 0.01800000000000001}, "inductor/test_coordinate_descent_tuner": {"TestCoordinateDescentTuner": 0.228}, "inductor/test_cpu_repro": {"CPUReproTests": 1160.281999999997}, "inductor/test_cuda_cpp_wrapper": {"DynamicShapesCudaWrapperCudaTests": 0.035000000000000024, "TestCudaWrapper": 0.03800000000000003}, "inductor/test_cuda_repro": {"CudaReproTests": 0.05100000000000004}, "inductor/test_cudagraph_trees": {"CudaGraphTreeTests": 0.08400000000000006}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.14100000000000001}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 0.171}, "inductor/test_debug_trace": {"TestDebugTrace": 0.002}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.269}, "inductor/test_dependencies": {"TestDependencies": 0.155}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 0.139}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 681.602, "EfficientConvBNEvalCudaTests": 352.474}, "inductor/test_extension_backend": {"ExtensionBackendTests": 24.863}, "inductor/test_flex_attention": {"TestFlexAttention": 0.003, "TestTemplatedSDPA": 0.006}, "inductor/test_foreach": {"ForeachTests": 0.19800000000000015}, "inductor/test_fp8": {"TestFP8Types": 0.011000000000000003}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 0.01900000000000001, "SDPAPatternRewriterCpuTests": 0.01900000000000001, "SDPAPatternRewriterCudaDynamicTests": 0.025000000000000015, "SDPAPatternRewriterCudaTests": 0.034000000000000016}, "inductor/test_fx_fusion": {"TestFxFusion": 0.152}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.011}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.002, "TestGroupBatchFusion": 103.14600000000002, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.009000000000000001, "TestIndexingSimplification": 0.138}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 0.022000000000000013, "FreezingCudaTests": 0.022000000000000013}, "inductor/test_inplacing_pass": {"TestReinplacingPassCorrectness": 0.227}, "inductor/test_kernel_benchmark": {"TestKernelBenchmark": 0.016000000000000007}, "inductor/test_layout_optim": {"TestLayoutOptim": 0.03600000000000001}, "inductor/test_loop_ordering": {"LoopOrderingTest": 0.224}, "inductor/test_max_autotune": {"TestMaxAutotune": 0.16700000000000004, "TestTuningProcess": 0.002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.218}, "inductor/test_metrics": {"TestMetrics": 0.006}, "inductor/test_minifier": {"MinifierTests": 0.226}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 0.221}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 0.010000000000000002, "TestPatternMatcher": 0.21800000000000005}, "inductor/test_mmdecomp": {"TestDecompCUDA": 0.026000000000000016}, "inductor/test_move_constructors_to_cuda": {"TestMoveConstructorsToCuda": 0.017000000000000005}, "inductor/test_multi_kernel": {"MultiKernelTest": 0.23900000000000002}, "inductor/test_pad_mm": {"PadMMTest": 0.157}, "inductor/test_padding": {"PaddingTest": 0.154, "PerfTestBetweenGoodAndBadShape": 0.002, "PerfTestWithAndWithoutPadding": 0.156}, "inductor/test_pattern_matcher": {"TestPatternMatcher": 0.04000000000000002}, "inductor/test_perf": {"FusionTests": 0.01800000000000001, "InplacingTests": 0.009000000000000001, "MinCutPartitioningTests": 0.009000000000000001, "NoopTests": 0.006, "NumBytesMetricTests": 0.157, "SchedulerFusionTests": 0.004, "TilingTests": 0.002}, "inductor/test_profiler": {"DynamoProfilerTests": 0.221}, "inductor/test_select_algorithm": {"TestSelectAlgorithm": 0.164}, "inductor/test_smoke": {"SmokeTest": 0.223}, "inductor/test_snode_runtime": {"ComputeBoundedTests": 0.007, "MemoryBoundedTests": 0.004, "TestCommAnalysis": 0.009000000000000001, "UnsupportedTests": 0.15}, "inductor/test_split_cat_fx_passes": {"TestSplitCatFxPasses": 0.14400000000000002}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 0.133}, "inductor/test_torchbind": {"TestTorchbind": 0.228}, "inductor/test_torchinductor": {"CpuTests": 162.1120000000019, "GPUTests": 109.11500000000201, "NanCheckerTest": 0.002, "RNNTest": 0.001, "SweepInputsCpuTest": 0.06500000000000004, "SweepInputsGPUTest": 0.06400000000000004, "TestFull": 0.001, "TritonCodeGenTests": 0.02300000000000001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 101.22400000000181, "DynamicShapesCodegenGPUTests": 103.30600000000186}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 177.61200000000224, "DynamicShapesGPUTests": 111.29500000000196, "TestInductorDynamicCUDA": 0.05100000000000004}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 25.729000000002365}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.003}, "inductor/test_triton_heuristics": {"TestTritonHeuristics": 0.21}, "inductor/test_triton_kernels": {"KernelTests": 0.3710000000000001, "MutationTests": 0.02900000000000002}, "inductor/test_triton_wrapper": {"TestTritonWrapper": 0.22}, "inductor/test_unbacked_symints": {"TestUnbackedSymintsCUDA": 0.010000000000000002}, "inductor/test_utils": {"TestUtils": 0.247}, "lazy/test_debug_util": {"DebugUtilTest": 0.276}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.25}, "lazy/test_generator": {"LazyGeneratorTest": 0.247}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.302}, "lazy/test_step_closures": {"ClosuresTest": 0.23500000000000001}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.002, "TestLazyTensor": 0.003}, "nn/test_convolution": {"TestConvolutionNN": 0.12500000000000003, "TestConvolutionNNDeviceTypeCUDA": 0.5460000000000004}, "nn/test_dropout": {"TestDropoutNN": 0.004, "TestDropoutNNDeviceTypeCUDA": 0.005}, "nn/test_embedding": {"TestEmbeddingNN": 0.022000000000000013, "TestEmbeddingNNDeviceTypeCUDA": 0.1310000000000001}, "nn/test_init": {"TestNNInit": 0.404}, "nn/test_lazy_modules": {"TestLazyModules": 0.06800000000000005}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.03200000000000002, "TestLoadStateDictSwap": 0.002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.007, "TestModuleHookNN": 0.016000000000000007, "TestModuleHooks": 0.02300000000000001, "TestStateDictHooks": 0.014000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 0.007, "TestMultiheadAttentionNNDeviceTypeCUDA": 0.012000000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.23500000000000001}, "nn/test_parametrization": {"TestNNParametrization": 0.057000000000000044, "TestNNParametrizationDeviceCUDA": 0.002}, "nn/test_pooling": {"TestAvgPool": 0.007, "TestPoolingNN": 0.014000000000000005, "TestPoolingNNDeviceTypeCUDA": 5.094000000000019}, "nn/test_pruning": {"TestPruningNN": 0.044000000000000025}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.018000000000000002}, "profiler/test_memory_profiler": {"TestDataFlow": 0.010000000000000002, "TestIdentifyGradients": 0.005, "TestMemoryProfiler": 0.25, "TestMemoryProfilerE2E": 0.017000000000000008}, "profiler/test_profiler": {"TestExperimentalUtils": 0.02000000000000001, "TestProfiler": 0.04100000000000003, "TestProfilerCUDA": 0.003, "TestProfilerITT": 0.001}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.32}, "profiler/test_record_function": {"TestRecordFunction": 0.279}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 0.276}, "test_ao_sparsity": {"TestActivationSparsifier": 0.001, "TestBaseDataScheduler": 0.004, "TestBaseDataSparsifier": 0.003, "TestBaseSparsifier": 0.009000000000000001, "TestBaseStructuredSparsifier": 0.01800000000000001, "TestComposability": 0.007, "TestCubicScheduler": 0.005, "TestFPGMPruner": 0.002, "TestFakeSparsity": 0.004, "TestFxComposability": 0.005, "TestNearlyDiagonalSparsifier": 0.005, "TestNormDataSparsifiers": 0.003, "TestQuantizationUtils": 0.002, "TestQuantizedSparseKernels": 0.174, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.002, "TestScheduler": 0.004, "TestSparsityUtilFunctions": 0.008, "TestWeightNormSparsifier": 0.006}, "test_autocast": {"TestAutocastCPU": 0.218, "TestAutocastGPU": 0.002, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.012000000000000004, "TestAutograd": 20.28900000000033, "TestAutogradComplex": 0.002, "TestAutogradDeviceTypeCUDA": 0.06400000000000004, "TestAutogradForwardMode": 0.02900000000000002, "TestAutogradForwardModeBatchedGrad": 0.005, "TestAutogradFunctional": 0.12500000000000008, "TestAutogradInferenceMode": 0.01900000000000001, "TestAutogradLogging": 0.003, "TestAutogradMultipleDispatchCUDA": 0.008, "TestMultithreadAutograd": 0.012000000000000004, "TestNestedCheckpoint": 0.014000000000000005}, "test_autograd_fallback": {"TestAutogradFallback": 0.23600000000000002}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 16.875999999998534}, "test_bundled_inputs": {"TestBundledInputs": 0.255}, "test_comparison_utils": {"TestComparisonUtils": 0.239}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCUDA": 0.016000000000000007}, "test_content_store": {"TestContentStoreCUDA": 0.005}, "test_cpp_api_parity": {"TestCppApiParity": 0.4900000000000004}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.016000000000000007, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.015000000000000006, "TestMAIATensor": 0.005, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 0.028000000000000018}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 25.143000000000022}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0}, "test_cuda": {"TestBlockStateAbsorption": 0.0, "TestCuda": 4.625000000000002, "TestCudaMallocAsync": 0.02000000000000001, "TestCudaOptimsCUDA": 0.013000000000000005}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 0.0, "TestCuda": 4.6110000000000335, "TestCudaMallocAsync": 0.02000000000000001, "TestCudaOptimsCUDA": 0.013000000000000005}, "test_cuda_multigpu": {"TestCudaComm": 0.013000000000000005, "TestCudaMultiGPU": 0.024}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.703}, "test_cuda_sanitizer": {"TestArgumentHandler": 0.225, "TestEventHandler": 0.017000000000000008, "TestMessages": 0.003}, "test_cuda_trace": {"TestCudaTrace": 1.9939999999999998}, "test_custom_ops": {"MiniOpTest": 0.06700000000000005, "MiniOpTestOther": 0.012000000000000004, "TestCustomOp": 0.08900000000000007, "TestCustomOpAPI": 0.02900000000000002, "TestCustomOpTestingCUDA": 0.028000000000000018, "TestGenerateOpcheckTests": 0.010000000000000002}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 136.048, "TestConcatDataset": 0.006, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.002, "TestDataLoader": 0.07000000000000005, "TestDataLoaderDeviceTypeCUDA": 0.003, "TestDataLoaderPersistentWorkers": 0.06800000000000005, "TestDatasetRandomSplit": 0.009000000000000001, "TestDictDataLoader": 0.004, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.001, "TestSetAffinity": 0.001, "TestStackDataset": 0.009000000000000001, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.005}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.001, "TestDataChunk": 0.007, "TestDataFramesPipes": 0.006, "TestFunctionalIterDataPipe": 0.01900000000000001, "TestFunctionalMapDataPipe": 0.009000000000000001, "TestGraph": 0.006, "TestIterDataPipeCountSampleYielded": 0.005, "TestIterDataPipeGraphFastForward": 0.005, "TestIterDataPipeSingletonConstraint": 0.005, "TestIterableDataPipeBasic": 0.025, "TestSerialization": 0.002, "TestSharding": 0.008, "TestStreamWrapper": 0.177, "TestTyping": 0.003}, "test_decomp": {"DecompOneOffTestsCUDA": 0.010000000000000002, "HasDecompTest": 0.002, "TestDecompCUDA": 4887.325000001199}, "test_deploy": {"TestFreezer": 0.235}, "test_dispatch": {"TestDispatch": 0.171, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCUDA": 0.11800000000000009}, "test_dynamic_shapes": {"TestDimConstraints": 0.004, "TestFloorDiv": 0.004, "TestPySymInt": 0.29000000000000004, "TestSymNumberMagicMethods": 0.21400000000000016}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 0.08900000000000007, "TestExpandedWeightHelperFunctionCUDA": 0.008, "TestExpandedWeightModuleCUDA": 0.1240000000000001}, "test_fake_tensor": {"FakeTensorConstHandling": 0.010000000000000002, "FakeTensorConverterTest": 0.010000000000000002, "FakeTensorDispatchCache": 0.02000000000000001, "FakeTensorOpInfoTestCUDA": 0.011000000000000003, "FakeTensorOperatorInvariants": 0.012000000000000004, "FakeTensorPropTest": 0.004, "FakeTensorSerialization": 0.002, "FakeTensorTest": 0.05600000000000004, "PropagateRealTensorsFakeTensorConstHandling": 0.010000000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.010000000000000002, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.012000000000000004, "PropagateRealTensorsFakeTensorPropTest": 0.004, "PropagateRealTensorsFakeTensorTest": 0.05600000000000004}, "test_flop_counter": {"TestFlopCounter": 0.025000000000000012}, "test_foreach": {"TestForeachCUDA": 1.46499999999996}, "test_function_schema": {"TestFunctionSchema": 0.264}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 94.132}, "test_functional_optim": {"TestFunctionalOptimParity": 0.249}, "test_functionalization": {"TestCrossRefFunctionalization": 0.05600000000000004, "TestFunctionalization": 0.31600000000000006}, "test_functionalization_of_rng_ops": {"TestFunctionalizationRngOpsCUDA": 0.010000000000000002}, "test_futures": {"TestFuture": 0.263}, "test_fx": {"AnnotationsTest": 0.007, "TestCSEPass": 0.015000000000000006, "TestCommonPass": 0.016000000000000007, "TestConstFold": 0.02000000000000001, "TestConstParamShapeInControlFlow": 0.006, "TestDCE": 0.007, "TestFX": 0.18600000000000014, "TestFXAPIBackwardCompatibility": 0.005, "TestFunctionalTracing": 0.1240000000000001, "TestMatcher": 0.008, "TestOperatorSignaturesCUDA": 2.1249999999999294, "TestPassManager": 0.006, "TestSourceMatcher": 0.005, "TestSubgraphRewriter": 0.027000000000000017, "TestVisionTracing": 180.648, "TypeCheckerTest": 0.03100000000000002}, "test_fx_experimental": {"TestFXExperimental": 0.04100000000000003, "TestNormalizeOperatorsCUDA": 0.6630000000000005, "TestTranslationValidation": 0.004}, "test_fx_passes": {"TestFXGraphPasses": 0.23800000000000004, "TestFXMatcherUtils": 0.016000000000000007}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.306}, "test_import_stats": {"TestImportTime": 0.236}, "test_indexing": {"NumpyTestsCUDA": 0.02100000000000001, "TestIndexingCUDA": 0.06700000000000005}, "test_itt": {"TestItt": 0.244}, "test_jit": {"TestAliasAnalysis": 0.004, "TestAsync": 0.02100000000000001, "TestAtenPow": 0.001, "TestAutodiffJit": 0.005, "TestAutodiffSubgraphSlicing": 0.043000000000000003, "TestAwait": 0.017000000000000008, "TestBackends": 0.003, "TestBackendsWithCompiler": 0.002, "TestBatchMM": 0.008, "TestBuiltins": 0.004, "TestCUDA": 0.004, "TestClassType": 0.04500000000000003, "TestComplex": 0.014000000000000005, "TestCustomOperators": 0.014000000000000005, "TestDCE": 0.002, "TestDataParallel": 0.0, "TestDataclasses": 0.007, "TestDeviceAnalysis": 0.016000000000000007, "TestDict": 0.028000000000000018, "TestDtypeAnalysis": 0.41100000000000003, "TestEnum": 0.01800000000000001, "TestFreezing": 0.05400000000000004, "TestFrontend": 0.002, "TestFrozenOptimizations": 0.03400000000000002, "TestFunctionalBlocks": 0.001, "TestFunctionalToInplaceActivation": 0.004, "TestGenerator": 0.005, "TestGetDefaultAttr": 0.003, "TestGraphRewritePasses": 0.001, "TestHash": 0.009000000000000001, "TestHooks": 0.023000000000000013, "TestIgnorableArgs": 0.002, "TestIgnoreContextManager": 0.003, "TestInplaceToFunctionalActivation": 0.002, "TestIsinstance": 0.02900000000000002, "TestJit": 10.76399999999997, "TestJitGeneratedModule": 12.979999999999983, "TestJitProfiler": 0.001, "TestJitUtils": 0.008, "TestList": 0.08100000000000006, "TestLogging": 0.006, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.024000000000000014, "TestMixTracingScripting": 0.022000000000000013, "TestModels": 249.989, "TestModuleAPIs": 0.003, "TestModuleContainers": 0.01800000000000001, "TestModuleInterface": 0.016000000000000007, "TestModules": 0.001, "TestNamedTuple": 0.01800000000000001, "TestNnapiBackend": 41.40500000000001, "TestOpDecompositions": 0.002, "TestOptimizeForMobilePreserveDebugInfo": 0.007, "TestPDT": 0.01800000000000001, "TestParametrization": 0.002, "TestPeephole": 0.03900000000000003, "TestProducerVersion": 0.001, "TestProfiler": 0.18400000000000002, "TestPythonBindings": 0.008, "TestPythonBuiltinOP": 0.015000000000000006, "TestPythonIr": 0.004, "TestRecursiveScript": 0.03200000000000002, "TestRemoveMutation": 0.008, "TestSaveLoad": 70.59200000000006, "TestSaveLoadFlatbuffer": 0.010000000000000002, "TestSaveLoadForOpVersion": 0.011000000000000003, "TestScript": 0.5950000000000004, "TestScriptDict": 0.010000000000000002, "TestScriptList": 0.017000000000000008, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.014000000000000005, "TestScriptProfile": 0.005, "TestSlice": 0.019000000000000006, "TestSparse": 0.004, "TestStringFormatting": 0.022000000000000013, "TestSymbolicShapeAnalysis": 0.025000000000000015, "TestTensorBuiltins": 0.006, "TestTensorCreationOps": 0.006, "TestTensorMethods": 0.002, "TestTorchbind": 0.13100000000000003, "TestTracer": 0.1310000000000001, "TestTypeSharing": 0.025000000000000015, "TestTypesAndAnnotation": 0.016000000000000007, "TestTyping": 0.03900000000000003, "TestUnion": 0.04900000000000004, "TestUnsupportedOps": 0.002, "TestUpgraders": 0.014000000000000005, "TestWarn": 0.007, "TestWith": 0.006}, "test_jit_autocast": {"TestAutocast": 0.07200000000000002, "TestJitTraceAutocast": 0.008}, "test_jit_disabled": {"TestJitDisabled": 0.207}, "test_jit_fuser_te": {"TestFuserCommon": 0.002, "TestNNCOpInfoCUDA": 12.10000000000013, "TestTEFuserDynamic": 363.61299999999983, "TestTEFuserStatic": 356.9859999999998}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCUDA": 0.0, "TestModel": 0.001, "TestOpCUDA": 0.001}, "test_jiterator": {"TestPythonJiteratorCUDA": 0.2910000000000002}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.044000000000000025, "TestVmapBatchedGradientLegacyCUDA": 0.02900000000000002, "TestVmapOperatorsLegacy": 0.05200000000000004}, "test_license": {"TestLicense": 0.305}, "test_linalg": {"TestLinalgCUDA": 778.9429999999859}, "test_logging": {"LoggingTest": 0.223}, "test_masked": {"TestMaskedCUDA": 0.1360000000000001}, "test_maskedtensor": {"TestBasicsCUDA": 0.016000000000000007, "TestBinary": 0.06800000000000005, "TestOperatorsCUDA": 0.7230000000000005, "TestReductions": 0.01900000000000001, "TestUnary": 0.2240000000000001}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.003, "TestMatmulCudaCUDA": 0.028000000000000018, "TestMixedDtypesLinearCudaCUDA": 0.0}, "test_meta": {"TestMetaCUDA": 303.89799999956387, "TestMetaConverter": 0.02000000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 0.265}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.225}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 0.229}, "test_mobile_optimizer": {"TestOptimizer": 0.194}, "test_model_dump": {"TestModelDump": 0.25}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.172}, "test_module_tracker": {"TestModuleTracker": 0.249}, "test_modules": {"TestModuleCUDA": 873.9219999999478}, "test_monitor": {"TestMonitor": 0.249, "TestMonitorTensorboard": 0.105}, "test_multiprocessing": {"TestMultiprocessing": 0.031000000000000017}, "test_multiprocessing_spawn": {"ErrorTest": 0.001, "ForkTest": 0.008, "SpawnTest": 0.219}, "test_namedtensor": {"TestNamedTensor": 0.08700000000000006}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 0.202}, "test_native_functions": {"TestNativeFunctions": 0.226}, "test_native_mha": {"TestMHADeviceTypeCUDA": 0.05400000000000004}, "test_nestedtensor": {"TestNestedTensor": 0.04900000000000004, "TestNestedTensorAutogradCUDA": 0.05600000000000004, "TestNestedTensorDeviceTypeCUDA": 0.1500000000000001, "TestNestedTensorSubclassCUDA": 0.22800000000000017}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.001, "TestFusionUtils": 0.002, "TestNN": 0.9960000000000008, "TestNNDeviceTypeCUDA": 1.1979999999999797, "TestUtils": 0.001}, "test_numba_integration": {"TestNumbaIntegration": 0.012999999999999998}, "test_numpy_interop": {"TestNumPyInteropCUDA": 0.04100000000000003}, "test_openmp": {"TestOpenMP_ParallelFor": 0.236}, "test_ops": {"TestCommonCUDA": 588.3159999994965, "TestCompositeComplianceCUDA": 619.2439999999513, "TestFakeTensorCUDA": 780.0379999999933, "TestMathBitsCUDA": 3.5559999999998255, "TestSelfKwarg": 0.001, "TestTagsCUDA": 1.0139999999999996}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 84.39600000001369}, "test_ops_gradients": {"TestBwdGradientsCUDA": 858.7659999999412}, "test_ops_jit": {"TestJitCUDA": 68.66000000000155}, "test_optim": {"TestDifferentiableOptimizer": 0.011000000000000003, "TestLRScheduler": 0.17900000000000013, "TestOptimRenewedCUDA": 0.5110000000000003, "TestSWAUtils": 0.013000000000000005}, "test_out_dtype_op": {"TestOutDtypeOp": 0.021000000000000005}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.001, "TestGradCheckOverride": 0.001, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.001, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 1.639999999999931, "TestTorchFunctionWarning": 0.001, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.007, "ModelTest": 0.0, "TestAnalyze": 0.262, "TestDependencyAPI": 0.017000000000000008, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006, "TestLoadBCPackages": 0.003, "TestMangling": 0.010000000000000002, "TestMisc": 0.011000000000000003, "TestPackageFX": 0.006, "TestPackageScript": 0.023000000000000013, "TestRepackage": 0.001, "TestResources": 0.004, "TestSaveLoad": 0.011000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.246}, "test_prims": {"TestDecompCUDA": 0.002, "TestPrimsBasic": 0.003, "TestPrimsCUDA": 0.012000000000000004, "TestRefsCUDA": 0.005}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.006, "TestGenericProxyTensorFake": 0.035000000000000024, "TestGenericProxyTensorReal": 0.036000000000000025, "TestGenericProxyTensorSymbolic": 0.035000000000000024, "TestRealProxyTensor": 0.001, "TestSymbolicTracing": 0.060000000000000046}, "test_pruning_op": {"PruningOpTest": 0.258}, "test_public_bindings": {"TestPublicBindings": 0.23500000000000001}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.001, "TestPythonDispatch": 0.07100000000000005, "TestPythonDispatcher": 0.002, "TestPythonRegistration": 0.01800000000000001, "TestWrapperSubclassAliasingCUDA": 0.01900000000000001}, "test_pytree": {"TestCxxPytree": 0.014000000000000005, "TestGenericPytree": 0.277, "TestPythonPytree": 0.03000000000000002}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.01800000000000001, "TestAOMigrationQuantization": 0.011000000000000003, "TestAOMigrationQuantizationFx": 0.012000000000000004, "TestBackendConfig": 0.01900000000000001, "TestBiasCorrectionEager": 0.002, "TestBitsCUDA": 0.003, "TestComparatorOps": 0.002, "TestDeprecatedJitQuantized": 0.004, "TestDistributed": 0.005, "TestDuplicateDQPass": 0.004, "TestDynamicQuantizedModule": 0.010000000000000002, "TestDynamicQuantizedOps": 0.016000000000000007, "TestEqualizeEager": 0.005, "TestEqualizeFx": 0.010000000000000002, "TestFXGraphMatcher": 0.014000000000000005, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 0.048000000000000036, "TestFXNumericSuiteCoreAPIsModels": 0.013000000000000005, "TestFXNumericSuiteNShadows": 0.026000000000000013, "TestFakeQuantize": 0.003, "TestFakeQuantizeOps": 0.03200000000000002, "TestFloat8DtypeCUDA": 0.014000000000000005, "TestFuseEager": 0.010000000000000002, "TestFuseFx": 0.016000000000000007, "TestFusedObsFakeQuant": 0.004, "TestFusedObsFakeQuantModule": 0.008, "TestFusionPasses": 0.001, "TestFxDetectInputWeightEqualization": 0.003, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.007, "TestFxModelReportObserver": 0.004, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.003, "TestHistogramObserver": 0.007, "TestMetaDataPorting": 0.006, "TestModelNumericsEager": 0.004, "TestNumericSuiteEager": 0.02000000000000001, "TestObserver": 0.014000000000000005, "TestPT2ERepresentation": 0.008, "TestPadding": 0.003, "TestQNNPackOps": 0.012000000000000004, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 0.003, "TestQuantizeDynamicJitPasses": 0.010000000000000002, "TestQuantizeEagerOps": 0.011000000000000003, "TestQuantizeEagerPTQDynamic": 0.013000000000000005, "TestQuantizeEagerPTQStatic": 0.02100000000000001, "TestQuantizeEagerQAT": 0.014000000000000005, "TestQuantizeEagerQATNumerics": 0.009000000000000001, "TestQuantizeFx": 0.1530000000000001, "TestQuantizeFxModels": 0.008, "TestQuantizeFxOps": 0.05600000000000004, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.02900000000000002, "TestQuantizeJitPasses": 0.03900000000000003, "TestQuantizePT2E": 0.04000000000000003, "TestQuantizePT2EQATModels": 404.817, "TestQuantizePT2EQAT_ConvBn1d": 568.384, "TestQuantizePT2EQAT_ConvBn2d": 554.915, "TestQuantizePT2EX86Inductor": 191.69400000000005, "TestQuantizedConv": 0.02900000000000002, "TestQuantizedEmbeddingOps": 0.007, "TestQuantizedFunctionalOps": 0.005, "TestQuantizedLinear": 0.015000000000000006, "TestQuantizedOps": 1031.8119999999994, "TestQuantizedTensor": 0.06600000000000004, "TestRecordHistogramObserver": 0.002, "TestReferenceQuantizedModule": 0.004, "TestSerialization": 0.01900000000000001, "TestStaticQuantizedModule": 811.4769999999996, "TestSubgraphRewriter": 0.014000000000000005, "TestUtils": 0.006, "TestXNNPACKQuantizer": 0.025000000000000015, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCUDA": 6.231999999999932}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 0.07300000000000005}, "test_schema_check": {"TestSchemaCheck": 0.036000000000000025, "TestSchemaCheckModeOpInfoCUDA": 20.88000000000379}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 0.07400000000000005}, "test_serialization": {"TestBothSerializationCUDA": 0.002, "TestOldSerialization": 0.03900000000000003, "TestSerialization": 0.07700000000000005, "TestSubclassSerialization": 0.008}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.255}, "test_shape_ops": {"TestShapeOpsCUDA": 0.09500000000000007}, "test_show_pickle": {"TestShowPickle": 0.209}, "test_sort_and_select": {"TestSortAndSelectCUDA": 1.5639999999999914}, "test_sparse": {"TestSparseAnyCUDA": 316.92899999997167, "TestSparseCUDA": 0.2760000000000002, "TestSparseLegacyAndDeprecation": 0.001, "TestSparseMaskedReductionsCUDA": 0.04200000000000003, "TestSparseMeta": 0.04000000000000003, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCUDA": 1.352999999999963}, "test_sparse_csr": {"TestSparseCSRCUDA": 2.077999999999902, "TestSparseCSRSampler": 0.001, "TestSparseCompressedCUDA": 2.984999999999785, "TestSparseCompressedTritonKernelsCUDA": 307.3939999999988}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.001, "TestSparseSemiStructuredCUDA": 0.005, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.001, "TestSparseSemiStructuredCUTLASSCUDA": 0.003, "TestSparseSemiStructuredTrainingCUDA": 0.002}, "test_spectral_ops": {"TestFFTCUDA": 0.34800000000000025}, "test_stateless": {"TestPythonOptimizeMode": 0.001, "TestStatelessDeprecation": 0.002, "TestStatelessFunctionalAPI": 0.054000000000000034}, "test_subclass": {"TestSubclass": 0.32100000000000006}, "test_sympy_utils": {"TestNumbers": 0.005, "TestSingletonInt": 0.001, "TestSympyInterp": 0.05600000000000004, "TestSympySolve": 0.028000000000000018, "TestValueRanges": 0.06900000000000005}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.1440000000000001, "TestLikeTensorCreationCUDA": 0.006, "TestRandomTensorCreationCUDA": 0.024000000000000014, "TestTensorCreationCUDA": 1.7889999999999648}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.002, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.002, "TestTensorBoardPyTorchNumpy": 0.265, "TestTensorBoardPytorchGraph": 0.006, "TestTensorBoardSummary": 0.01800000000000001, "TestTensorBoardSummaryWriter": 0.003, "TestTensorBoardUtils": 0.004, "TestTensorBoardWriter": 0.001, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 0.25200000000000006}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.001, "TestTensorExprPyBind": 0.232}, "test_testing": {"TestAssertClose": 0.03300000000000002, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.014000000000000005, "TestAssertCloseMultiDeviceCUDA": 0.002, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.004, "TestAssertCloseSparseBSR": 0.004, "TestAssertCloseSparseCOO": 0.006, "TestAssertCloseSparseCSC": 0.004, "TestAssertCloseSparseCSR": 0.004, "TestFrameworkUtils": 0.001, "TestImports": 0.006, "TestMakeTensorCUDA": 0.7310000000000005, "TestOpInfoSampleFunctionsCUDA": 1.3939999999999777, "TestOpInfos": 0.002, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCUDA": 0.027000000000000017, "TestTestingCUDA": 0.04100000000000003}, "test_torch": {"TestBasicVitalSigns": 0.003, "TestDevicePrecisionCUDA": 0.02000000000000001, "TestTorch": 0.21500000000000016, "TestTorchDeviceTypeCUDA": 35.68899999999835, "TestVitalSignsCudaCUDA": 0.001}, "test_transformers": {"TestAttnBiasCUDA": 0.022000000000000013, "TestSDPACUDA": 1.3079999999999679, "TestSDPACudaOnlyCUDA": 78.69600000001333, "TestSDPAFailureModesCUDA": 0.035000000000000024, "TestTransformersCUDA": 16.215000000000032}, "test_type_hints": {"TestTypeHints": 0.248}, "test_type_info": {"TestDTypeInfo": 0.363}, "test_type_promotion": {"TestTypePromotionCUDA": 0.4260000000000003}, "test_typing": {"TestTyping": 55.24499999999998}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 27.04100000000891}, "test_utils": {"TestAssert": 0.002, "TestBottleneck": 0.001, "TestCheckpoint": 0.017000000000000008, "TestCollectEnv": 0.001, "TestCppExtensionUtils": 0.002, "TestDataLoaderUtils": 0.004, "TestDeviceUtilsCUDA": 7.502000000000917, "TestExtensionUtils": 0.002, "TestHipify": 0.001, "TestHipifyTrie": 0.003, "TestONNXUtils": 0.002, "TestRenderUtils": 0.001, "TestStandaloneCPPJIT": 0.001, "TestTraceback": 0.005}, "test_view_ops": {"TestOldViewOpsCUDA": 0.11600000000000009, "TestViewOpsCUDA": 0.16300000000000012}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.017, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 0.24400000000000002}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 1363.541, "TestXNNPACKOps": 0.497, "TestXNNPACKRewritePass": 0.002, "TestXNNPACKSerDes": 0.004}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.002}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.264, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.009000000000000001, "TestPickling": 0.017000000000000008, "TestPromotion": 0.009}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 0.257, "TestEinsumPath": 0.0, "TestMisc": 0.001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.244, "TestMisc": 0.002, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.003, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.001, "TestFloatNonIntegerArgument": 0.004, "TestIndexing": 0.28800000000000003, "TestMultiIndexingAutomated": 0.003, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.012000000000000004, "TestArgmax": 0.06300000000000004, "TestArgmaxArgminCommon": 0.027000000000000017, "TestArgmin": 0.06300000000000004, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.013000000000000005, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.002, "TestAttributes": 0.019000000000000003, "TestBinop": 0.001, "TestBool": 660.1439999999999, "TestCequenceMethods": 0.001, "TestChoose": 0.014000000000000002, "TestClip": 0.002, "TestCompress": 0.003, "TestConversion": 0.003, "TestCreation": 0.001, "TestDelMisc": 0.001, "TestDot": 2.74, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.006, "TestFlag": 0.012000000000000004, "TestFormat": 0.003, "TestFromBuffer": 0.010000000000000002, "TestHash": 0.175, "TestHashing": 0.002, "TestIO": 0.001, "TestInner": 0.004, "TestLexsort": 0.012000000000000004, "TestMatmul": 0.3300000000000001, "TestMatmulOperator": 0.013000000000000005, "TestMethods": 0.11700000000000009, "TestMinMax": 0.002, "TestMinScalarType": 0.004, "TestNewaxis": 0.001, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.05900000000000001, "TestResize": 0.008, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.015, "TestSortFloatMisc": 0.15300000000000002, "TestStats": 0.2900000000000001, "TestSubscripting": 0.001, "TestTake": 0.008, "TestVdot": 0.004, "TestWarnings": 0.007, "TestWhere": 0.008, "TestWritebackIfCopy": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.005, "TestArgwhere": 0.006, "TestArrayComparisons": 0.004, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006, "TestBoolArray": 0.003, "TestBoolCmp": 0.002, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.05400000000000004, "TestConvolve": 0.003, "TestCorrelate": 0.004, "TestCreationFuncs": 0.005, "TestCross": 0.005, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006, "TestFromiter": 0.0, "TestIndex": 0.002, "TestIndices": 0.016000000000000007, "TestIsclose": 0.008, "TestIsscalar": 0.001, "TestLikeFuncs": 0.0, "TestMoveaxis": 0.005, "TestNonarrayArgs": 0.037000000000000026, "TestNonzeroAndCountNonzero": 0.023000000000000013, "TestOuterMisc": 0.001, "TestRequire": 0.004, "TestResize": 0.226, "TestRoll": 0.003, "TestRollaxis": 0.002, "TestSeterr": 0.004, "TestStdVar": 0.005, "TestStdVarComplex": 0.002, "TestStringFunction": 0.001, "TestTensordot": 0.003, "TestTypes": 0.005}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.261, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.02100000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.060000000000000046, "TestFromInt": 0.002, "TestFromString": 0.244}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.249, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.010000000000000002, "TestBaseMath": 0.002, "TestBitShifts": 0.010000000000000002, "TestComplexDivision": 0.002, "TestConversion": 0.006, "TestHash": 0.0, "TestModulus": 41.47599999999999, "TestMultiply": 0.0, "TestNegative": 0.002, "TestPower": 0.004, "TestRepr": 0.001, "TestScalarOpsMisc": 0.028000000000000018, "TestScalarSubclassingMisc": 0.009000000000000001, "TestSubtract": 0.002, "TestTypes": 0.254}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.225, "TestAtleast2d": 0.005, "TestAtleast3d": 0.004, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.047000000000000035, "TestHstack": 0.007, "TestStackMisc": 0.0, "TestVstack": 0.007}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.001, "TestFFTShift": 0.329, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.07400000000000005, "TestFFTShift": 0.245, "TestFFTThreadSafe": 0.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.278}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.002, "TestUnique": 0.281}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.002, "TestAmax": 0.001, "TestAmin": 0.001, "TestAngle": 0.001, "TestAny": 0.002, "TestAverage": 0.003, "TestBincount": 0.013000000000000005, "TestCheckFinite": 0.002, "TestCopy": 0.002, "TestCorrCoef": 0.010000000000000002, "TestCov": 0.013000000000000005, "TestCumprod": 0.001, "TestCumsum": 0.001, "TestDelete": 0.015, "TestDiff": 0.006, "TestDigitize": 0.011000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.1210000000000001, "TestFlip": 0.007, "TestGradient": 0.01800000000000001, "TestInsert": 0.005, "TestInterp": 0.02900000000000002, "TestKaiser": 0.002, "TestMedian": 0.015000000000000006, "TestMeshgrid": 0.011000000000000003, "TestMsort": 0.0, "TestPercentile": 0.02100000000000001, "TestPiecewise": 0.008, "TestProd": 0.001, "TestPtp": 0.001, "TestQuantile": 0.003, "TestRot90": 0.212, "TestSelect": 0.006, "TestSinc": 0.002, "TestSortComplex": 0.007, "TestTrapz": 0.002, "TestTrimZeros": 0.008, "TestUnique": 0.002, "Test_I0": 0.002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.552, "TestHistogramOptimBinNums": 0.017000000000000008, "TestHistogramdd": 0.017000000000000008}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.001, "TestDiagIndicesFrom": 0.003, "TestFillDiagonal": 0.007, "TestGrid": 0.007, "TestIndexExpression": 0.002, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.304}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.010000000000000002, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.009000000000000001, "TestColumnStack": 0.004, "TestDsplit": 0.005, "TestDstack": 0.006, "TestExpandDims": 0.004, "TestHsplit": 0.004, "TestKron": 0.002, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.002, "TestSplit": 0.002, "TestSqueeze": 0.005, "TestTakeAlongAxis": 0.269, "TestTile": 0.004, "TestVsplit": 0.004}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.005, "TestEye": 0.252, "TestFliplr": 0.001, "TestFlipud": 0.001, "TestHistogram2d": 0.006, "TestTri": 0.007, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.221, "TestImag": 0.002, "TestIscomplex": 0.002, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.006, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.003, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.003, "TestNanToNum": 0.003, "TestReal": 0.002, "TestRealIfClose": 0.001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.02100000000000001, "TestCond": 0.272, "TestDet": 0.184, "TestEig": 0.060000000000000005, "TestEigh": 0.007, "TestEighCases": 0.0, "TestEigvals": 0.07, "TestEigvalsh": 0.007, "TestEigvalshCases": 0.0, "TestInv": 0.07100000000000001, "TestLstsq": 0.012000000000000004, "TestMatrixRank": 0.003, "TestMisc": 0.37, "TestMisc2": 0.001, "TestMultiDot": 0.011000000000000003, "TestNormDouble": 0.010000000000000002, "TestNormInt64": 0.010000000000000002, "TestNormSingle": 0.010000000000000002, "TestNorm_NonSystematic": 0.001, "TestPinv": 0.296, "TestPinvHermitian": 0.07500000000000001, "TestQR": 0.012000000000000004, "TestSVD": 0.069, "TestSVDHermitian": 0.224, "TestSolve": 0.322, "TestTensorinv": 0.007, "TestTensorsolve": 0.002}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.003, "TestCtorNested": 0.001, "TestDefaultDtype": 0.004, "TestDivmod": 0.005, "TestExport": 0.0, "TestMisc": 0.002, "TestNormalizations": 0.003, "TestOneArr": 0.23500000000000018, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1330000000000001, "TestOneArrAndShape": 0.008, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.30600000000000005}, "torch_np/test_dtype": {"TestConvertDType": 0.28400000000000003}, "torch_np/test_function_base": {"TestAppend": 0.256}, "torch_np/test_ndarray_methods": {"TestAmax": 0.001, "TestAmin": 0.007, "TestArgmax": 0.11600000000000005, "TestArgmaxArgminCommon": 0.04900000000000002, "TestArgmin": 0.14300000000000007, "TestContains": 0.001, "TestIndexing": 0.293, "TestIter": 0.004, "TestNoExtraMethods": 0.006, "TestNonzero": 0.005, "TestRavel": 0.008, "TestReshape": 0.002, "TestTranspose": 0.002}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.01, "TestNEP50Table": 0.0}, "torch_np/test_random": {"TestChoice": 0.002, "TestNumpyGlobal": 0.001, "TestScalarReturn": 0.262, "TestShuffle": 0.006}, "torch_np/test_reductions": {"TestAll": 0.003, "TestAny": 0.003, "TestFlatnonzero": 0.202, "TestGenericCumSumProd": 0.008, "TestGenericReductions": 1.0609999999999948, "TestMean": 0.004, "TestSum": 0.010000000000000002}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.27, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3070000000000002, "TestNdarrayDunderVsUfunc": 0.03000000000000002, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.24100000000000002}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.28600000000000003}}}, "linux-jammy-cpu-py3.12-gcc11-inductor-halide": {"inductor-halide": {"inductor/test_halide": {"HalideTests": 1.8415}}}, "linux-jammy-py3.10-clang15-asan": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 5.786333333333334}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.1786666666666665}, "distributions/test_constraints": {"test_constraints": 0.13666666666666677}, "distributions/test_distributions": {"TestAgainstScipy": 1.6416666666666666, "TestConstraints": 0.4663333333333333, "TestDistributionShapes": 0.3413333333333335, "TestDistributions": 60.25133333333333, "TestFunctors": 0.025000000000000005, "TestJit": 53.74433333333334, "TestKL": 10.441333333333331, "TestLazyLogitsInitialization": 0.041, "TestNumericalStability": 0.24000000000000007, "TestRsample": 1.623, "TestValidation": 1.3086666666666666}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.5323333333333333}, "dynamo/test_after_aot": {"TestAfterAot": 13.111333333333334}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.7493333333333334}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 27.391000000000002}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.35666666666666674, "AOTAutogradCacheTests": 34.35233333333333}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 3.9163333333333328}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.07466666666666667, "TestCustomBackendAPI": 3.114333333333333, "TestExplainWithBackend": 23.14833333333333, "TestOptimizations": 3.2496666666666663}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 26.399333333333335}, "dynamo/test_base_output": {"TestBaseOutput": 0.004}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 14.833333333333334}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 14.681666666666667, "BytecodeTests": 0.541}, "dynamo/test_compile": {"InPlaceCompilationTests": 15.809, "PublicTorchCompilerTests": 0.0030000000000000005}, "dynamo/test_comptime": {"ComptimeTests": 0.7266666666666667}, "dynamo/test_config": {"ConfigTests": 0.6663333333333333}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.4073333333333333, "CppGuardManagerFuncTorchHigherOrderOpTests": 16.080333333333332, "CppGuardManagerFunctionTests": 44.569000000000095, "CppGuardManagerHigherOrderOpTests": 10.139666666666665, "CppGuardManagerMiscTests": 71.67900000000007, "CppGuardManagerReproTests": 69.98633333333335}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.7386666666666668}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.291}, "dynamo/test_decorators": {"DecoratorTests": 14.65}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0016666666666666668, "TestDeviceGuard": 0.022000000000000002}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 39.87166666666666, "DynamicShapesCtxManagerTests": 6.284333333333333, "DynamicShapesExportTests": 39.25933333333333, "DynamicShapesFuncTorchHigherOrderOpTests": 106.7276666666667, "DynamicShapesFunctionTests": 124.31633333333332, "DynamicShapesHigherOrderOpTests": 22.010333333333335, "DynamicShapesMiscTests": 137.53300000000004, "DynamicShapesNNModuleTests": 9.981666666666667, "DynamicShapesReproTests": 145.11566666666673, "DynamicShapesSubGraphTests": 13.075000000000001, "DynamicShapesTestSDPA": 0.5103333333333334}, "dynamo/test_exc": {"ExcTests": 2.3013333333333335}, "dynamo/test_exceptions": {"ExceptionTests": 0.6250000000000001}, "dynamo/test_export": {"ExportTests": 21.552666666666664}, "dynamo/test_export_mutations": {"MutationExportTests": 0.6243333333333335}, "dynamo/test_frame_init": {"FrameInitTests": 0.27166666666666667}, "dynamo/test_functions": {"DefaultsTests": 1.0246666666666668, "FunctionTests": 35.25866666666668}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.3923333333333332}, "dynamo/test_global": {"TestGlobals": 0.6806666666666668}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.3056666666666667}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.09400000000000001, "FuncTorchHigherOrderOpTests": 13.477666666666664, "HigherOrderOpTests": 9.739333333333335, "HigherOrderOpVmapGuardTests": 5.181333333333335}, "dynamo/test_hooks": {"HooksTests": 44.481666666666676}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 18.27033333333333, "InlineInbuiltNNModulesExportTests": 21.308333333333334, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 13.819333333333333, "InlineInbuiltNNModulesFunctionTests": 29.299000000000035, "InlineInbuiltNNModulesHigherOrderOpTests": 9.475999999999997, "InlineInbuiltNNModulesMiscTests": 91.96500000000015, "InlineInbuiltNNModulesNNModuleTests": 5.683333333333331}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 17.287333333333333}, "dynamo/test_interop": {"InteropTests": 0.7586666666666666}, "dynamo/test_logging": {"LoggingTests": 34.425666666666665}, "dynamo/test_minifier": {"MinifierTests": 1.7269999999999996}, "dynamo/test_misc": {"MiscTests": 108.50433333333358, "TestTracer": 0.26133333333333336}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.005}, "dynamo/test_modules": {"NNModuleTests": 4.449666666666666, "OptimizedModuleTest": 32.955000000000005}, "dynamo/test_nops": {"NopTests": 0.36466666666666664}, "dynamo/test_optimizers": {"End2EndTests": 0.8033333333333333, "OptimizerTests": 2.2183333333333333}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.5566666666666668}, "dynamo/test_profiler": {"DynamoProfilerTests": 2.188333333333333}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.7680000000000001}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.0846666666666664}, "dynamo/test_recompiles": {"RecompileTests": 1.079}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.6090000000000001}, "dynamo/test_replay_record": {"ReplayRecordTests": 1.1639999999999997}, "dynamo/test_repros": {"ReproTests": 81.03233333333337}, "dynamo/test_resume": {"ResumeFunctionTests": 0.48500000000000004}, "dynamo/test_sdpa": {"TestSDPA": 0.574}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.626}, "dynamo/test_sources": {"SourceTests": 0.5460000000000002}, "dynamo/test_structured_trace": {"StructuredTraceTest": 22.74166666666667}, "dynamo/test_subclasses": {"SubclassTests": 6.9013333333333335, "TestNestedTensor": 26.194333333333333}, "dynamo/test_subgraphs": {"SubGraphTests": 3.163}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.12933333333333333, "TraceRuleTests": 1.27}, "dynamo/test_triton_kernels": {"KernelTests": 0.019333333333333345, "MutationTests": 0.0036666666666666666, "NoOptimizationKernelTests": 0.04200000000000003, "no_opt_test_class": 0.033666666666666685}, "dynamo/test_unspec": {"UnspecTests": 23.60633333333334}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 1.0683333333333334}, "dynamo/test_view": {"ViewTests": 0.7183333333333333}, "export/test_converter": {"TestConverter": 12.885333333333334}, "export/test_db": {"ExampleTests": 4.581}, "export/test_experimental": {"TestExperiment": 1.8429999999999997}, "export/test_export": {"TestDynamismExpression": 0.6876666666666665, "TestExport": 53.52133333333333, "TestExportCustomClass": 0.14333333333333334, "TestOneOffModelExportResult": 2.0406666666666666}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.646, "NonStrictExportTestExport": 52.77000000000001}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.8106666666666666, "PreDispatchExportTestExport": 53.58733333333333}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.3993333333333333}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.8096666666666666}, "export/test_hop": {"TestHOPCPU": 4.154333333333334, "TestHOPGeneric": 0.004}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0033333333333333335, "TestLift": 0.17, "TestLiftUnlift": 0.018000000000000002}, "export/test_pass_infra": {"TestPassInfra": 1.3349999999999997}, "export/test_passes": {"TestPasses": 23.655999999999995}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.1706666666666665, "RetraceExportTestExport": 70.645}, "export/test_safeguard": {"TestSafeguard": 1.3633333333333333}, "export/test_schema": {"TestSchema": 0.3153333333333333}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.3686666666666667, "SerDesExportPreDispatchTestExport": 34.69366666666667, "SerDesExportTestDynamismExpression": 0.8889999999999999, "SerDesExportTestExport": 55.58700000000001}, "export/test_serialize": {"TestDeserialize": 12.661000000000001, "TestOpVersioning": 0.005666666666666667, "TestSaveLoad": 0.5226666666666667, "TestSchemaVersioning": 0.05566666666666666, "TestSerialize": 1.639, "TestSerializeCustomClass": 0.158}, "export/test_sparse": {"TestSparseProp": 145.4069999999999}, "export/test_tools": {"TestExportTools": 0.6569999999999999}, "export/test_torchbind": {"TestCompileTorchbind": 2.1633333333333336, "TestExportTorchbind": 3.5433333333333317, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.29000000000000004}, "export/test_unflatten": {"TestUnflatten": 4.991333333333333}, "export/test_upgrade": {"TestUpgrade": 0.5733333333333334}, "export/test_verifier": {"TestVerifier": 1.26}, "functorch/test_aotdispatch": {"TestAOTAutograd": 26.706333333333333, "TestAOTAutogradWithDynamo": 30.085333333333335, "TestAOTDispatch": 1.1660000000000001, "TestAOTExport": 4.849333333333333, "TestAOTModuleSimplified": 1.2073333333333334, "TestEagerFusionModuleInfoCPU": 1795.8726666666664, "TestEagerFusionOpInfoCPU": 3667.6999999999985, "TestPartitioning": 2.179666666666667, "TestPythonKeyCPU": 4.003666666666667}, "functorch/test_control_flow": {"TestControlFlow": 1.0053333333333334, "TestControlFlowTraced": 148.99366666666668}, "functorch/test_dims": {"TestMin": 20.469, "TestMinFunctorchOnly": 17.499666666666666}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.15866666666666673, "TestAutogradFunctionVmapAPICPU": 0.025333333333333333, "TestCompileTransformsCPU": 15.931333333333333, "TestComposabilityCPU": 4.497666666666665, "TestExamplesCorrectnessCPU": 22.148999999999997, "TestFunctionalizeCPU": 0.2173333333333334, "TestGradTransformCPU": 1.473333333333332, "TestHelpersCPU": 0.016, "TestHessianCPU": 0.132, "TestHigherOrderOperatorInteractionCPU": 0.05566666666666666, "TestJacCPU": 1.319333333333331, "TestJvpCPU": 0.08700000000000002, "TestLinearizeCPU": 0.31033333333333335, "TestMakeFunctional": 0.15900000000000003, "TestSliceArgnums": 0.03433333333333335, "TestVmapJvpInplaceViewCPU": 0.029, "TestVmapOfGradCPU": 1.0563333333333333}, "functorch/test_logging": {"TestAOTLogging": 0.37233333333333335}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.47700000000000004, "RandomOpTestCase": 0.14833333333333334, "ReduceTestCase": 0.10366666666666667, "TestMemoryEfficientOpAuthoring": 0.001}, "functorch/test_minifier": {"TestMinifier": 0.5433333333333333}, "functorch/test_ops": {"TestOperatorsCPU": 0.7083333333333335}, "functorch/test_parsing": {"TestAnonymousAxis": 0.27666666666666667, "TestParsedExpression": 0.005666666666666667, "TestParsingUtils": 0.006666666666666667, "TestValidateRearrangeExpressions": 0.006666666666666667}, "functorch/test_rearrange": {"TestRearrange": 0.4303333333333334}, "functorch/test_vmap": {"TestRandomnessCPU": 3.692333333333334, "TestTransformFailureCPU": 1.0159999999999998, "TestVmapAPI": 0.8336666666666668, "TestVmapBatchedGradientCPU": 0.41900000000000004, "TestVmapDeviceTypeCPU": 0.04533333333333334, "TestVmapNestedTensorCPU": 0.09333333333333334, "TestVmapOperators": 9.803999999999998, "TestVmapOperatorsOpInfoCPU": 2187.2696666666657}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.9563333333332156}, "higher_order_ops/test_with_effects": {"TestWithEffects": 16.342000000000002}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 13.406}, "inductor/test_binary_folding": {"FreezingCpuTests": 61.687333333333335}, "inductor/test_codecache": {"TestFxGraphCache": 74.93233333333337, "TestFxGraphCacheHashing": 1.2373333333333332, "TestUtils": 6.119666666666666, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.324}, "inductor/test_compile_worker": {"TestCompileWorker": 17.658666666666665}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 417.09499999999997, "TestAutogradWithCompiledAutograd": 526.2510000000005, "TestCompiledAutograd": 321.4123333333333, "TestCustomOpWithCompiledAutograd": 3.122999999999997}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 792.192, "CompiledOptimizerTests": 380.2816666666665}, "inductor/test_config": {"TestInductorConfig": 9.706666666666663}, "inductor/test_control_flow": {"CondTests": 0.007666666666666666, "WhileLoopTests": 0.004}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 817.5653333333333, "TestCppWrapper": 881.0536666666667}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 2033.443, "TestCppWrapper": 2056.2419999999997}, "inductor/test_cpu_repro": {"CPUReproTests": 1196.8886666666667}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 3653.1756666666665, "TestSelectAlgorithmDynamicShapesCPU": 3424.9583333333335}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0033333333333333335}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 16.597333333333335}, "inductor/test_debug_trace": {"TestDebugTrace": 3.8540000000000005}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0013333333333333333}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 64.53933333333335}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 151.93166666666664}, "inductor/test_extension_backend": {"ExtensionBackendTests": 25.893666666666665}, "inductor/test_flex_attention": {"TestFlexAttention": 0.015000000000000006, "TestTemplatedSDPA": 0.013000000000000005}, "inductor/test_foreach": {"ForeachTests": 28.616999999999905}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 132.734, "SDPAPatternRewriterCpuTests": 125.61866666666664}, "inductor/test_fx_fusion": {"TestFxFusion": 0.262}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.019666666666666666}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.20299999999999999, "TestGroupBatchFusion": 0.001, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.05033333333333334, "TestIndexingSimplification": 0.7143333333333333}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 84.492}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.001}, "inductor/test_metrics": {"TestMetrics": 0.164}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 293.81733333333335, "TestPatternMatcher": 1060.0916666666665}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.02300000000000001}, "inductor/test_profiler": {"DynamoProfilerTests": 0.004}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 29.467666666666663}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.013666666666666672}, "inductor/test_torchbind": {"TestTorchbind": 22.415000000000003}, "inductor/test_torchinductor": {"CpuTests": 2531.9223333333325, "SweepInputsCpuTest": 203.837, "TestFull": 17.19066666666667}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2619.291999999999}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 2.1366666666665353}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.8233333333333334}, "inductor/test_triton_kernels": {"KernelTests": 0.06466666666666672, "MutationTests": 0.006333333333333334, "NoOptimizationKernelTests": 0.015000000000000006, "no_opt_test_class": 0.03666666666666669}, "inductor/test_utils": {"TestUtils": 0.2683333333333333}, "lazy/test_debug_util": {"DebugUtilTest": 0.649}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.6509999999999999}, "lazy/test_generator": {"LazyGeneratorTest": 0.6296666666666667}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 1.8966666666666665}, "lazy/test_step_closures": {"ClosuresTest": 2.2606666666666664}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 3.036, "TestLazyOpInfoCPU": 30.79700000000003, "TestLazyTensor": 0.38066666666666665}, "nn/test_convolution": {"TestConvolutionNN": 36.20966666666667, "TestConvolutionNNDeviceTypeCPU": 28.195666666666693}, "nn/test_dropout": {"TestDropoutNN": 0.35200000000000004, "TestDropoutNNDeviceTypeCPU": 0.891}, "nn/test_embedding": {"TestEmbeddingNN": 0.10866666666666673, "TestEmbeddingNNDeviceTypeCPU": 23.19133333333333}, "nn/test_init": {"TestNNInit": 6.7876666666666665}, "nn/test_lazy_modules": {"TestLazyModules": 0.9353333333333335}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.9506666666666664, "TestLoadStateDictSwap": 0.12566666666666668}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.06866666666666667, "TestModuleHookNN": 0.20066666666666666, "TestModuleHooks": 0.22166666666666668, "TestStateDictHooks": 0.06566666666666668}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 12.538666666666666, "TestMultiheadAttentionNNDeviceTypeCPU": 0.041}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.3606666666666662}, "nn/test_parametrization": {"TestNNParametrization": 2.815333333333332, "TestNNParametrizationDeviceCPU": 0.03366666666666667}, "nn/test_pooling": {"TestAvgPool": 0.8383333333333333, "TestPoolingNN": 1.264, "TestPoolingNNDeviceTypeCPU": 81.94399999999996}, "nn/test_pruning": {"TestPruningNN": 0.18533333333333343}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.35000000000000003}, "profiler/test_memory_profiler": {"TestDataFlow": 2.0759999999999996, "TestIdentifyGradients": 0.967, "TestMemoryProfiler": 0.30466666666666664, "TestMemoryProfilerE2E": 14.107333333333335}, "profiler/test_profiler": {"TestExecutionTrace": 20.618666666666666, "TestExperimentalUtils": 12.334999999999999, "TestProfiler": 22.320000000000004, "TestProfilerCUDA": 0.0013333333333333333, "TestProfilerITT": 0.009333333333333334, "TestRecordFunction": 0.14533333333333334, "TestTorchTidyProfiler": 7.609999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.5203333333333334}, "profiler/test_record_function": {"TestRecordFunction": 0.5830000000000001}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 6.865666666666667}, "test_ao_sparsity": {"TestActivationSparsifier": 0.38399999999999995, "TestBaseDataScheduler": 0.10999999999999999, "TestBaseDataSparsifier": 0.23566666666666666, "TestBaseSparsifier": 0.03766666666666666, "TestBaseStructuredSparsifier": 2.7216666666666662, "TestComposability": 9.239666666666666, "TestCubicScheduler": 0.005666666666666667, "TestFPGMPruner": 0.03966666666666666, "TestFakeSparsity": 0.274, "TestFxComposability": 6.469333333333334, "TestNearlyDiagonalSparsifier": 3.5036666666666663, "TestNormDataSparsifiers": 3.0596666666666668, "TestQuantizationUtils": 0.05033333333333334, "TestQuantizedSparseKernels": 0.1743333333333333, "TestQuantizedSparseLayers": 1.1786666666666668, "TestSaliencyPruner": 0.04833333333333334, "TestScheduler": 0.018, "TestSparsityUtilFunctions": 0.07366666666666667, "TestWeightNormSparsifier": 1.0523333333333333}, "test_autocast": {"TestAutocastCPU": 3.317, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.006000000000000001}, "test_autograd": {"TestAllowMutationOnSaved": 0.07300000000000001, "TestAutograd": 66.50033333333342, "TestAutogradComplex": 0.013333333333333334, "TestAutogradDeviceTypeCPU": 0.8720000000000002, "TestAutogradForwardMode": 0.1953333333333334, "TestAutogradForwardModeBatchedGrad": 0.052333333333333336, "TestAutogradFunctional": 37.865, "TestAutogradInferenceMode": 0.05166666666666667, "TestAutogradLogging": 0.018, "TestAutogradMultipleDispatchCPU": 0.05666666666666667, "TestMultithreadAutograd": 0.7473333333333335, "TestNestedCheckpoint": 1.422, "TestSelectiveActivationCheckpoint": 0.06933333333333332}, "test_autograd_fallback": {"TestAutogradFallback": 0.4353333333333335}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 354.73899999997775}, "test_bundled_inputs": {"TestBundledInputs": 3.6166666666666667}, "test_comparison_utils": {"TestComparisonUtils": 0.28633333333333333}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.14}, "test_content_store": {"TestContentStoreCPU": 11.947000000000001}, "test_cpp_api_parity": {"TestCppApiParity": 8.950666666666665}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.033, "TestMAIATensor": 0.009666666666666669, "TestORTTensor": 0.023000000000000003, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.033, "TestMAIATensor": 0.01, "TestORTTensor": 0.02266666666666667, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.005, "TestTorchLibrary": 0.0003333333333333333}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 52.108}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.6526666666666665}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 17.740333333333336}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.6816666666666666}, "test_custom_backend": {"TestCustomBackend": 0.5493333333333333}, "test_custom_ops": {"MiniOpTest": 0.9976666666666669, "MiniOpTestOther": 0.09700000000000003, "TestCustomOp": 3.5163333333333306, "TestCustomOpAPI": 0.2636666666666667, "TestCustomOpTestingCPU": 2.559666666666667, "TestCustomOperators": 0.681, "TestGenerateOpcheckTests": 6.4366666666666665}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 75.97833333333334, "TestConcatDataset": 0.018, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.0016666666666666668, "TestDataLoader": 0.11433333333333333, "TestDataLoaderDeviceTypeCPU": 0.0023333333333333335, "TestDataLoaderPersistentWorkers": 0.0030000000000000005, "TestDatasetRandomSplit": 0.05466666666666667, "TestDictDataLoader": 0.124, "TestIndividualWorkerQueue": 0.0003333333333333333, "TestNamedTupleDataLoader": 0.006000000000000001, "TestSetAffinity": 0.17833333333333334, "TestStackDataset": 0.08766666666666667, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.07466666666666667}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.01, "TestDataChunk": 0.007, "TestDataFramesPipes": 0.002, "TestFunctionalIterDataPipe": 5.176999999999999, "TestFunctionalMapDataPipe": 0.04, "TestGraph": 0.023333333333333334, "TestIterDataPipeCountSampleYielded": 0.011000000000000001, "TestIterDataPipeGraphFastForward": 0.04866666666666667, "TestIterDataPipeSingletonConstraint": 0.02366666666666667, "TestIterableDataPipeBasic": 0.026000000000000006, "TestSerialization": 13.747666666666667, "TestSharding": 0.405, "TestStreamWrapper": 0.2886666666666667, "TestTyping": 0.008666666666666668}, "test_decomp": {"DecompOneOffTestsCPU": 0.004666666666666667, "HasDecompTest": 0.8786666666666667, "TestDecompCPU": 4.288000000000072}, "test_deploy": {"TestFreezer": 0.2783333333333333}, "test_dispatch": {"TestDispatch": 94.99966666666664, "TestPythonDispatcher": 0.03366666666666667}, "test_dlpack": {"TestTorchDlPackCPU": 0.3040000000000002}, "test_dynamic_shapes": {"TestDimConstraints": 2.2020000000000004, "TestFloorDiv": 0.015, "TestGuardsExpressions": 0.030666666666666665, "TestPySymInt": 1.3869999999999996, "TestSymNumberMagicMethods": 2.157666666666661}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 6.936333333333333, "TestExpandedWeightHelperFunctionCPU": 0.03, "TestExpandedWeightModuleCPU": 25.181}, "test_fake_tensor": {"FakeTensorConstHandling": 0.09066666666666669, "FakeTensorConverterTest": 0.02966666666666667, "FakeTensorDispatchCache": 0.09899999999999998, "FakeTensorOpInfoTestCPU": 0.117, "FakeTensorOperatorInvariants": 0.9779999999999999, "FakeTensorPropTest": 0.2343333333333333, "FakeTensorSerialization": 0.006000000000000001, "FakeTensorTest": 1.0539999999999996, "PropagateRealTensorsFakeTensorConstHandling": 0.18600000000000003, "PropagateRealTensorsFakeTensorConverterTest": 0.02766666666666667, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.09599999999999999, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.55, "PropagateRealTensorsFakeTensorPropTest": 0.07400000000000001, "PropagateRealTensorsFakeTensorTest": 0.3780000000000001}, "test_flop_counter": {"TestFlopCounter": 1.338333333333333}, "test_foreach": {"TestForeachCPU": 151.3909999999959}, "test_function_schema": {"TestFunctionSchema": 1.1066666666666667}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 67.543}, "test_functional_optim": {"TestFunctionalOptimParity": 0.628}, "test_functionalization": {"TestCrossRefFunctionalization": 5.900666666666665, "TestFunctionalization": 6.776}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.049666666666666665}, "test_futures": {"TestFuture": 0.9943333333333334}, "test_fx": {"AnnotationsTest": 0.016333333333333335, "TestCSEPass": 0.3640000000000001, "TestCommonPass": 0.08266666666666667, "TestConstFold": 0.17566666666666667, "TestConstParamShapeInControlFlow": 0.05733333333333334, "TestDCE": 0.030333333333333337, "TestFX": 6.514666666666656, "TestFXAPIBackwardCompatibility": 0.02866666666666667, "TestFunctionalTracing": 0.4136666666666669, "TestMatcher": 0.449, "TestOperatorSignaturesCPU": 4.0973333333333, "TestPassManager": 0.02533333333333333, "TestSourceMatcher": 1.618, "TestSubgraphRewriter": 0.31366666666666676, "TestVisionTracing": 766.386, "TypeCheckerTest": 4.163999999999999}, "test_fx_experimental": {"TestFXExperimental": 41.37633333333334, "TestNormalizeOperatorsCPU": 69.8973333333334, "TestTranslationValidation": 0.18100000000000002}, "test_fx_passes": {"TestFXGraphPasses": 0.9073333333333337, "TestFXMatcherUtils": 0.10500000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.6140000000000001}, "test_import_stats": {"TestImportTime": 8.818}, "test_indexing": {"NumpyTestsCPU": 0.07400000000000002, "TestIndexingCPU": 4.257999999999996}, "test_itt": {"TestItt": 0.27099999999999996}, "test_jit": {"TestAliasAnalysis": 1.178, "TestAsync": 1.8176666666666665, "TestAtenPow": 0.025000000000000005, "TestAutodiffJit": 0.40700000000000003, "TestAutodiffSubgraphSlicing": 1.779, "TestAwait": 0.7603333333333334, "TestBackends": 3.7586666666666666, "TestBackendsWithCompiler": 0.751, "TestBatchMM": 0.318, "TestBuiltins": 0.17566666666666667, "TestClassType": 5.393999999999998, "TestComplex": 3.055, "TestCustomOperators": 0.10466666666666669, "TestDCE": 0.042333333333333334, "TestDataParallel": 0.0030000000000000005, "TestDataclasses": 28.427333333333333, "TestDeviceAnalysis": 21.864666666666665, "TestDict": 1.4909999999999999, "TestDtypeAnalysis": 0.7123333333333334, "TestDtypeCustomRulesCPU": 13.5, "TestEnum": 0.5050000000000001, "TestFreezing": 5.111999999999999, "TestFrontend": 0.5733333333333333, "TestFrozenOptimizations": 61.09033333333332, "TestFunctionalBlocks": 0.023333333333333334, "TestFunctionalToInplaceActivation": 10.691, "TestGenerator": 0.2826666666666667, "TestGetDefaultAttr": 0.04733333333333334, "TestGraphRewritePasses": 0.25299999999999995, "TestHash": 0.3076666666666667, "TestHooks": 2.952666666666667, "TestIgnorableArgs": 0.03833333333333334, "TestIgnoreContextManager": 0.084, "TestInplaceToFunctionalActivation": 10.812666666666667, "TestIsinstance": 0.8306666666666668, "TestJit": 24.59833333333334, "TestJitGeneratedModule": 69.214, "TestJitProfiler": 0.0013333333333333333, "TestJitUtils": 0.019000000000000003, "TestList": 4.433666666666666, "TestLogging": 0.232, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.5510000000000002, "TestMixTracingScripting": 7.018333333333334, "TestModels": 9.611333333333333, "TestModuleAPIs": 0.611, "TestModuleContainers": 5.271999999999999, "TestModuleInterface": 1.5526666666666669, "TestModules": 0.062, "TestNamedTuple": 0.21533333333333335, "TestNnapiBackend": 0.021333333333333346, "TestOpDecompositions": 0.075, "TestOptimizeForMobilePreserveDebugInfo": 1.1813333333333336, "TestParametrization": 0.41133333333333333, "TestPeephole": 1.6463333333333334, "TestProducerVersion": 0.002, "TestProfiler": 0.8913333333333334, "TestPythonBindings": 0.261, "TestPythonBuiltinOP": 1.7519999999999998, "TestPythonIr": 0.082, "TestRecursiveScript": 2.802333333333332, "TestRemoveMutation": 0.47100000000000003, "TestSaveLoad": 1.957333333333333, "TestSaveLoadFlatbuffer": 1.0196666666666667, "TestSaveLoadForOpVersion": 5.378666666666667, "TestScript": 86.17633333333345, "TestScriptDict": 0.04633333333333334, "TestScriptList": 1.4869999999999992, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.39733333333333337, "TestScriptProfile": 1.586, "TestSlice": 0.5746666666666669, "TestSparse": 0.17, "TestStringFormatting": 0.4070000000000001, "TestSymbolicShapeAnalysis": 7.187666666666668, "TestTensorBuiltins": 0.29433333333333334, "TestTensorCreationOps": 0.18499999999999997, "TestTensorMethods": 0.043333333333333335, "TestTorchbind": 0.37233333333333346, "TestTracer": 12.817666666666662, "TestTypeSharing": 1.498, "TestTypesAndAnnotation": 0.2886666666666667, "TestTyping": 1.4896666666666665, "TestUnion": 1.7393333333333334, "TestUnsupportedOps": 0.059666666666666666, "TestUpgraders": 0.27566666666666667, "TestWarn": 0.17566666666666667, "TestWith": 1.646}, "test_jit_autocast": {"TestAutocast": 0.5683333333333334, "TestJitTraceAutocast": 46.22833333333333}, "test_jit_disabled": {"TestJitDisabled": 0.3956666666666666}, "test_jit_fuser_te": {"TestFuserCommon": 0.427, "TestLoopnestRandomizationCPU": 0.001, "TestNNCOpInfoCPU": 17.075666666666265, "TestTEFuserDynamic": 769.5086666666666, "TestTEFuserStatic": 859.84}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.25866666666666666, "TestFusionPatternCPU": 27.49666666666667, "TestModel": 18.710000000000004, "TestOpCPU": 162.27333333333334}, "test_legacy_vmap": {"TestVmapAPI": 5.113999999999997, "TestVmapAPILegacy": 6.841333333333332, "TestVmapBatchedGradientCPU": 0.17733333333333337, "TestVmapBatchedGradientLegacyCPU": 0.23666666666666672, "TestVmapOperators": 3.597999999999999, "TestVmapOperatorsLegacy": 4.298333333333332}, "test_license": {"TestLicense": 0.3216666666666666}, "test_linalg": {"TestLinalgCPU": 436.65100000000047}, "test_logging": {"LoggingTest": 8.332666666666666}, "test_masked": {"TestMaskedCPU": 50.425333333333356}, "test_maskedtensor": {"TestBasicsCPU": 0.31999999999999995, "TestBinary": 0.7540000000000004, "TestOperatorsCPU": 9.053333333333322, "TestReductions": 0.12533333333333335, "TestUnary": 0.5730000000000003}, "test_meta": {"TestMetaCPU": 25.268333333336965, "TestMetaConverter": 0.09300000000000004}, "test_mkl_verbose": {"TestMKLVerbose": 10.095666666666666}, "test_mkldnn": {"TestMkldnnCPU": 292.7086666666666}, "test_mkldnn_fusion": {"TestMkldnnFusion": 1552.2070000000003}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 10.118}, "test_mobile_optimizer": {"TestOptimizer": 9.999666666666668}, "test_model_dump": {"TestModelDump": 0.8933333333333334}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.15566666666666665}, "test_module_init": {"TestModuleInitCPU": 6.466999999999999}, "test_module_tracker": {"TestModuleTracker": 0.2946666666666667}, "test_modules": {"TestModuleCPU": 2254.170999999979}, "test_monitor": {"TestMonitor": 0.272, "TestMonitorTensorboard": 0.2373333333333333}, "test_multiprocessing": {"TestMultiprocessing": 22.82366666666667}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.582, "SpawnTest": 53.08766666666668}, "test_namedtensor": {"TestNamedTensor": 0.8896666666666668}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.6503333333333332}, "test_native_functions": {"TestNativeFunctions": 0.8060000000000002}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.7500000000000003}, "test_nestedtensor": {"TestNestedTensor": 0.2396666666666668, "TestNestedTensorAutogradCPU": 3.479666666666665, "TestNestedTensorDeviceTypeCPU": 1.9196666666666629, "TestNestedTensorSubclassCPU": 29.547333333333338}, "test_nn": {"TestAddRelu": 0.004, "TestConstantPadNd": 0.004, "TestFunctionalPickle": 0.0016666666666666668, "TestFusionEval": 0.419, "TestFusionUtils": 0.006333333333333333, "TestNN": 108.59966666666664, "TestNNDeviceTypeCPU": 366.03466666666617, "TestUtils": 0.005333333333333333}, "test_numba_integration": {"TestNumbaIntegration": 0.005333333333333333}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.34066666666666673}, "test_openmp": {"TestOpenMP_ParallelFor": 0.001}, "test_ops": {"TestCommonCPU": 3475.900999999952, "TestCompositeComplianceCPU": 1921.7873333333298, "TestFakeTensorCPU": 546.7503333333328, "TestMathBitsCPU": 121.51133333333338, "TestRefsOpsInfoCPU": 1.605000000000001, "TestSelfKwarg": 0.026333333333333334, "TestTagsCPU": 23.13299999999998}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 2536.535333333321}, "test_ops_gradients": {"TestBwdGradientsCPU": 3912.6639999999447}, "test_ops_jit": {"TestJitCPU": 6070.545666666666}, "test_optim": {"TestDifferentiableOptimizer": 0.6253333333333334, "TestLRScheduler": 1.156333333333331, "TestOptim": 173.136, "TestOptimRenewedCPU": 131.4133333333332, "TestSWAUtils": 0.5123333333333333}, "test_out_dtype_op": {"TestOutDtypeOp": 0.3166666666666667}, "test_overrides": {"TestBroadcastAllOverride": 0.0036666666666666666, "TestDisabledTorchFunction": 0.002, "TestDisabledUserWarnings": 0.002, "TestEinsumOverride": 0.007, "TestGradCheckOverride": 0.04133333333333333, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.01, "TestIterator": 0.002, "TestNamedTuple": 0.0030000000000000005, "TestPickle": 0.0023333333333333335, "TestRNN": 0.005, "TestResolveName": 0.13033333333333333, "TestTorchFunctionMode": 0.04366666666666669, "TestTorchFunctionOverride": 1.9586666666665788, "TestTorchFunctionWarning": 0.015333333333333332, "TestWrapTorchFunction": 0.0016666666666666668}, "test_package": {"DirectoryReaderTest": 0.08700000000000001, "ModelTest": 0.002, "TestAnalyze": 0.28833333333333333, "TestDependencyAPI": 0.06200000000000002, "TestDependencyHooks": 0.012000000000000002, "TestDiGraph": 0.024000000000000007, "TestGlobGroup": 0.029333333333333347, "TestImporter": 0.015666666666666666, "TestLoadBCPackages": 0.36599999999999994, "TestMangling": 0.023333333333333334, "TestMisc": 0.04566666666666667, "TestPackageFX": 0.08833333333333332, "TestPackageScript": 7.0, "TestRepackage": 0.008666666666666668, "TestResources": 0.014666666666666666, "TestSaveLoad": 0.04700000000000001}, "test_per_overload_api": {"TestPerOverloadAPI": 0.322}, "test_prims": {"TestDecompCPU": 0.10166666666666664, "TestPrimsBasic": 0.033, "TestPrimsCPU": 0.134, "TestRefsCPU": 0.02}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.17566666666666667, "TestGenericProxyTensorFake": 4.984, "TestGenericProxyTensorReal": 4.6723333333333334, "TestGenericProxyTensorSymbolic": 23.563666666666666, "TestProxyTensorOpInfoCPU": 991.0253333333316, "TestRealProxyTensor": 0.02666666666666667, "TestSymbolicTracing": 5.3276666666666666}, "test_pruning_op": {"PruningOpTest": 1.053}, "test_public_bindings": {"TestPublicBindings": 8.993333333333334}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.024999999999999998, "TestPythonDispatch": 0.31766666666666676, "TestPythonDispatcher": 0.016666666666666666, "TestPythonRegistration": 0.251, "TestWrapperSubclassAliasingCPU": 0.12066666666666671}, "test_pytree": {"TestCxxPytree": 0.015666666666666672, "TestGenericPytree": 0.4296666666666668, "TestPythonPytree": 0.09933333333333338}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.021333333333333333, "TestAOMigrationNNQuantized": 0.03933333333333333, "TestAOMigrationQuantization": 0.023333333333333334, "TestAOMigrationQuantizationFx": 0.029333333333333333, "TestBackendConfig": 0.06833333333333334, "TestBiasCorrectionEager": 3.6776666666666666, "TestBits": 0.007666666666666666, "TestBitsCPU": 0.24533333333333332, "TestComparatorOps": 3.0086666666666666, "TestDeprecatedJitQuantized": 9.831000000000001, "TestDistributed": 0.07366666666666666, "TestDuplicateDQPass": 10.799000000000001, "TestDynamicQuantizedModule": 45.397, "TestDynamicQuantizedOps": 11.883000000000001, "TestEqualizeEager": 0.2316666666666667, "TestEqualizeFx": 10.185666666666668, "TestFXGraphMatcher": 1.986, "TestFXGraphMatcherModels": 13.861333333333334, "TestFXNumericSuiteCoreAPIs": 66.26333333333334, "TestFXNumericSuiteCoreAPIsModels": 92.64233333333334, "TestFXNumericSuiteNShadows": 99.30166666666666, "TestFakeQuantize": 0.6066666666666667, "TestFakeQuantizeOps": 4.024333333333334, "TestFloat8DtypeCPU": 0.3053333333333334, "TestFloat8DtypeCPUOnlyCPU": 0.655, "TestFuseEager": 6.901666666666666, "TestFuseFx": 2.9899999999999998, "TestFusedObsFakeQuant": 0.224, "TestFusedObsFakeQuantModule": 0.478, "TestFusionPasses": 0.12733333333333333, "TestFxDetectInputWeightEqualization": 0.39200000000000007, "TestFxDetectOutliers": 0.91, "TestFxModelReportClass": 1.4883333333333333, "TestFxModelReportDetectDynamicStatic": 0.30333333333333334, "TestFxModelReportDetector": 0.3373333333333333, "TestFxModelReportObserver": 0.7646666666666667, "TestFxModelReportVisualizer": 0.4156666666666667, "TestGenerateNumericDebugHandle": 2.191333333333333, "TestGraphUtils": 1.8333333333333333, "TestHistogramObserver": 159.65133333333333, "TestMetaDataPorting": 23.041, "TestModelNumericsEager": 2.0613333333333332, "TestNumericSuiteEager": 23.160333333333337, "TestObserver": 14.007666666666665, "TestPT2ERepresentation": 64.06966666666666, "TestPadding": 75.287, "TestQNNPackOps": 0.011333333333333334, "TestQuantizationDocs": 0.005999999999999999, "TestQuantizeDynamicJitOps": 5.956333333333333, "TestQuantizeDynamicJitPasses": 13.428666666666667, "TestQuantizeEagerOps": 4.876666666666666, "TestQuantizeEagerPTQDynamic": 36.29366666666667, "TestQuantizeEagerPTQStatic": 60.69266666666666, "TestQuantizeEagerQAT": 16.708333333333336, "TestQuantizeEagerQATNumerics": 6.710999999999999, "TestQuantizeFx": 93.77000000000002, "TestQuantizeFxModels": 10.753333333333336, "TestQuantizeFxOps": 296.6123333333333, "TestQuantizeJit": 59.025666666666666, "TestQuantizeJitOps": 806.4343333333333, "TestQuantizeJitPasses": 21.139666666666667, "TestQuantizePT2E": 94.02300000000001, "TestQuantizePT2EQAT": 78.517, "TestQuantizePT2EQATModels": 57.24033333333333, "TestQuantizePT2EQAT_ConvBn1d": 502.1076666666666, "TestQuantizePT2EQAT_ConvBn2d": 491.7623333333333, "TestQuantizePT2EX86Inductor": 214.76399999999998, "TestQuantizedConv": 59.19033333333334, "TestQuantizedEmbeddingOps": 1.2923333333333333, "TestQuantizedFunctionalOps": 0.8766666666666666, "TestQuantizedLinear": 33.96233333333333, "TestQuantizedOps": 353.47733333333326, "TestQuantizedTensor": 8.147333333333334, "TestRecordHistogramObserver": 0.08333333333333333, "TestReferenceQuantizedModule": 0.09266666666666667, "TestSerialization": 5.134333333333333, "TestStaticQuantizedModule": 211.024, "TestSubgraphRewriter": 2.3293333333333335, "TestUtils": 0.030333333333333334, "TestXNNPACKQuantizer": 152.24366666666666, "TestXNNPACKQuantizerModels": 11.211}, "test_reductions": {"TestReductionsCPU": 146.43033333333565}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 22.96133333333333}, "test_schema_check": {"TestSchemaCheck": 0.2633333333333335, "TestSchemaCheckModeOpInfoCPU": 443.9796666666627}, "test_segment_reductions": {"TestSegmentReductionsCPU": 3.4106666666666654}, "test_serialization": {"TestBothSerializationCPU": 1.039, "TestOldSerialization": 53.202, "TestSerialization": 28.054333333333343, "TestSubclassSerialization": 0.06066666666666667}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.27499999999999997}, "test_shape_ops": {"TestShapeOpsCPU": 5.353999999999996}, "test_show_pickle": {"TestShowPickle": 0.28833333333333333}, "test_sort_and_select": {"TestSortAndSelectCPU": 5.263999999999997}, "test_sparse": {"TestSparseAnyCPU": 2413.6903333333344, "TestSparseCPU": 108.7906666666667, "TestSparseLegacyAndDeprecation": 0.07733333333333332, "TestSparseMaskedReductionsCPU": 3.7946666666666666, "TestSparseMeta": 10.053666666666667, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 10.873999999999974}, "test_sparse_csr": {"TestSparseCSRCPU": 252.30299999999707, "TestSparseCSRSampler": 1.8549999999999998, "TestSparseCompressedCPU": 207.85333333333395, "TestSparseCompressedTritonKernelsCPU": 0.004666666666666666}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 30.764999999999986, "TestFFTDocExamplesCPU": 0.09233333333333336}, "test_stateless": {"TestPythonOptimizeMode": 6.974333333333334, "TestStatelessDeprecation": 4.665666666666666, "TestStatelessFunctionalAPI": 0.7326666666666669}, "test_subclass": {"TestSubclass": 0.6963333333333336}, "test_sympy_utils": {"TestNumbers": 0.055, "TestSingletonInt": 0.009666666666666667, "TestSympyInterp": 9.079, "TestSympySolve": 0.3603333333333334, "TestValueRanges": 5.746666666666667}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.8606666666666672, "TestBufferProtocolCPU": 0.6380000000000005, "TestLikeTensorCreationCPU": 0.013666666666666667, "TestRandomTensorCreationCPU": 5.235666666666667, "TestTensorCreationCPU": 62.884333333333444}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.03466666666666667, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.004666666666666667, "TestTensorBoardPyTorchNumpy": 0.35200000000000004, "TestTensorBoardPytorchGraph": 122.96566666666666, "TestTensorBoardSummary": 0.065, "TestTensorBoardSummaryWriter": 0.011000000000000001, "TestTensorBoardUtils": 0.30833333333333335, "TestTensorBoardWriter": 0.12733333333333333, "TestTensorProtoSummary": 0.018}, "test_tensorexpr": {"TestTensorExprFuser": 226.83333333333334}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.051333333333333335, "TestTensorExprPyBind": 0.34966666666666674}, "test_testing": {"TestAssertClose": 0.18033333333333343, "TestAssertCloseContainer": 0.007666666666666666, "TestAssertCloseErrorMessage": 0.1366666666666667, "TestAssertCloseQuantized": 0.016666666666666666, "TestAssertCloseSparseBSC": 0.032, "TestAssertCloseSparseBSR": 0.065, "TestAssertCloseSparseCOO": 0.04033333333333333, "TestAssertCloseSparseCSC": 0.037, "TestAssertCloseSparseCSR": 0.041, "TestFrameworkUtils": 23.521666666666665, "TestImports": 26.921000000000003, "TestMakeTensorCPU": 1.5136666666666665, "TestOpInfoSampleFunctionsCPU": 4.155999999999989, "TestOpInfos": 0.004666666666666667, "TestTestParametrization": 0.03066666666666668, "TestTestParametrizationDeviceTypeCPU": 3.586999999999998, "TestTestingCPU": 0.31600000000000006}, "test_torch": {"TestBasicVitalSigns": 0.02733333333333333, "TestTorch": 9.019999999999992, "TestTorchDeviceTypeCPU": 38.60200000000008, "TestVitalSignsCudaCPU": 0.0016666666666666668}, "test_transformers": {"TestAttnBiasCPU": 82.70566666666666, "TestAttnMasksCPU": 199.78300000000002, "TestSDPACPU": 827.7179999999998, "TestSDPAFailureModesCPU": 0.036666666666666674, "TestTransformersCPU": 23.105333333333334}, "test_type_hints": {"TestTypeHints": 0.332}, "test_type_info": {"TestDTypeInfo": 0.4126666666666667}, "test_type_promotion": {"TestTypePromotionCPU": 10.131333333333318}, "test_typing": {"TestTyping": 80.85633333333332}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 1069.49366666659}, "test_utils": {"TestAssert": 0.35566666666666663, "TestBottleneck": 15.823, "TestCheckpoint": 0.18866666666666668, "TestCollectEnv": 1.2026666666666666, "TestCppExtensionUtils": 0.14, "TestDataLoaderUtils": 0.135, "TestDeviceUtilsCPU": 34.41766666666743, "TestExtensionUtils": 0.004, "TestHipify": 0.0016666666666666668, "TestHipifyTrie": 0.006666666666666667, "TestONNXUtils": 0.004, "TestRenderUtils": 0.02033333333333333, "TestStandaloneCPPJIT": 6.734000000000001, "TestTraceback": 0.01}, "test_view_ops": {"TestOldViewOpsCPU": 38.73766666666666, "TestViewOpsCPU": 2.2356666666666682, "TestViewOpsLAZY": 3.360999999999983}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.025000000000000005, "WeakKeyDictionaryTestCase": 0.022000000000000002, "WeakTest": 4.204333333333332}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 161.215, "TestXNNPACKOps": 8.682666666666666, "TestXNNPACKRewritePass": 6.240666666666667, "TestXNNPACKSerDes": 13.412333333333335}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0033333333333333335}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.3086666666666667, "TestClassGetItem": 0.0013333333333333333, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0026666666666666666, "TestMisc": 0.004666666666666667, "TestPickling": 0.17800000000000002, "TestPromotion": 0.002}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 23.073666666666664, "TestEinsumPath": 0.0013333333333333333, "TestMisc": 0.008333333333333333}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0003333333333333333, "TestFinfo": 0.0013333333333333333, "TestHalf": 0.0, "TestIinfo": 0.28700000000000003, "TestMisc": 0.0026666666666666666, "TestPythonFloat": 0.001, "TestRepr": 0.004, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0033333333333333335, "TestBooleanIndexing": 0.013666666666666666, "TestBroadcastedAssignments": 0.035666666666666666, "TestFancyIndexingCast": 0.010333333333333333, "TestFloatNonIntegerArgument": 0.02, "TestIndexing": 0.6296666666666669, "TestMultiIndexingAutomated": 0.015333333333333332, "TestMultipleEllipsisError": 0.0026666666666666666, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.03166666666666667, "TestArgmax": 2.7503333333333337, "TestArgmaxArgminCommon": 0.1520000000000001, "TestArgmin": 2.7569999999999992, "TestArrayAttributeDeletion": 0.01, "TestArrayConstruction": 0.07266666666666668, "TestArrayCreationCopyArgument": 0.004333333333333334, "TestArrayInterface": 0.05233333333333332, "TestAssignment": 0.01966666666666667, "TestAttributes": 0.03900000000000001, "TestBinop": 0.029333333333333333, "TestBool": 40.13366666666668, "TestCequenceMethods": 0.0033333333333333335, "TestChoose": 0.03566666666666667, "TestClip": 0.009, "TestCompress": 0.006000000000000001, "TestConversion": 0.07466666666666667, "TestCreation": 0.0036666666666666666, "TestDelMisc": 0.0023333333333333335, "TestDot": 0.10433333333333338, "TestDtypedescr": 0.0023333333333333335, "TestFancyIndexing": 0.04666666666666666, "TestFlag": 0.015666666666666672, "TestFormat": 0.008, "TestFromBuffer": 0.017333333333333336, "TestHash": 0.236, "TestHashing": 0.005, "TestIO": 0.0016666666666666668, "TestInner": 0.39766666666666667, "TestLexsort": 0.026000000000000006, "TestMatmul": 0.7873333333333333, "TestMatmulOperator": 0.5426666666666667, "TestMethods": 2.4739999999999984, "TestMinMax": 0.006666666666666667, "TestMinScalarType": 0.015, "TestNewaxis": 0.005666666666666667, "TestPEP3118Dtype": 0.0033333333333333335, "TestPutmask": 0.016333333333333335, "TestRepeat": 0.03166666666666667, "TestResize": 0.06633333333333334, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.034, "TestSizeOf": 0.013333333333333334, "TestSortFloatMisc": 0.3086666666666667, "TestStats": 0.367, "TestSubscripting": 0.0023333333333333335, "TestTake": 0.054333333333333345, "TestVdot": 0.05200000000000001, "TestViewDtype": 0.009666666666666667, "TestWarnings": 0.008333333333333333, "TestWhere": 1.1336666666666666, "TestWritebackIfCopy": 0.04133333333333333}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.05333333333333332, "TestArgwhere": 0.05566666666666666, "TestArrayComparisons": 0.023333333333333334, "TestBaseRepr": 0.007666666666666668, "TestBinaryRepr": 0.010666666666666666, "TestBoolArray": 4.106, "TestBoolCmp": 0.289, "TestBoolScalar": 0.008333333333333333, "TestBroadcast": 0.009666666666666669, "TestClip": 0.32033333333333347, "TestConvolve": 0.030333333333333334, "TestCorrelate": 0.050666666666666665, "TestCreationFuncs": 1.7716666666666665, "TestCross": 0.08866666666666667, "TestDtypePositional": 0.0023333333333333335, "TestFloatExceptions": 0.010666666666666666, "TestFromiter": 0.0006666666666666666, "TestIndex": 0.01, "TestIndices": 0.05933333333333333, "TestIsclose": 0.17266666666666666, "TestIsscalar": 0.0023333333333333335, "TestLikeFuncs": 0.001, "TestMoveaxis": 0.014666666666666666, "TestNonarrayArgs": 0.1563333333333334, "TestNonzeroAndCountNonzero": 0.40599999999999997, "TestOuterMisc": 0.007666666666666666, "TestRequire": 0.007666666666666666, "TestResize": 0.37733333333333335, "TestRoll": 0.062, "TestRollaxis": 0.007666666666666666, "TestSeterr": 0.007333333333333333, "TestStdVar": 0.04466666666666666, "TestStdVarComplex": 0.019666666666666666, "TestStringFunction": 0.0026666666666666666, "TestTensordot": 0.021666666666666667, "TestTypes": 0.019}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.002, "TestCommonType": 0.34, "TestDocStrings": 0.0006666666666666666, "TestIsSubDType": 0.011666666666666667, "TestScalarTypeNames": 0.03633333333333335}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.12700000000000009, "TestFromInt": 0.012333333333333335, "TestFromString": 0.30266666666666664}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.004, "TestBitCount": 0.0030000000000000005, "TestClassGetItem": 0.008, "TestClassGetitemMisc": 0.0030000000000000005, "TestIsInteger": 0.0023333333333333335}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.14233333333333334, "TestBaseMath": 13.465666666666666, "TestBitShifts": 0.14400000000000002, "TestComplexDivision": 0.09166666666666667, "TestConversion": 0.09333333333333334, "TestHash": 0.001, "TestModulus": 1.6006666666666665, "TestMultiply": 0.001, "TestNegative": 0.028333333333333335, "TestPower": 0.19299999999999998, "TestRepr": 0.0023333333333333335, "TestScalarOpsMisc": 0.07633333333333338, "TestScalarSubclassingMisc": 0.047333333333333366, "TestSubtract": 0.027, "TestTypes": 20.512666666666664}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.3463333333333333, "TestAtleast2d": 0.022333333333333334, "TestAtleast3d": 0.023666666666666666, "TestBlock": 0.03700000000000002, "TestConcatenate": 0.2710000000000002, "TestHstack": 0.029, "TestStackMisc": 0.021000000000000008, "TestVstack": 0.030666666666666672}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.017, "TestFFTShift": 10.210333333333333, "TestIRFFTN": 0.005333333333333333, "TestRFFTFreq": 0.016}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 5.084, "TestFFTShift": 0.27366666666666667, "TestFFTThreadSafe": 4.859333333333333}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.323}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0033333333333333335, "TestUnique": 0.6290000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.011333333333333334, "TestAmax": 0.009333333333333334, "TestAmin": 0.009333333333333332, "TestAngle": 0.012666666666666666, "TestAny": 0.010666666666666666, "TestAverage": 0.044333333333333336, "TestBincount": 0.06366666666666666, "TestCheckFinite": 0.0036666666666666666, "TestCopy": 0.012666666666666666, "TestCorrCoef": 0.055333333333333325, "TestCov": 0.09366666666666669, "TestCumprod": 0.05366666666666666, "TestCumsum": 0.07266666666666667, "TestDelete": 0.028333333333333335, "TestDiff": 0.16066666666666665, "TestDigitize": 0.020000000000000004, "TestExtins": 0.008, "TestFilterwindows": 0.7886666666666673, "TestFlip": 0.04966666666666667, "TestGradient": 0.278, "TestInsert": 0.012666666666666666, "TestInterp": 0.06466666666666669, "TestKaiser": 0.014333333333333332, "TestMedian": 0.20533333333333337, "TestMeshgrid": 0.07500000000000001, "TestMsort": 0.0, "TestPercentile": 0.15066666666666675, "TestPiecewise": 0.014666666666666666, "TestProd": 0.052333333333333336, "TestPtp": 0.016, "TestQuantile": 0.03566666666666667, "TestRot90": 0.3663333333333334, "TestSelect": 0.011000000000000001, "TestSinc": 0.011666666666666667, "TestSortComplex": 0.014666666666666666, "TestTrapz": 0.008, "TestTrimZeros": 0.013000000000000003, "TestUnique": 0.005, "Test_I0": 0.018000000000000002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.48600000000000015, "TestHistogramOptimBinNums": 0.04466666666666668, "TestHistogramdd": 0.26266666666666666}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.002, "TestConcatenator": 0.015, "TestDiagIndices": 0.008, "TestDiagIndicesFrom": 0.011666666666666667, "TestFillDiagonal": 0.04, "TestGrid": 0.02033333333333334, "TestIndexExpression": 0.024333333333333332, "TestIx_": 0.01, "TestNdIndex": 0.0016666666666666668, "TestNdenumerate": 0.0023333333333333335, "TestRavelUnravelIndex": 0.379}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.03133333333333333, "TestApplyOverAxes": 0.0030000000000000005, "TestArraySplit": 0.34366666666666673, "TestColumnStack": 0.017666666666666667, "TestDsplit": 0.02, "TestDstack": 0.030000000000000002, "TestExpandDims": 0.015333333333333332, "TestHsplit": 0.024999999999999998, "TestKron": 0.031000000000000003, "TestMayShareMemory": 0.0030000000000000005, "TestPutAlongAxis": 0.026, "TestSplit": 0.012666666666666668, "TestSqueeze": 0.06500000000000002, "TestTakeAlongAxis": 0.43, "TestTile": 0.19466666666666665, "TestVsplit": 0.018333333333333333}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.063, "TestEye": 0.5980000000000001, "TestFliplr": 0.011333333333333334, "TestFlipud": 0.010666666666666666, "TestHistogram2d": 0.08066666666666668, "TestTri": 0.216, "TestTrilIndicesFrom": 0.0030000000000000005, "TestTriuIndices": 0.007, "TestTriuIndicesFrom": 0.0026666666666666666, "TestVander": 0.041}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0023333333333333335, "TestCommonType": 0.36866666666666664, "TestImag": 0.019666666666666666, "TestIscomplex": 0.007666666666666666, "TestIscomplexobj": 0.006333333333333334, "TestIsfinite": 0.016666666666666666, "TestIsinf": 0.013999999999999999, "TestIsnan": 0.01633333333333333, "TestIsneginf": 0.0030000000000000005, "TestIsposinf": 0.0030000000000000005, "TestIsreal": 0.013000000000000003, "TestIsrealobj": 0.0023333333333333335, "TestIsscalar": 0.0023333333333333335, "TestMintypecode": 0.006333333333333334, "TestNanToNum": 0.028333333333333335, "TestReal": 0.02266666666666667, "TestRealIfClose": 0.012666666666666666}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.5223333333333334, "TestCond": 0.39000000000000007, "TestDet": 0.21166666666666667, "TestEig": 0.05833333333333335, "TestEigh": 0.04000000000000001, "TestEighCases": 0.0, "TestEigvals": 0.08233333333333336, "TestEigvalsh": 0.036000000000000004, "TestEigvalshCases": 0.0003333333333333333, "TestInv": 0.06933333333333334, "TestLstsq": 0.2903333333333334, "TestMatrixRank": 0.7936666666666667, "TestMisc": 0.10066666666666668, "TestMisc2": 0.005333333333333333, "TestMultiDot": 0.1376666666666667, "TestNormDouble": 1.2000000000000002, "TestNormInt64": 1.3840000000000001, "TestNormSingle": 1.3143333333333334, "TestNorm_NonSystematic": 0.005333333333333333, "TestPinv": 0.21166666666666667, "TestPinvHermitian": 0.04633333333333334, "TestQR": 1.164333333333329, "TestSVD": 0.07200000000000001, "TestSVDHermitian": 0.14100000000000001, "TestSolve": 0.357, "TestTensorinv": 0.03966666666666666, "TestTensorsolve": 0.008666666666666668}, "torch_np/test_basic": {"TestArrayToSequence": 0.011333333333333334, "TestCopyTo": 0.008, "TestCtorNested": 0.005333333333333333, "TestDefaultDtype": 0.010333333333333333, "TestDivmod": 0.025333333333333333, "TestExport": 0.0003333333333333333, "TestMisc": 0.0030000000000000005, "TestNormalizations": 0.006000000000000001, "TestOneArr": 0.44566666666666704, "TestOneArrAndAxesTuple": 0.01566666666666667, "TestOneArrAndAxis": 0.23800000000000013, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.01566666666666667, "TestPythonArgsToArray": 0.020000000000000004, "TestSequenceOfArrays": 0.027666666666666683, "TestSequenceOfArraysToSingle": 0.014, "TestShapeLikeToArray": 0.007333333333333333, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.49366666666666675}, "torch_np/test_dtype": {"TestConvertDType": 0.37333333333333346}, "torch_np/test_function_base": {"TestAppend": 0.3713333333333333}, "torch_np/test_ndarray_methods": {"TestAmax": 0.020333333333333335, "TestAmin": 0.018000000000000002, "TestArgmax": 3.0150000000000006, "TestArgmaxArgminCommon": 0.17033333333333342, "TestArgmin": 3.785333333333332, "TestContains": 0.0033333333333333335, "TestIndexing": 0.33266666666666667, "TestIter": 0.008333333333333333, "TestNoExtraMethods": 0.01333333333333333, "TestNonzero": 0.3063333333333333, "TestRavel": 0.012666666666666668, "TestReshape": 0.006666666666666667, "TestTranspose": 0.014333333333333332}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.014666666666666666, "TestNEP50Table": 0.002}, "torch_np/test_random": {"TestChoice": 0.017666666666666667, "TestNumpyGlobal": 0.005666666666666667, "TestScalarReturn": 0.3383333333333334, "TestShuffle": 0.016666666666666666}, "torch_np/test_reductions": {"TestAll": 0.018666666666666668, "TestAny": 0.019666666666666666, "TestFlatnonzero": 0.3466666666666667, "TestGenericCumSumProd": 0.028, "TestGenericReductions": 3.0286666666666364, "TestMean": 0.038, "TestSum": 0.37366666666666665}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.3540000000000001, "TestIsScalar": 0.041000000000000016}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.8206666666666664, "TestNdarrayDunderVsUfunc": 0.3156666666666668, "TestUfuncDtypeKwd": 0.007666666666666666, "TestUnaryUfuncs": 0.3523333333333334}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.4440000000000001}}, "slow": {"backends/xeon/test_launch": {"TestTorchrun": 5.613}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.193}, "distributions/test_constraints": {"test_constraints": 0.2530000000000001}, "distributions/test_distributions": {"TestAgainstScipy": 0.004, "TestConstraints": 0.002, "TestDistributionShapes": 0.04300000000000003, "TestDistributions": 0.1360000000000001, "TestFunctors": 0.004, "TestJit": 0.008, "TestKL": 0.013000000000000005, "TestLazyLogitsInitialization": 0.002, "TestNumericalStability": 0.010000000000000002, "TestRsample": 0.007, "TestValidation": 0.004}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.36200000000000004}, "dynamo/test_after_aot": {"TestAfterAot": 0.176}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.253}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 0.29700000000000004}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.276}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 0.376}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.002, "TestCustomBackendAPI": 0.003, "TestExplainWithBackend": 0.001, "TestOptimizations": 0.281}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 0.182}, "dynamo/test_base_output": {"TestBaseOutput": 0.005}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 0.168}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 0.001, "BytecodeTests": 0.185}, "dynamo/test_compile": {"InPlaceCompilationTests": 0.231, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.183}, "dynamo/test_config": {"ConfigTests": 0.18}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.003, "CppGuardManagerFuncTorchHigherOrderOpTests": 0.07500000000000005, "CppGuardManagerFunctionTests": 0.2770000000000002, "CppGuardManagerHigherOrderOpTests": 0.09900000000000007, "CppGuardManagerMiscTests": 0.6310000000000003, "CppGuardManagerReproTests": 0.21400000000000016}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.134}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.275}, "dynamo/test_decorators": {"DecoratorTests": 0.193}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.013000000000000001}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 0.03500000000000001, "DynamicShapesCtxManagerTests": 0.04700000000000002, "DynamicShapesExportTests": 2654.502999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 0.07800000000000006, "DynamicShapesFunctionTests": 0.3070000000000002, "DynamicShapesHigherOrderOpTests": 0.10600000000000007, "DynamicShapesMiscTests": 0.5680000000000004, "DynamicShapesNNModuleTests": 0.09500000000000006, "DynamicShapesReproTests": 0.25300000000000017, "DynamicShapesSubGraphTests": 0.04900000000000003, "DynamicShapesTestSDPA": 0.004}, "dynamo/test_exc": {"ExcTests": 0.012}, "dynamo/test_exceptions": {"ExceptionTests": 0.184}, "dynamo/test_export": {"ExportTests": 0.23100000000000018}, "dynamo/test_export_mutations": {"MutationExportTests": 0.179}, "dynamo/test_frame_init": {"FrameInitTests": 0.175}, "dynamo/test_functions": {"DefaultsTests": 0.02000000000000001, "FunctionTests": 0.5790000000000003}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.263}, "dynamo/test_global": {"TestGlobals": 0.259}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.2}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.012000000000000002, "FuncTorchHigherOrderOpTests": 0.08200000000000006, "HigherOrderOpTests": 0.4650000000000001, "HigherOrderOpVmapGuardTests": 0.017000000000000005}, "dynamo/test_hooks": {"HooksTests": 0.29400000000000004}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 0.19700000000000004, "InlineInbuiltNNModulesExportTests": 0.17900000000000013, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 0.07400000000000005, "InlineInbuiltNNModulesFunctionTests": 0.2950000000000002, "InlineInbuiltNNModulesHigherOrderOpTests": 0.09800000000000007, "InlineInbuiltNNModulesMiscTests": 0.4820000000000004, "InlineInbuiltNNModulesNNModuleTests": 0.07400000000000005}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 0.184}, "dynamo/test_interop": {"InteropTests": 0.183}, "dynamo/test_logging": {"LoggingTests": 0.34700000000000003}, "dynamo/test_minifier": {"MinifierTests": 0.182}, "dynamo/test_misc": {"MiscTests": 0.46000000000000035, "TestTracer": 0.001}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.003}, "dynamo/test_modules": {"NNModuleTests": 0.33000000000000007, "OptimizedModuleTest": 0.037000000000000026}, "dynamo/test_nops": {"NopTests": 0.272}, "dynamo/test_optimizers": {"End2EndTests": 0.175, "OptimizerTests": 0.171}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.182}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.201}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.168}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.182}, "dynamo/test_recompiles": {"RecompileTests": 0.181}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.18}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.17600000000000002}, "dynamo/test_repros": {"ReproTests": 0.2710000000000002}, "dynamo/test_resume": {"ResumeFunctionTests": 0.207}, "dynamo/test_sdpa": {"TestSDPA": 0.266}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.184}, "dynamo/test_sources": {"SourceTests": 0.246}, "dynamo/test_structured_trace": {"StructuredTraceTest": 0.276}, "dynamo/test_subclasses": {"SubclassTests": 0.404, "TestNestedTensor": 0.027000000000000017}, "dynamo/test_subgraphs": {"SubGraphTests": 0.3320000000000001}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.001, "TraceRuleTests": 0.18}, "dynamo/test_triton_kernels": {"KernelTests": 0.017000000000000008, "MutationTests": 0.003, "NoOptimizationKernelTests": 0.012000000000000004, "no_opt_test_class": 0.017000000000000008}, "dynamo/test_unspec": {"UnspecTests": 0.21700000000000003}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.256}, "dynamo/test_view": {"ViewTests": 0.175}, "export/test_converter": {"TestConverter": 0.378}, "export/test_db": {"ExampleTests": 0.28600000000000003}, "export/test_experimental": {"TestExperiment": 0.28500000000000003}, "export/test_export": {"TestDynamismExpression": 0.005, "TestExport": 0.1520000000000001, "TestExportCustomClass": 0.436, "TestOneOffModelExportResult": 0.011000000000000003}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.005, "NonStrictExportTestExport": 0.1510000000000001}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.004, "PreDispatchExportTestExport": 0.1410000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.175}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.835}, "export/test_hop": {"TestHOPCPU": 0.02000000000000001, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.16299999999999998, "TestLiftUnlift": 0.0175}, "export/test_pass_infra": {"TestPassInfra": 0.271}, "export/test_passes": {"TestPasses": 0.28400000000000003}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.006, "RetraceExportTestExport": 0.17900000000000013}, "export/test_safeguard": {"TestSafeguard": 0.166}, "export/test_schema": {"TestSchema": 0.264}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.005, "SerDesExportPreDispatchTestExport": 0.16000000000000011, "SerDesExportTestDynamismExpression": 0.006, "SerDesExportTestExport": 0.1510000000000001}, "export/test_serialize": {"TestDeserialize": 0.06100000000000005, "TestOpVersioning": 0.005, "TestSaveLoad": 0.007, "TestSchemaVersioning": 0.001, "TestSerialize": 0.361, "TestSerializeCustomClass": 0.002}, "export/test_sparse": {"TestSparseProp": 0.5030000000000001}, "export/test_tools": {"TestExportTools": 0.28200000000000003}, "export/test_torchbind": {"TestCompileTorchbind": 1.7980000000000003, "TestExportTorchbind": 3.3729999999999998, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.175}, "export/test_unflatten": {"TestUnflatten": 0.301}, "export/test_upgrade": {"TestUpgrade": 0.17400000000000002}, "export/test_verifier": {"TestVerifier": 0.273}, "functorch/test_aotdispatch": {"TestAOTAutograd": 0.1430000000000001, "TestAOTAutogradWithDynamo": 0.12300000000000008, "TestAOTDispatch": 0.009000000000000001, "TestAOTExport": 0.02900000000000002, "TestAOTModuleSimplified": 0.007, "TestEagerFusionModuleInfoCPU": 216.70200000000006, "TestEagerFusionOpInfoCPU": 2235.8409999999917, "TestPartitioning": 0.011000000000000003, "TestPythonKeyCPU": 0.014000000000000005}, "functorch/test_control_flow": {"TestControlFlow": 0.281, "TestControlFlowTraced": 0.22000000000000017}, "functorch/test_dims": {"TestMin": 0.393, "TestMinFunctorchOnly": 0.04000000000000003}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.03300000000000002, "TestAutogradFunctionVmapAPICPU": 0.014000000000000002, "TestCompileTransformsCPU": 0.003, "TestComposabilityCPU": 0.05100000000000003, "TestExamplesCorrectnessCPU": 0.04200000000000001, "TestFunctionalizeCPU": 0.02100000000000001, "TestGradTransformCPU": 0.06400000000000004, "TestHelpersCPU": 0.009000000000000001, "TestHessianCPU": 0.004, "TestHigherOrderOperatorInteractionCPU": 0.020000000000000004, "TestJacCPU": 0.11700000000000009, "TestJvpCPU": 0.168, "TestLinearizeCPU": 0.005, "TestMakeFunctional": 0.02000000000000001, "TestSliceArgnums": 0.009000000000000001, "TestVmapJvpInplaceViewCPU": 0.006, "TestVmapOfGradCPU": 0.007}, "functorch/test_logging": {"TestAOTLogging": 0.19}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.239, "RandomOpTestCase": 0.001, "ReduceTestCase": 0.009000000000000001, "TestMemoryEfficientOpAuthoring": 0.001}, "functorch/test_minifier": {"TestMinifier": 0.197}, "functorch/test_ops": {"TestOperatorsCPU": 0.7420000000000002}, "functorch/test_parsing": {"TestAnonymousAxis": 0.241, "TestParsedExpression": 0.005, "TestParsingUtils": 0.008, "TestValidateRearrangeExpressions": 0.007}, "functorch/test_rearrange": {"TestRearrange": 0.189}, "functorch/test_vmap": {"TestRandomnessCPU": 0.4320000000000002, "TestTransformFailureCPU": 0.007, "TestVmapAPI": 0.06400000000000004, "TestVmapBatchedGradientCPU": 0.03300000000000002, "TestVmapDeviceTypeCPU": 0.005, "TestVmapNestedTensorCPU": 0.014000000000000005, "TestVmapOperators": 0.16500000000000012, "TestVmapOperatorsOpInfoCPU": 3.9039999999998747}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.0079999999999028}, "higher_order_ops/test_with_effects": {"TestWithEffects": 14.282}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 15.716}, "inductor/test_binary_folding": {"FreezingCpuTests": 0.003}, "inductor/test_codecache": {"TestFxGraphCache": 0.02700000000000001, "TestFxGraphCacheHashing": 0.009000000000000001, "TestUtils": 0.001, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.281}, "inductor/test_compile_worker": {"TestCompileWorker": 0.305}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 0.32500000000000023, "TestAutogradWithCompiledAutograd": 0.34600000000000025, "TestCompiledAutograd": 0.060000000000000046, "TestCustomOpWithCompiledAutograd": 0.09300000000000007}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 0.026000000000000016, "CompiledOptimizerTests": 0.35500000000000026}, "inductor/test_config": {"TestInductorConfig": 0.314}, "inductor/test_control_flow": {"CondTests": 0.007, "WhileLoopTests": 0.004}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 0.05300000000000004, "TestCppWrapper": 118.75150000000019}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 650.2729999999996, "TestCppWrapper": 1648.1769999999997}, "inductor/test_cpu_repro": {"CPUReproTests": 3361.207000000002}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 0.1390000000000001, "TestSelectAlgorithmDynamicShapesCPU": 0.1370000000000001}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 0.203}, "inductor/test_debug_trace": {"TestDebugTrace": 0.002}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.004}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 0.28700000000000003}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 428.622}, "inductor/test_extension_backend": {"ExtensionBackendTests": 2.636}, "inductor/test_flex_attention": {"TestFlexAttention": 0.014000000000000005, "TestTemplatedSDPA": 0.01800000000000001}, "inductor/test_foreach": {"ForeachTests": 0.04600000000000003}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 0.01900000000000001, "SDPAPatternRewriterCpuTests": 0.031000000000000014}, "inductor/test_fx_fusion": {"TestFxFusion": 0.17200000000000001}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.016}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.176, "TestGroupBatchFusion": 0.001, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.009000000000000001, "TestIndexingSimplification": 0.305}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 0.023000000000000013}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.001}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 0.010000000000000002, "TestPatternMatcher": 0.24000000000000007}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.11600000000000002}, "inductor/test_profiler": {"DynamoProfilerTests": 0.005}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 0.394}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.007}, "inductor/test_torchbind": {"TestTorchbind": 0.278}, "inductor/test_torchinductor": {"CpuTests": 377.5059999999925, "SweepInputsCpuTest": 0.06700000000000005, "TestFull": 0.001}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 332.6649999999927}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 0.8400000000000005}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.002}, "inductor/test_triton_kernels": {"KernelTests": 0.03300000000000002, "MutationTests": 0.004, "NoOptimizationKernelTests": 0.015000000000000006, "no_opt_test_class": 0.02000000000000001}, "inductor/test_utils": {"TestUtils": 0.279}, "lazy/test_debug_util": {"DebugUtilTest": 0.185}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.17}, "lazy/test_generator": {"LazyGeneratorTest": 0.173}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.253}, "lazy/test_step_closures": {"ClosuresTest": 0.167}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.002, "TestLazyOpInfoCPU": 0.25200000000000017, "TestLazyTensor": 0.003}, "nn/test_convolution": {"TestConvolutionNN": 0.04000000000000003, "TestConvolutionNNDeviceTypeCPU": 0.6320000000000005}, "nn/test_dropout": {"TestDropoutNN": 0.009000000000000001, "TestDropoutNNDeviceTypeCPU": 0.1}, "nn/test_embedding": {"TestEmbeddingNN": 0.023000000000000013, "TestEmbeddingNNDeviceTypeCPU": 0.1520000000000001}, "nn/test_init": {"TestNNInit": 0.468}, "nn/test_lazy_modules": {"TestLazyModules": 0.16100000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.16100000000000003, "TestLoadStateDictSwap": 0.002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.007, "TestModuleHookNN": 0.016000000000000007, "TestModuleHooks": 0.126, "TestStateDictHooks": 0.014000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 0.099, "TestMultiheadAttentionNNDeviceTypeCPU": 0.012000000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.17400000000000002}, "nn/test_parametrization": {"TestNNParametrization": 0.057000000000000044, "TestNNParametrizationDeviceCPU": 0.002}, "nn/test_pooling": {"TestAvgPool": 0.007, "TestPoolingNN": 0.010000000000000002, "TestPoolingNNDeviceTypeCPU": 19.036000000000058}, "nn/test_pruning": {"TestPruningNN": 0.14600000000000002}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.022000000000000006}, "profiler/test_memory_profiler": {"TestDataFlow": 0.011000000000000003, "TestIdentifyGradients": 0.005, "TestMemoryProfiler": 0.164, "TestMemoryProfilerE2E": 0.11400000000000002}, "profiler/test_profiler": {"TestExecutionTrace": 0.008, "TestExperimentalUtils": 0.02700000000000001, "TestProfiler": 0.046000000000000034, "TestProfilerCUDA": 0.002, "TestProfilerITT": 0.002, "TestRecordFunction": 0.004, "TestTorchTidyProfiler": 0.022000000000000013}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.17300000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.168}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 0.18600000000000003}, "test_ao_sparsity": {"TestActivationSparsifier": 0.001, "TestBaseDataScheduler": 0.004, "TestBaseDataSparsifier": 0.003, "TestBaseSparsifier": 0.009000000000000001, "TestBaseStructuredSparsifier": 0.01800000000000001, "TestComposability": 0.007, "TestCubicScheduler": 0.008, "TestFPGMPruner": 0.002, "TestFakeSparsity": 0.004, "TestFxComposability": 0.005, "TestNearlyDiagonalSparsifier": 0.005, "TestNormDataSparsifiers": 0.003, "TestQuantizationUtils": 0.002, "TestQuantizedSparseKernels": 0.271, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.002, "TestScheduler": 0.004, "TestSparsityUtilFunctions": 0.008, "TestWeightNormSparsifier": 0.006}, "test_autocast": {"TestAutocastCPU": 0.17800000000000002, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.003}, "test_autograd": {"TestAllowMutationOnSaved": 0.012000000000000004, "TestAutograd": 21.403000000000322, "TestAutogradComplex": 0.002, "TestAutogradDeviceTypeCPU": 0.10300000000000006, "TestAutogradForwardMode": 0.02900000000000002, "TestAutogradForwardModeBatchedGrad": 0.005, "TestAutogradFunctional": 0.1230000000000001, "TestAutogradInferenceMode": 0.01900000000000001, "TestAutogradLogging": 0.003, "TestAutogradMultipleDispatchCPU": 0.012000000000000004, "TestMultithreadAutograd": 0.011000000000000003, "TestNestedCheckpoint": 0.014000000000000005}, "test_autograd_fallback": {"TestAutogradFallback": 0.19700000000000004}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 17.523999999998665}, "test_bundled_inputs": {"TestBundledInputs": 0.17800000000000002}, "test_comparison_utils": {"TestComparisonUtils": 0.17300000000000001}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.015000000000000006}, "test_content_store": {"TestContentStoreCPU": 0.004}, "test_cpp_api_parity": {"TestCppApiParity": 0.3110000000000002}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.016000000000000004, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.015000000000000003, "TestMAIATensor": 0.004, "TestORTTensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 0.031000000000000017}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.5239999999999996}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 2.954999999999998}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.562}, "test_custom_backend": {"TestCustomBackend": 0.534}, "test_custom_ops": {"MiniOpTest": 0.07600000000000005, "MiniOpTestOther": 0.013000000000000005, "TestCustomOp": 0.09400000000000007, "TestCustomOpAPI": 0.03000000000000002, "TestCustomOpTestingCPU": 0.03300000000000002, "TestCustomOperators": 0.7150000000000001, "TestGenerateOpcheckTests": 0.010000000000000002}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 167.345, "TestConcatDataset": 0.006, "TestConvAfterFork": 0.0, "TestCustomPinFn": 0.002, "TestDataLoader": 0.001, "TestDataLoaderDeviceTypeCPU": 0.003, "TestDataLoaderPersistentWorkers": 0.002, "TestDatasetRandomSplit": 0.009000000000000001, "TestDictDataLoader": 0.002, "TestIndividualWorkerQueue": 0.0, "TestNamedTupleDataLoader": 0.001, "TestSetAffinity": 0.001, "TestStackDataset": 0.009000000000000001, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.005}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.003, "TestDataChunk": 0.007, "TestDataFramesPipes": 0.006, "TestFunctionalIterDataPipe": 0.024000000000000007, "TestFunctionalMapDataPipe": 0.013, "TestGraph": 0.007, "TestIterDataPipeCountSampleYielded": 0.006, "TestIterDataPipeGraphFastForward": 0.006, "TestIterDataPipeSingletonConstraint": 0.005, "TestIterableDataPipeBasic": 0.065, "TestSerialization": 0.002, "TestSharding": 0.009000000000000001, "TestStreamWrapper": 0.398, "TestTyping": 0.008}, "test_decomp": {"DecompOneOffTestsCPU": 0.005, "HasDecompTest": 0.004, "TestDecompCPU": 5.4700000000001525}, "test_deploy": {"TestFreezer": 0.174}, "test_dispatch": {"TestDispatch": 0.18300000000000002, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCPU": 0.11800000000000009}, "test_dynamic_shapes": {"TestDimConstraints": 0.004, "TestFloorDiv": 0.004, "TestPySymInt": 0.30600000000000005, "TestSymNumberMagicMethods": 0.21600000000000016}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 0.10900000000000008, "TestExpandedWeightHelperFunctionCPU": 0.009000000000000001, "TestExpandedWeightModuleCPU": 0.10200000000000008}, "test_fake_tensor": {"FakeTensorConstHandling": 0.010000000000000002, "FakeTensorConverterTest": 0.010000000000000002, "FakeTensorDispatchCache": 0.01900000000000001, "FakeTensorOpInfoTestCPU": 0.011000000000000003, "FakeTensorOperatorInvariants": 0.010000000000000002, "FakeTensorPropTest": 0.004, "FakeTensorSerialization": 0.002, "FakeTensorTest": 0.037000000000000026, "PropagateRealTensorsFakeTensorConstHandling": 0.010000000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.010000000000000002, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.011000000000000003, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.011000000000000003, "PropagateRealTensorsFakeTensorPropTest": 0.004, "PropagateRealTensorsFakeTensorTest": 0.03800000000000003}, "test_flop_counter": {"TestFlopCounter": 0.027000000000000014}, "test_foreach": {"TestForeachCPU": 3.6199999999997154}, "test_function_schema": {"TestFunctionSchema": 0.203}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 224.21}, "test_functional_optim": {"TestFunctionalOptimParity": 0.298}, "test_functionalization": {"TestCrossRefFunctionalization": 0.05600000000000004, "TestFunctionalization": 0.31900000000000006}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.001}, "test_futures": {"TestFuture": 0.196}, "test_fx": {"AnnotationsTest": 0.007, "TestCSEPass": 0.015000000000000006, "TestCommonPass": 0.008, "TestConstFold": 0.02000000000000001, "TestConstParamShapeInControlFlow": 0.007, "TestDCE": 0.007, "TestFX": 0.18500000000000014, "TestFXAPIBackwardCompatibility": 0.005, "TestFunctionalTracing": 0.12500000000000008, "TestMatcher": 0.008, "TestOperatorSignaturesCPU": 4.16399999999996, "TestPassManager": 0.006, "TestSourceMatcher": 0.005, "TestSubgraphRewriter": 0.027000000000000017, "TestVisionTracing": 733.9370000000004, "TypeCheckerTest": 0.03100000000000002}, "test_fx_experimental": {"TestFXExperimental": 0.04100000000000003, "TestNormalizeOperatorsCPU": 1.0090000000000001, "TestTranslationValidation": 0.004}, "test_fx_passes": {"TestFXGraphPasses": 0.29700000000000004, "TestFXMatcherUtils": 0.017000000000000008}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.185}, "test_import_stats": {"TestImportTime": 0.25}, "test_indexing": {"NumpyTestsCPU": 0.02100000000000001, "TestIndexingCPU": 0.06600000000000004}, "test_itt": {"TestItt": 0.166}, "test_jit": {"TestAliasAnalysis": 0.004, "TestAsync": 0.024000000000000014, "TestAtenPow": 0.001, "TestAutodiffJit": 0.006, "TestAutodiffSubgraphSlicing": 0.022000000000000013, "TestAwait": 0.022000000000000006, "TestBackends": 0.006, "TestBackendsWithCompiler": 0.004, "TestBatchMM": 0.008, "TestBuiltins": 0.004, "TestClassType": 0.047000000000000035, "TestComplex": 0.014000000000000005, "TestCustomOperators": 0.017000000000000008, "TestDCE": 0.002, "TestDataParallel": 0.005, "TestDataclasses": 0.008, "TestDeviceAnalysis": 0.01900000000000001, "TestDict": 0.03200000000000002, "TestDtypeAnalysis": 2.961, "TestDtypeCustomRulesCPU": 11.358000000000008, "TestEnum": 0.017000000000000008, "TestFreezing": 0.05400000000000004, "TestFrontend": 0.002, "TestFrozenOptimizations": 0.027000000000000017, "TestFunctionalBlocks": 0.001, "TestFunctionalToInplaceActivation": 0.004, "TestGenerator": 0.005, "TestGetDefaultAttr": 0.003, "TestGraphRewritePasses": 0.001, "TestHash": 0.009000000000000001, "TestHooks": 0.023000000000000013, "TestIgnorableArgs": 0.002, "TestIgnoreContextManager": 0.003, "TestInplaceToFunctionalActivation": 0.002, "TestIsinstance": 0.02900000000000002, "TestJit": 6.467000000000015, "TestJitGeneratedModule": 56.59099999999982, "TestJitProfiler": 0.001, "TestJitUtils": 0.008, "TestList": 0.11300000000000009, "TestLogging": 0.006, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.023000000000000013, "TestMixTracingScripting": 0.025000000000000015, "TestModels": 29.71400000000001, "TestModuleAPIs": 0.003, "TestModuleContainers": 0.01800000000000001, "TestModuleInterface": 0.016000000000000007, "TestModules": 0.001, "TestNamedTuple": 0.016000000000000007, "TestNnapiBackend": 0.03000000000000002, "TestOpDecompositions": 0.002, "TestOptimizeForMobilePreserveDebugInfo": 0.007, "TestParametrization": 0.002, "TestPeephole": 0.03800000000000003, "TestProducerVersion": 0.001, "TestProfiler": 0.7760000000000001, "TestPythonBindings": 0.008, "TestPythonBuiltinOP": 0.015000000000000006, "TestPythonIr": 0.004, "TestRecursiveScript": 0.03700000000000002, "TestRemoveMutation": 0.008, "TestSaveLoad": 0.016000000000000007, "TestSaveLoadFlatbuffer": 0.010000000000000002, "TestSaveLoadForOpVersion": 0.011000000000000003, "TestScript": 26.56600000000046, "TestScriptDict": 0.011000000000000003, "TestScriptList": 0.02100000000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.01800000000000001, "TestScriptProfile": 0.005, "TestSlice": 0.01800000000000001, "TestSparse": 0.004, "TestStringFormatting": 0.022000000000000013, "TestSymbolicShapeAnalysis": 0.025000000000000015, "TestTensorBuiltins": 0.006, "TestTensorCreationOps": 0.006, "TestTensorMethods": 0.002, "TestTorchbind": 0.33400000000000013, "TestTracer": 0.1380000000000001, "TestTypeSharing": 0.02900000000000002, "TestTypesAndAnnotation": 0.016000000000000007, "TestTyping": 0.03900000000000003, "TestUnion": 0.04900000000000004, "TestUnsupportedOps": 0.002, "TestUpgraders": 0.014000000000000005, "TestWarn": 0.007, "TestWith": 0.006}, "test_jit_autocast": {"TestAutocast": 0.046000000000000034, "TestJitTraceAutocast": 0.009000000000000001}, "test_jit_disabled": {"TestJitDisabled": 0.158}, "test_jit_fuser_te": {"TestFuserCommon": 0.001, "TestLoopnestRandomizationCPU": 0.001, "TestNNCOpInfoCPU": 9757.929000000033, "TestTEFuserDynamic": 29.279, "TestTEFuserStatic": 23.673000000000002}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCPU": 22.5, "TestModel": 17.740000000000002, "TestOpCPU": 142.43799999999996}, "test_legacy_vmap": {"TestVmapAPI": 0.49900000000000005, "TestVmapAPILegacy": 0.04300000000000003, "TestVmapBatchedGradientCPU": 0.02900000000000002, "TestVmapBatchedGradientLegacyCPU": 0.02900000000000002, "TestVmapOperators": 0.05200000000000004, "TestVmapOperatorsLegacy": 0.05200000000000004}, "test_license": {"TestLicense": 0.173}, "test_linalg": {"TestLinalgCPU": 147.36800000000193}, "test_logging": {"LoggingTest": 0.167}, "test_masked": {"TestMaskedCPU": 0.17000000000000012}, "test_maskedtensor": {"TestBasicsCPU": 0.016000000000000007, "TestBinary": 0.08200000000000006, "TestOperatorsCPU": 1.0719999999999938, "TestReductions": 0.02000000000000001, "TestUnary": 0.1530000000000001}, "test_meta": {"TestMetaCPU": 7.238000000000434, "TestMetaConverter": 0.02000000000000001}, "test_mkl_verbose": {"TestMKLVerbose": 0.171}, "test_mkldnn": {"TestMkldnnCPU": 0.08500000000000006}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.17500000000000002}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 0.171}, "test_mobile_optimizer": {"TestOptimizer": 0.244}, "test_model_dump": {"TestModelDump": 0.24200000000000002}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.259}, "test_module_init": {"TestModuleInitCPU": 0.3890000000000003}, "test_module_tracker": {"TestModuleTracker": 0.176}, "test_modules": {"TestModuleCPU": 3.9709999999996906}, "test_monitor": {"TestMonitor": 0.17400000000000002, "TestMonitorTensorboard": 0.331}, "test_multiprocessing": {"TestMultiprocessing": 0.10900000000000001}, "test_multiprocessing_spawn": {"ErrorTest": 0.001, "ForkTest": 0.008, "SpawnTest": 0.17500000000000002}, "test_namedtensor": {"TestNamedTensor": 0.08700000000000006}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 0.144}, "test_native_functions": {"TestNativeFunctions": 0.17900000000000002}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.02900000000000002}, "test_nestedtensor": {"TestNestedTensor": 0.05100000000000004, "TestNestedTensorAutogradCPU": 0.06300000000000004, "TestNestedTensorDeviceTypeCPU": 0.21000000000000016, "TestNestedTensorSubclassCPU": 0.23200000000000018}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.001, "TestFusionUtils": 0.002, "TestNN": 0.9600000000000007, "TestNNDeviceTypeCPU": 1.2899999999999696, "TestUtils": 0.001}, "test_numba_integration": {"TestNumbaIntegration": 0.008}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.136}, "test_openmp": {"TestOpenMP_ParallelFor": 0.002}, "test_ops": {"TestCommonCPU": 25.792999999999545, "TestCompositeComplianceCPU": 1706.429999999943, "TestFakeTensorCPU": 488.1050000000017, "TestMathBitsCPU": 3.301999999999909, "TestRefsOpsInfoCPU": 0.9530000000000007, "TestSelfKwarg": 0.001, "TestTagsCPU": 1.1130000000000009}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 50.258999999994074}, "test_ops_gradients": {"TestBwdGradientsCPU": 1804.7799999999388}, "test_ops_jit": {"TestJitCPU": 679.4329999999909}, "test_optim": {"TestDifferentiableOptimizer": 0.013000000000000003, "TestLRScheduler": 0.21900000000000017, "TestOptim": 0.72, "TestOptimRenewedCPU": 0.9160000000000006, "TestSWAUtils": 0.016000000000000007}, "test_out_dtype_op": {"TestOutDtypeOp": 0.022000000000000006}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.001, "TestGradCheckOverride": 0.001, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.001, "TestTorchFunctionMode": 0.024000000000000014, "TestTorchFunctionOverride": 1.6959999999999262, "TestTorchFunctionWarning": 0.001, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.008, "ModelTest": 0.0, "TestAnalyze": 0.306, "TestDependencyAPI": 0.017000000000000008, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006, "TestLoadBCPackages": 0.003, "TestMangling": 0.010000000000000002, "TestMisc": 0.011000000000000003, "TestPackageFX": 0.007, "TestPackageScript": 0.023000000000000013, "TestRepackage": 0.001, "TestResources": 0.004, "TestSaveLoad": 0.011000000000000003}, "test_per_overload_api": {"TestPerOverloadAPI": 0.251}, "test_prims": {"TestDecompCPU": 0.002, "TestPrimsBasic": 0.003, "TestPrimsCPU": 0.012000000000000004, "TestRefsCPU": 0.005}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.006, "TestGenericProxyTensorFake": 0.037000000000000026, "TestGenericProxyTensorReal": 0.036000000000000025, "TestGenericProxyTensorSymbolic": 0.04200000000000002, "TestProxyTensorOpInfoCPU": 10.604999999999839, "TestRealProxyTensor": 0.001, "TestSymbolicTracing": 0.06700000000000005}, "test_pruning_op": {"PruningOpTest": 0.162}, "test_public_bindings": {"TestPublicBindings": 0.168}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.001, "TestPythonDispatch": 0.07100000000000005, "TestPythonDispatcher": 0.002, "TestPythonRegistration": 0.01900000000000001, "TestWrapperSubclassAliasingCPU": 0.01900000000000001}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 0.36000000000000004, "TestPythonPytree": 0.03000000000000002}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011, "TestAOMigrationNNQuantized": 0.018000000000000002, "TestAOMigrationQuantization": 0.011, "TestAOMigrationQuantizationFx": 0.012, "TestBackendConfig": 0.021000000000000005, "TestBiasCorrectionEager": 0.002, "TestBits": 0.002, "TestBitsCPU": 0.003, "TestComparatorOps": 0.002, "TestDeprecatedJitQuantized": 0.004, "TestDistributed": 0.008, "TestDuplicateDQPass": 0.004, "TestDynamicQuantizedModule": 0.012, "TestDynamicQuantizedOps": 0.017, "TestEqualizeEager": 0.005, "TestEqualizeFx": 0.01, "TestFXGraphMatcher": 0.019000000000000003, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 0.050000000000000024, "TestFXNumericSuiteCoreAPIsModels": 0.013000000000000001, "TestFXNumericSuiteNShadows": 0.024000000000000007, "TestFakeQuantize": 0.003, "TestFakeQuantizeOps": 0.029000000000000012, "TestFloat8DtypeCPU": 0.02800000000000001, "TestFloat8DtypeCPUOnlyCPU": 0.004, "TestFuseEager": 0.012, "TestFuseFx": 0.018000000000000002, "TestFusedObsFakeQuant": 0.004, "TestFusedObsFakeQuantModule": 0.01, "TestFusionPasses": 0.001, "TestFxDetectInputWeightEqualization": 0.003, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.007, "TestFxModelReportObserver": 0.004, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.003, "TestHistogramObserver": 0.011, "TestMetaDataPorting": 0.007, "TestModelNumericsEager": 0.005, "TestNumericSuiteEager": 0.022000000000000006, "TestObserver": 0.016, "TestPT2ERepresentation": 0.008, "TestPadding": 0.003, "TestQNNPackOps": 0.007, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 0.003, "TestQuantizeDynamicJitPasses": 0.011, "TestQuantizeEagerOps": 0.011, "TestQuantizeEagerPTQDynamic": 0.016, "TestQuantizeEagerPTQStatic": 0.022000000000000006, "TestQuantizeEagerQAT": 0.015000000000000001, "TestQuantizeEagerQATNumerics": 0.012, "TestQuantizeFx": 0.16100000000000012, "TestQuantizeFxModels": 0.007, "TestQuantizeFxOps": 0.055000000000000035, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.03000000000000001, "TestQuantizeJitPasses": 0.04000000000000002, "TestQuantizePT2E": 0.04000000000000002, "TestQuantizePT2EQAT": 266.2749999999999, "TestQuantizePT2EQATModels": 162.43, "TestQuantizePT2EQAT_ConvBn1d": 538.555, "TestQuantizePT2EQAT_ConvBn2d": 535.365, "TestQuantizePT2EX86Inductor": 183.21800000000002, "TestQuantizedConv": 0.03400000000000001, "TestQuantizedEmbeddingOps": 0.009000000000000001, "TestQuantizedFunctionalOps": 0.005, "TestQuantizedLinear": 0.017, "TestQuantizedOps": 171.70500000000013, "TestQuantizedTensor": 0.05700000000000004, "TestRecordHistogramObserver": 0.003, "TestReferenceQuantizedModule": 0.004, "TestSerialization": 0.019000000000000003, "TestStaticQuantizedModule": 122.81499999999998, "TestSubgraphRewriter": 0.014000000000000002, "TestUtils": 0.006, "TestXNNPACKQuantizer": 0.02500000000000001, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCPU": 29.649999999999945}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 0.17800000000000005}, "test_schema_check": {"TestSchemaCheck": 0.03800000000000003, "TestSchemaCheckModeOpInfoCPU": 9.581999999999782}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.17100000000000007}, "test_serialization": {"TestBothSerializationCPU": 0.002, "TestOldSerialization": 0.03900000000000003, "TestSerialization": 0.07800000000000006, "TestSubclassSerialization": 0.008}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.241}, "test_shape_ops": {"TestShapeOpsCPU": 0.1930000000000001}, "test_show_pickle": {"TestShowPickle": 0.156}, "test_sort_and_select": {"TestSortAndSelectCPU": 84.15800000000031}, "test_sparse": {"TestSparseAnyCPU": 1.352999999999969, "TestSparseCPU": 0.2770000000000002, "TestSparseLegacyAndDeprecation": 0.001, "TestSparseMaskedReductionsCPU": 0.04300000000000003, "TestSparseMeta": 0.04000000000000003, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 1.6209999999999525}, "test_sparse_csr": {"TestSparseCSRCPU": 1.8189999999999122, "TestSparseCSRSampler": 0.001, "TestSparseCompressedCPU": 3.1349999999997684, "TestSparseCompressedTritonKernelsCPU": 0.003}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.003}, "test_spectral_ops": {"TestFFTCPU": 0.2640000000000002, "TestFFTDocExamplesCPU": 0.01800000000000001}, "test_stateless": {"TestPythonOptimizeMode": 0.001, "TestStatelessDeprecation": 0.002, "TestStatelessFunctionalAPI": 0.05900000000000004}, "test_subclass": {"TestSubclass": 0.28600000000000003}, "test_sympy_utils": {"TestNumbers": 0.005, "TestSingletonInt": 0.001, "TestSympyInterp": 0.05600000000000004, "TestSympySolve": 0.028000000000000018, "TestValueRanges": 0.06800000000000005}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.1450000000000001, "TestBufferProtocolCPU": 0.12800000000000009, "TestLikeTensorCreationCPU": 0.006, "TestRandomTensorCreationCPU": 0.023000000000000013, "TestTensorCreationCPU": 3.670999999999966}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.004, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.006, "TestTensorBoardPyTorchNumpy": 0.377, "TestTensorBoardPytorchGraph": 0.007, "TestTensorBoardSummary": 0.022000000000000006, "TestTensorBoardSummaryWriter": 0.003, "TestTensorBoardUtils": 0.006, "TestTensorBoardWriter": 0.002, "TestTensorProtoSummary": 0.008}, "test_tensorexpr": {"TestTensorExprFuser": 0.30700000000000005}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.001, "TestTensorExprPyBind": 0.17600000000000002}, "test_testing": {"TestAssertClose": 0.035000000000000024, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.015000000000000006, "TestAssertCloseQuantized": 0.005, "TestAssertCloseSparseBSC": 0.004, "TestAssertCloseSparseBSR": 0.004, "TestAssertCloseSparseCOO": 0.006, "TestAssertCloseSparseCSC": 0.004, "TestAssertCloseSparseCSR": 0.005, "TestFrameworkUtils": 0.001, "TestImports": 0.006, "TestMakeTensorCPU": 0.8240000000000006, "TestOpInfoSampleFunctionsCPU": 1.3439999999999641, "TestOpInfos": 0.003, "TestTestParametrization": 0.024000000000000007, "TestTestParametrizationDeviceTypeCPU": 0.049000000000000016, "TestTestingCPU": 0.05300000000000003}, "test_torch": {"TestBasicVitalSigns": 0.003, "TestTorch": 0.22100000000000017, "TestTorchDeviceTypeCPU": 31.09100000000094, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 0.02100000000000001, "TestAttnMasksCPU": 0.017000000000000008, "TestSDPACPU": 1.315999999999967, "TestSDPAFailureModesCPU": 0.025000000000000015, "TestTransformersCPU": 1.6309999999999973}, "test_type_hints": {"TestTypeHints": 0.166}, "test_type_info": {"TestDTypeInfo": 0.327}, "test_type_promotion": {"TestTypePromotionCPU": 0.45200000000000035}, "test_typing": {"TestTyping": 83.31800000000005}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 25.87400000000712}, "test_utils": {"TestAssert": 0.002, "TestBottleneck": 0.002, "TestCheckpoint": 0.014000000000000005, "TestCollectEnv": 0.001, "TestCppExtensionUtils": 0.002, "TestDataLoaderUtils": 0.004, "TestDeviceUtilsCPU": 6.168000000000335, "TestExtensionUtils": 0.002, "TestHipify": 0.001, "TestHipifyTrie": 0.008, "TestONNXUtils": 0.002, "TestRenderUtils": 0.001, "TestStandaloneCPPJIT": 0.001, "TestTraceback": 0.005}, "test_view_ops": {"TestOldViewOpsCPU": 0.12500000000000008, "TestViewOpsCPU": 0.23100000000000015, "TestViewOpsLAZY": 0.22400000000000017}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.026000000000000002, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 0.23500000000000001}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 1466.3290000000002, "TestXNNPACKOps": 0.359, "TestXNNPACKRewritePass": 0.002, "TestXNNPACKSerDes": 0.004}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.007}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.33, "TestClassGetItem": 0.001, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.002, "TestMisc": 0.003, "TestPickling": 0.017000000000000008, "TestPromotion": 0.001}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 0.29900000000000004, "TestEinsumPath": 0.0, "TestMisc": 0.001}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.002, "TestHalf": 0.001, "TestIinfo": 0.23500000000000001, "TestMisc": 0.002, "TestPythonFloat": 0.001, "TestRepr": 0.002, "TestSingle": 0.001}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.003, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.001, "TestFloatNonIntegerArgument": 0.004, "TestIndexing": 0.41000000000000003, "TestMultiIndexingAutomated": 0.003, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.014, "TestArgmax": 0.07100000000000005, "TestArgmaxArgminCommon": 0.1390000000000001, "TestArgmin": 0.06800000000000005, "TestArrayAttributeDeletion": 0.005, "TestArrayConstruction": 0.341, "TestArrayCreationCopyArgument": 0.004, "TestArrayInterface": 0.006, "TestAssignment": 0.004, "TestAttributes": 0.032, "TestBinop": 0.001, "TestBool": 1102.5149999999999, "TestCequenceMethods": 0.001, "TestChoose": 0.030000000000000002, "TestClip": 0.004, "TestCompress": 0.003, "TestConversion": 0.004, "TestCreation": 0.002, "TestDelMisc": 0.001, "TestDot": 9.136, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.008, "TestFlag": 0.016, "TestFormat": 0.003, "TestFromBuffer": 0.012, "TestHash": 0.272, "TestHashing": 0.003, "TestIO": 0.007, "TestInner": 0.005, "TestLexsort": 0.012, "TestMatmul": 0.618, "TestMatmulOperator": 0.015000000000000001, "TestMethods": 0.1350000000000001, "TestMinMax": 0.002, "TestMinScalarType": 0.004, "TestNewaxis": 0.001, "TestPEP3118Dtype": 0.001, "TestPutmask": 0.009000000000000001, "TestRepeat": 0.023, "TestResize": 0.011, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.028000000000000004, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.017, "TestStats": 0.47, "TestSubscripting": 0.001, "TestTake": 0.009000000000000001, "TestVdot": 0.004, "TestViewDtype": 0.006, "TestWarnings": 0.001, "TestWhere": 0.01, "TestWritebackIfCopy": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.005, "TestArgwhere": 0.005, "TestArrayComparisons": 0.008, "TestBaseRepr": 0.008, "TestBinaryRepr": 0.012, "TestBoolArray": 0.003, "TestBoolCmp": 0.002, "TestBoolScalar": 0.008, "TestBroadcast": 0.005, "TestClip": 0.06200000000000004, "TestConvolve": 0.004, "TestCorrelate": 0.006, "TestCreationFuncs": 0.005, "TestCross": 0.006, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006, "TestFromiter": 0.001, "TestIndex": 0.004, "TestIndices": 0.01800000000000001, "TestIsclose": 0.009000000000000001, "TestIsscalar": 0.001, "TestLikeFuncs": 0.003, "TestMoveaxis": 0.005, "TestNonarrayArgs": 0.03900000000000003, "TestNonzeroAndCountNonzero": 0.04100000000000002, "TestOuterMisc": 0.001, "TestRequire": 0.004, "TestResize": 0.272, "TestRoll": 0.003, "TestRollaxis": 0.002, "TestSeterr": 0.005, "TestStdVar": 0.005, "TestStdVarComplex": 0.002, "TestStringFunction": 0.001, "TestTensordot": 0.003, "TestTypes": 0.009000000000000001}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.17200000000000001, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.11700000000000002}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.15400000000000005, "TestFromInt": 0.003, "TestFromString": 0.165}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.003, "TestBitCount": 0.001, "TestClassGetItem": 0.003, "TestClassGetitemMisc": 0.003, "TestIsInteger": 0.002}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.010000000000000002, "TestBaseMath": 0.002, "TestBitShifts": 0.013000000000000001, "TestComplexDivision": 0.003, "TestConversion": 0.007, "TestHash": 0.002, "TestModulus": 72.547, "TestMultiply": 0.0, "TestNegative": 0.003, "TestPower": 0.005, "TestRepr": 0.001, "TestScalarOpsMisc": 0.06700000000000005, "TestScalarSubclassingMisc": 0.04000000000000003, "TestSubtract": 0.002, "TestTypes": 0.324}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.428, "TestAtleast2d": 0.01, "TestAtleast3d": 0.006, "TestBlock": 0.02100000000000001, "TestConcatenate": 0.06000000000000004, "TestHstack": 0.015000000000000001, "TestStackMisc": 0.02100000000000001, "TestVstack": 0.016}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.001, "TestFFTShift": 0.168, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.001}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.17100000000000007, "TestFFTShift": 0.163, "TestFFTThreadSafe": 0.004}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.17200000000000001}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.007, "TestUnique": 0.26}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.002, "TestAmax": 0.001, "TestAmin": 0.001, "TestAngle": 0.001, "TestAny": 0.002, "TestAverage": 0.004, "TestBincount": 0.013000000000000005, "TestCheckFinite": 0.003, "TestCopy": 0.002, "TestCorrCoef": 0.010000000000000002, "TestCov": 0.013000000000000005, "TestCumprod": 0.001, "TestCumsum": 0.001, "TestDelete": 0.023, "TestDiff": 0.006, "TestDigitize": 0.011000000000000003, "TestExtins": 0.003, "TestFilterwindows": 0.1210000000000001, "TestFlip": 0.007, "TestGradient": 0.01800000000000001, "TestInsert": 0.005, "TestInterp": 0.02900000000000002, "TestKaiser": 0.002, "TestMedian": 0.015000000000000006, "TestMeshgrid": 0.011000000000000003, "TestMsort": 0.0, "TestPercentile": 0.02900000000000002, "TestPiecewise": 0.008, "TestProd": 0.001, "TestPtp": 0.001, "TestQuantile": 0.006, "TestRot90": 0.273, "TestSelect": 0.007, "TestSinc": 0.002, "TestSortComplex": 0.007, "TestTrapz": 0.002, "TestTrimZeros": 0.008, "TestUnique": 0.002, "Test_I0": 0.002}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 1.191999999999998, "TestHistogramOptimBinNums": 0.017000000000000008, "TestHistogramdd": 0.017000000000000008}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006, "TestDiagIndices": 0.002, "TestDiagIndicesFrom": 0.005, "TestFillDiagonal": 0.007, "TestGrid": 0.10500000000000001, "TestIndexExpression": 0.002, "TestIx_": 0.006, "TestNdIndex": 0.002, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.17900000000000002}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.011000000000000003, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.010000000000000002, "TestColumnStack": 0.005, "TestDsplit": 0.005, "TestDstack": 0.006, "TestExpandDims": 0.005, "TestHsplit": 0.004, "TestKron": 0.005, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.002, "TestSplit": 0.002, "TestSqueeze": 0.006, "TestTakeAlongAxis": 0.26, "TestTile": 0.004, "TestVsplit": 0.004}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.005, "TestEye": 0.17300000000000001, "TestFliplr": 0.001, "TestFlipud": 0.001, "TestHistogram2d": 0.008, "TestTri": 0.101, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.002}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.256, "TestImag": 0.002, "TestIscomplex": 0.002, "TestIscomplexobj": 0.003, "TestIsfinite": 0.007, "TestIsinf": 0.007, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.115, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.004, "TestNanToNum": 0.008, "TestReal": 0.004, "TestRealIfClose": 0.001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.02100000000000001, "TestCond": 0.531, "TestDet": 0.362, "TestEig": 0.101, "TestEigh": 0.007, "TestEighCases": 0.0, "TestEigvals": 0.132, "TestEigvalsh": 0.007, "TestEigvalshCases": 0.0, "TestInv": 0.136, "TestLstsq": 0.012000000000000004, "TestMatrixRank": 0.003, "TestMisc": 0.495, "TestMisc2": 0.002, "TestMultiDot": 0.012000000000000004, "TestNormDouble": 0.010000000000000002, "TestNormInt64": 0.010000000000000002, "TestNormSingle": 0.011000000000000001, "TestNorm_NonSystematic": 0.001, "TestPinv": 0.42300000000000004, "TestPinvHermitian": 0.11599999999999999, "TestQR": 0.012000000000000004, "TestSVD": 0.089, "TestSVDHermitian": 0.28200000000000003, "TestSolve": 0.40800000000000003, "TestTensorinv": 0.007, "TestTensorsolve": 0.003}, "torch_np/test_basic": {"TestArrayToSequence": 0.006, "TestCopyTo": 0.003, "TestCtorNested": 0.001, "TestDefaultDtype": 0.004, "TestDivmod": 0.005, "TestExport": 0.0, "TestMisc": 0.002, "TestNormalizations": 0.003, "TestOneArr": 0.2610000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1340000000000001, "TestOneArrAndShape": 0.03300000000000001, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.011000000000000003, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.343}, "torch_np/test_dtype": {"TestConvertDType": 0.21400000000000005}, "torch_np/test_function_base": {"TestAppend": 0.167}, "torch_np/test_ndarray_methods": {"TestAmax": 0.001, "TestAmin": 0.001, "TestArgmax": 0.07500000000000005, "TestArgmaxArgminCommon": 0.03000000000000002, "TestArgmin": 0.09400000000000006, "TestContains": 0.001, "TestIndexing": 0.255, "TestIter": 0.002, "TestNoExtraMethods": 0.006, "TestNonzero": 0.005, "TestRavel": 0.002, "TestReshape": 0.002, "TestTranspose": 0.002}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.011, "TestNEP50Table": 0.001}, "torch_np/test_random": {"TestChoice": 0.002, "TestNumpyGlobal": 0.001, "TestScalarReturn": 0.29900000000000004, "TestShuffle": 0.006}, "torch_np/test_reductions": {"TestAll": 0.003, "TestAny": 0.003, "TestFlatnonzero": 0.253, "TestGenericCumSumProd": 0.008, "TestGenericReductions": 0.9340000000000007, "TestMean": 0.004, "TestSum": 0.010000000000000002}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.184, "TestIsScalar": 0.02100000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.3090000000000002, "TestNdarrayDunderVsUfunc": 0.03100000000000002, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.273}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.30700000000000005}}}, "linux-jammy-py3.8-gcc11": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 1.6506666666666667}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.8749999999999999}, "distributions/test_constraints": {"test_constraints": 0.07300000000000005}, "distributions/test_distributions": {"TestAgainstScipy": 1.1246666666666665, "TestConstraints": 0.1396666666666667, "TestDistributionShapes": 0.13100000000000006, "TestDistributions": 35.61000000000001, "TestFunctors": 0.010666666666666666, "TestJit": 19.588333333333335, "TestKL": 2.864333333333333, "TestLazyLogitsInitialization": 0.013, "TestNumericalStability": 0.07100000000000001, "TestRsample": 0.6809999999999999, "TestValidation": 0.3383333333333334}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.5663333333333332}, "dynamo/test_after_aot": {"TestAfterAot": 6.349333333333334}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.7850000000000001}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 11.405000000000001}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.20699999999999996, "AOTAutogradCacheTests": 16.162000000000003}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.946999999999999}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.044333333333333336, "TestCustomBackendAPI": 1.6073333333333333, "TestExplainWithBackend": 10.187333333333333, "TestOptimizations": 2.1956666666666655}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 12.913000000000002}, "dynamo/test_base_output": {"TestBaseOutput": 0.004333333333333334}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.102666666666667}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 5.916666666666667, "BytecodeTests": 0.4043333333333334}, "dynamo/test_compile": {"InPlaceCompilationTests": 7.575666666666666, "PublicTorchCompilerTests": 0.0030000000000000005}, "dynamo/test_comptime": {"ComptimeTests": 0.6303333333333334}, "dynamo/test_config": {"ConfigTests": 0.5673333333333334}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.21666666666666667, "CppGuardManagerFuncTorchHigherOrderOpTests": 10.665, "CppGuardManagerFunctionTests": 25.670666666666662, "CppGuardManagerHigherOrderOpTests": 7.3536666666666655, "CppGuardManagerMiscTests": 40.786333333333374, "CppGuardManagerReproTests": 36.00500000000002}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.2663333333333335}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.2866666666666667}, "dynamo/test_decorators": {"DecoratorTests": 7.222666666666666}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0016666666666666668, "TestDeviceGuard": 0.015333333333333332}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 33.34466666666666, "DynamicShapesCtxManagerTests": 4.841999999999999, "DynamicShapesExportTests": 26.968333333333337, "DynamicShapesFuncTorchHigherOrderOpTests": 95.93633333333337, "DynamicShapesFunctionTests": 70.28766666666672, "DynamicShapesHigherOrderOpTests": 16.132, "DynamicShapesMiscTests": 87.95300000000013, "DynamicShapesNNModuleTests": 6.208000000000001, "DynamicShapesReproTests": 103.17633333333335, "DynamicShapesSubGraphTests": 11.797666666666666, "DynamicShapesTestSDPA": 0.36999999999999994}, "dynamo/test_exc": {"ExcTests": 1.9636666666666667}, "dynamo/test_exceptions": {"ExceptionTests": 0.5073333333333335}, "dynamo/test_export": {"ExportTests": 17.376999999999995}, "dynamo/test_export_mutations": {"MutationExportTests": 0.531}, "dynamo/test_frame_init": {"FrameInitTests": 0.26866666666666666}, "dynamo/test_functions": {"DefaultsTests": 0.7176666666666668, "FunctionTests": 17.057666666666673}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.417}, "dynamo/test_global": {"TestGlobals": 0.5153333333333334}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.31333333333333335}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.26133333333333336, "FuncTorchHigherOrderOpTests": 10.647666666666668, "HigherOrderOpTests": 7.8343333333333325, "HigherOrderOpVmapGuardTests": 4.201666666666667}, "dynamo/test_hooks": {"HooksTests": 24.817333333333334}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 9.181999999999997, "InlineInbuiltNNModulesExportTests": 15.111999999999997, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 10.655000000000003, "InlineInbuiltNNModulesFunctionTests": 24.234333333333353, "InlineInbuiltNNModulesHigherOrderOpTests": 7.241333333333333, "InlineInbuiltNNModulesMiscTests": 55.42066666666673, "InlineInbuiltNNModulesNNModuleTests": 4.186333333333331}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 8.607333333333331}, "dynamo/test_interop": {"InteropTests": 0.5376666666666666}, "dynamo/test_logging": {"LoggingTests": 17.450333333333337}, "dynamo/test_minifier": {"MinifierTests": 1.434333333333333}, "dynamo/test_misc": {"MiscTests": 53.71766666666675, "TestTracer": 0.052}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.0030000000000000005}, "dynamo/test_modules": {"NNModuleTests": 2.7179999999999978, "OptimizedModuleTest": 18.31866666666667}, "dynamo/test_nops": {"NopTests": 0.35100000000000003}, "dynamo/test_optimizers": {"End2EndTests": 0.6083333333333333, "OptimizerTests": 1.5873333333333333}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.4613333333333334}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.329}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.6526666666666667}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.8130000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.8326666666666668}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.49666666666666665}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.7696666666666667}, "dynamo/test_repros": {"ReproTests": 48.22366666666672}, "dynamo/test_resume": {"ResumeFunctionTests": 0.413}, "dynamo/test_sdpa": {"TestSDPA": 0.44733333333333336}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.509}, "dynamo/test_sources": {"SourceTests": 0.4713333333333334}, "dynamo/test_structured_trace": {"StructuredTraceTest": 15.021333333333333}, "dynamo/test_subclasses": {"SubclassTests": 4.842666666666665, "TestNestedTensor": 10.844333333333333}, "dynamo/test_subgraphs": {"SubGraphTests": 2.3126666666666655}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.08800000000000001, "TraceRuleTests": 1.1403333333333332}, "dynamo/test_triton_kernels": {"KernelTests": 0.015000000000000006, "MutationTests": 0.0030000000000000005, "NoOptimizationKernelTests": 0.012000000000000004, "no_opt_test_class": 0.017333333333333343}, "dynamo/test_unspec": {"UnspecTests": 13.139000000000001}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.5493333333333333}, "dynamo/test_view": {"ViewTests": 0.6070000000000001}, "export/test_converter": {"TestConverter": 7.142}, "export/test_db": {"ExampleTests": 3.1686666666666663}, "export/test_experimental": {"TestExperiment": 0.9126666666666666}, "export/test_export": {"TestDynamismExpression": 0.586, "TestExport": 26.34733333333334, "TestExportCustomClass": 0.06566666666666666, "TestOneOffModelExportResult": 1.0253333333333334}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.46900000000000003, "NonStrictExportTestExport": 26.869999999999994}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.4709999999999999, "PreDispatchExportTestExport": 27.275666666666666}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.25533333333333336}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.6876666666666668}, "export/test_hop": {"TestHOPCPU": 2.815666666666667, "TestHOPGeneric": 0.0030000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.002, "TestLift": 0.19900000000000004, "TestLiftUnlift": 0.010666666666666666}, "export/test_pass_infra": {"TestPassInfra": 0.9976666666666669}, "export/test_passes": {"TestPasses": 12.277666666666667}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.8446666666666666, "RetraceExportTestExport": 40.190999999999995}, "export/test_safeguard": {"TestSafeguard": 0.9286666666666669}, "export/test_schema": {"TestSchema": 0.29066666666666663}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.2323333333333333, "SerDesExportPreDispatchTestExport": 19.73133333333333, "SerDesExportTestDynamismExpression": 0.56, "SerDesExportTestExport": 28.743666666666666}, "export/test_serialize": {"TestDeserialize": 7.309666666666668, "TestOpVersioning": 0.00425, "TestSaveLoad": 0.3016666666666667, "TestSchemaVersioning": 0.03166666666666667, "TestSerialize": 1.2106666666666668, "TestSerializeCustomClass": 0.08800000000000001}, "export/test_sparse": {"TestSparseProp": 64.2263333333333}, "export/test_tools": {"TestExportTools": 0.5026666666666667}, "export/test_torchbind": {"TestCompileTorchbind": 1.2040000000000004, "TestExportTorchbind": 1.8236666666666659, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.268}, "export/test_unflatten": {"TestUnflatten": 3.125666666666667}, "export/test_upgrade": {"TestUpgrade": 0.41875000000000007}, "export/test_verifier": {"TestVerifier": 0.8543333333333334}, "functorch/test_aotdispatch": {"TestAOTAutograd": 13.101666666666668, "TestAOTAutogradWithDynamo": 14.660666666666666, "TestAOTDispatch": 0.5986666666666668, "TestAOTExport": 2.193, "TestAOTModuleSimplified": 0.6589999999999999, "TestEagerFusionModuleInfoCPU": 876.4316666666668, "TestEagerFusionOpInfoCPU": 2079.825999999999, "TestPartitioning": 1.089, "TestPythonKeyCPU": 1.1786666666666668}, "functorch/test_control_flow": {"TestControlFlow": 0.6896666666666667, "TestControlFlowTraced": 105.485}, "functorch/test_dims": {"TestMin": 15.809666666666663, "TestMinFunctorchOnly": 14.62433333333333}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.0796666666666667, "TestAutogradFunctionVmapAPICPU": 0.018666666666666668, "TestCompileTransformsCPU": 9.251666666666667, "TestComposabilityCPU": 1.7443333333333328, "TestExamplesCorrectnessCPU": 5.895666666666666, "TestFunctionalizeCPU": 0.09966666666666668, "TestGradTransformCPU": 0.4586666666666668, "TestHelpersCPU": 0.01, "TestHessianCPU": 0.03733333333333333, "TestHigherOrderOperatorInteractionCPU": 0.022333333333333334, "TestJacCPU": 0.5013333333333335, "TestJvpCPU": 0.05933333333333335, "TestLinearizeCPU": 0.20566666666666666, "TestMakeFunctional": 0.13166666666666668, "TestSliceArgnums": 0.013333333333333336, "TestVmapJvpInplaceViewCPU": 0.014, "TestVmapOfGradCPU": 0.25866666666666666}, "functorch/test_logging": {"TestAOTLogging": 0.3013333333333333}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.4333333333333334, "RandomOpTestCase": 0.07766666666666666, "ReduceTestCase": 0.07500000000000001, "TestMemoryEfficientOpAuthoring": 0.0006666666666666666}, "functorch/test_minifier": {"TestMinifier": 0.4553333333333333}, "functorch/test_ops": {"TestOperatorsCPU": 3327.4426666666463}, "functorch/test_parsing": {"TestAnonymousAxis": 0.29333333333333333, "TestParsedExpression": 0.006333333333333334, "TestParsingUtils": 0.005666666666666667, "TestValidateRearrangeExpressions": 0.004666666666666667}, "functorch/test_rearrange": {"TestRearrange": 0.30433333333333334}, "functorch/test_vmap": {"TestRandomnessCPU": 1.1730000000000003, "TestTransformFailureCPU": 0.07033333333333334, "TestVmapAPI": 0.26066666666666677, "TestVmapBatchedGradientCPU": 0.18166666666666673, "TestVmapDeviceTypeCPU": 0.022000000000000002, "TestVmapNestedTensorCPU": 0.055000000000000014, "TestVmapOperators": 2.9663333333333277, "TestVmapOperatorsOpInfoCPU": 499.5149999999988}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.6569999999998806}, "higher_order_ops/test_with_effects": {"TestWithEffects": 7.937333333333332}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 7.856333333333333}, "inductor/test_binary_folding": {"FreezingCpuTests": 34.327666666666666}, "inductor/test_codecache": {"TestFxGraphCache": 37.07633333333333, "TestFxGraphCacheHashing": 0.718, "TestUtils": 3.157666666666666, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.261}, "inductor/test_compile_worker": {"TestCompileWorker": 10.296333333333333}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 225.1050000000007, "TestAutogradWithCompiledAutograd": 287.002666666667, "TestCompiledAutograd": 173.02666666666673, "TestCustomOpWithCompiledAutograd": 2.2096666666666613}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 488.47100000000006, "CompiledOptimizerTests": 226.2813333333338}, "inductor/test_config": {"TestInductorConfig": 5.5}, "inductor/test_control_flow": {"CondTests": 0.005, "WhileLoopTests": 0.0030000000000000005}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 540.8926666666667, "TestCppWrapper": 583.7456666666666}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1304.603, "TestCppWrapper": 1366.1923333333332}, "inductor/test_cpu_repro": {"CPUReproTests": 654.2139999999999}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 1462.0620000000006, "TestSelectAlgorithmDynamicShapesCPU": 1424.4436666666668}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0030000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 10.063666666666665}, "inductor/test_debug_trace": {"TestDebugTrace": 2.8190000000000004}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.01}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 32.66466666666667}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 73.56966666666666}, "inductor/test_extension_backend": {"ExtensionBackendTests": 17.308333333333334}, "inductor/test_flex_attention": {"TestFlexAttention": 0.014333333333333339, "TestTemplatedSDPA": 0.006666666666666667}, "inductor/test_foreach": {"ForeachTests": 16.66333333333336}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 73.89966666666668, "SDPAPatternRewriterCpuTests": 69.3}, "inductor/test_fx_fusion": {"TestFxFusion": 0.215}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.015666666666666666}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.19000000000000003, "TestGroupBatchFusion": 0.001, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.04700000000000001, "TestIndexingSimplification": 0.502}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 48.580999999999996}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_metrics": {"TestMetrics": 0.262}, "inductor/test_minifier": {"MinifierTests": 22.84833333333334}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 47.472}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 163.23733333333334, "TestPatternMatcher": 562.4653333333334}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.014666666666666673}, "inductor/test_profiler": {"DynamoProfilerTests": 0.002}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 16.041666666666668}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.006500000000000001}, "inductor/test_torchbind": {"TestTorchbind": 9.342333333333334}, "inductor/test_torchinductor": {"CpuTests": 1379.6633333333323, "SweepInputsCpuTest": 106.73766666666667, "TestFull": 9.61}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 1491.1129999999991}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 1573.145333333333, "TestInductorDynamicCPU": 0.033000000000000015}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 24735.035000000007}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 1.5436666666666667}, "inductor/test_triton_kernels": {"KernelTests": 0.09466666666666673, "MutationTests": 0.008666666666666668, "NoOptimizationKernelTests": 0.013000000000000005, "no_opt_test_class": 0.025333333333333347}, "inductor/test_utils": {"TestUtils": 0.25933333333333336}, "lazy/test_debug_util": {"DebugUtilTest": 0.3213333333333333}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.31833333333333336}, "lazy/test_generator": {"LazyGeneratorTest": 0.306}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.638}, "lazy/test_step_closures": {"ClosuresTest": 2.2586666666666666}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.25633333333333336, "TestLazyOpInfoCPU": 7.010333333333307, "TestLazyTensor": 0.07433333333333332}, "nn/test_convolution": {"TestConvolutionNN": 14.011333333333333, "TestConvolutionNNDeviceTypeCPU": 6.5213333333332955}, "nn/test_dropout": {"TestDropoutNN": 0.09300000000000001, "TestDropoutNNDeviceTypeCPU": 0.22933333333333336}, "nn/test_embedding": {"TestEmbeddingNN": 0.06633333333333337, "TestEmbeddingNNDeviceTypeCPU": 6.267333333333333}, "nn/test_init": {"TestNNInit": 3.815333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 0.3983333333333335}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.66, "TestLoadStateDictSwap": 0.043666666666666666}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.020666666666666663, "TestModuleHookNN": 0.059000000000000004, "TestModuleHooks": 0.07800000000000001, "TestStateDictHooks": 0.029666666666666675}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 5.185666666666666, "TestMultiheadAttentionNNDeviceTypeCPU": 0.021333333333333333}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.48066666666666674}, "nn/test_parametrization": {"TestNNParametrization": 0.9246666666666664, "TestNNParametrizationDeviceCPU": 0.023000000000000003}, "nn/test_pooling": {"TestAvgPool": 0.2203333333333333, "TestPoolingNN": 0.261, "TestPoolingNNDeviceTypeCPU": 32.504}, "nn/test_pruning": {"TestPruningNN": 0.1223333333333334}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.205}, "profiler/test_memory_profiler": {"TestDataFlow": 1.1716666666666666, "TestIdentifyGradients": 0.20733333333333337, "TestMemoryProfiler": 0.262, "TestMemoryProfilerE2E": 2.472666666666667}, "profiler/test_profiler": {"TestExecutionTrace": 7.831333333333333, "TestExperimentalUtils": 3.930666666666666, "TestProfiler": 17.72933333333334, "TestProfilerCUDA": 0.001, "TestProfilerITT": 0.004333333333333334, "TestRecordFunction": 0.04066666666666667, "TestTorchTidyProfiler": 5.452666666666666}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.34133333333333343}, "profiler/test_record_function": {"TestRecordFunction": 0.33666666666666667}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.369333333333333}, "test_ao_sparsity": {"TestActivationSparsifier": 0.11133333333333334, "TestBaseDataScheduler": 0.04133333333333333, "TestBaseDataSparsifier": 0.09499999999999999, "TestBaseSparsifier": 0.021666666666666667, "TestBaseStructuredSparsifier": 1.6066666666666665, "TestComposability": 1.4389999999999998, "TestCubicScheduler": 0.004, "TestFPGMPruner": 0.02366666666666667, "TestFakeSparsity": 0.06133333333333333, "TestFxComposability": 1.2086666666666668, "TestNearlyDiagonalSparsifier": 0.5796666666666667, "TestNormDataSparsifiers": 0.947, "TestQuantizationUtils": 0.027333333333333334, "TestQuantizedSparseKernels": 0.3283333333333333, "TestQuantizedSparseLayers": 0.329, "TestSaliencyPruner": 0.021666666666666667, "TestScheduler": 0.013, "TestSparsityUtilFunctions": 0.035, "TestWeightNormSparsifier": 0.23500000000000001}, "test_autocast": {"TestAutocastCPU": 0.8653333333333335, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.004666666666666667}, "test_autograd": {"TestAllowMutationOnSaved": 0.024333333333333335, "TestAutograd": 25.34366666666662, "TestAutogradComplex": 0.006000000000000001, "TestAutogradDeviceTypeCPU": 0.29266666666666674, "TestAutogradForwardMode": 0.06733333333333337, "TestAutogradForwardModeBatchedGrad": 0.015666666666666666, "TestAutogradFunctional": 9.569333333333336, "TestAutogradInferenceMode": 0.03066666666666668, "TestAutogradLogging": 0.012666666666666666, "TestAutogradMultipleDispatchCPU": 0.026333333333333334, "TestMultithreadAutograd": 0.17966666666666672, "TestNestedCheckpoint": 0.36133333333333334, "TestSelectiveActivationCheckpoint": 0.036333333333333336}, "test_autograd_fallback": {"TestAutogradFallback": 0.34933333333333344}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 108.02000000000112}, "test_bundled_inputs": {"TestBundledInputs": 1.146333333333333}, "test_comparison_utils": {"TestComparisonUtils": 0.25866666666666666}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.057000000000000016}, "test_content_store": {"TestContentStoreCPU": 5.7076666666666656}, "test_cpp_api_parity": {"TestCppApiParity": 3.6033333333333197}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.022666666666666672, "TestMAIATensor": 0.007666666666666666, "TestORTTensor": 0.013, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.02233333333333334, "TestMAIATensor": 0.007666666666666666, "TestORTTensor": 0.012666666666666666, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.0030000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 39.818333333333335}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.7573333333333334}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 8.550666666666666}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.7749999999999999}, "test_custom_backend": {"TestCustomBackend": 0.07466666666666666}, "test_custom_ops": {"MiniOpTest": 0.5980000000000002, "MiniOpTestOther": 0.06600000000000002, "TestCustomOp": 1.7976666666666639, "TestCustomOpAPI": 0.15933333333333335, "TestCustomOpTestingCPU": 1.707, "TestCustomOperators": 0.338, "TestGenerateOpcheckTests": 2.970333333333333}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 33.63566666666667, "TestConcatDataset": 0.007666666666666666, "TestConvAfterFork": 0.059666666666666666, "TestCustomPinFn": 0.0013333333333333333, "TestDataLoader": 33.348000000000006, "TestDataLoaderDeviceTypeCPU": 0.0023333333333333335, "TestDataLoaderPersistentWorkers": 49.27599999999999, "TestDatasetRandomSplit": 0.028666666666666663, "TestDictDataLoader": 0.041666666666666664, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.0036666666666666666, "TestSetAffinity": 0.07266666666666667, "TestStackDataset": 0.027000000000000007, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.018333333333333333}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.010666666666666666, "TestDataChunk": 0.008333333333333333, "TestDataFramesPipes": 0.0036666666666666666, "TestFunctionalIterDataPipe": 4.471333333333332, "TestFunctionalMapDataPipe": 0.032, "TestGraph": 0.013333333333333334, "TestIterDataPipeCountSampleYielded": 0.009, "TestIterDataPipeGraphFastForward": 0.036000000000000004, "TestIterDataPipeSingletonConstraint": 0.018000000000000002, "TestIterableDataPipeBasic": 0.025000000000000005, "TestSerialization": 5.530333333333334, "TestSharding": 0.18100000000000005, "TestStreamWrapper": 0.257, "TestTyping": 0.005333333333333333}, "test_decomp": {"DecompOneOffTestsCPU": 0.7266666666666667, "HasDecompTest": 0.1426666666666667, "TestDecompCPU": 4803.650666666673}, "test_deploy": {"TestFreezer": 0.277}, "test_dispatch": {"TestDispatch": 27.033999999999995, "TestPythonDispatcher": 0.03133333333333333}, "test_dlpack": {"TestTorchDlPackCPU": 0.19333333333333347}, "test_dynamic_shapes": {"TestDimConstraints": 2.0096666666666665, "TestFloorDiv": 0.014666666666666666, "TestGuardsExpressions": 0.025333333333333333, "TestPySymInt": 1.350999999999999, "TestSymNumberMagicMethods": 1.8986666666666612}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 2.313666666666665, "TestExpandedWeightHelperFunctionCPU": 0.01966666666666667, "TestExpandedWeightModuleCPU": 5.9543333333333335}, "test_fake_tensor": {"FakeTensorConstHandling": 0.04933333333333335, "FakeTensorConverterTest": 0.022333333333333334, "FakeTensorDispatchCache": 0.06166666666666667, "FakeTensorOpInfoTestCPU": 0.083, "FakeTensorOperatorInvariants": 0.26366666666666666, "FakeTensorPropTest": 0.062, "FakeTensorSerialization": 0.005, "FakeTensorTest": 0.49866666666666665, "PropagateRealTensorsFakeTensorConstHandling": 0.08400000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.021, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.06666666666666667, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.14633333333333334, "PropagateRealTensorsFakeTensorPropTest": 0.042666666666666665, "PropagateRealTensorsFakeTensorTest": 0.2096666666666667}, "test_flop_counter": {"TestFlopCounter": 0.6623333333333332}, "test_foreach": {"TestForeachCPU": 54.34300000000051}, "test_function_schema": {"TestFunctionSchema": 0.5983333333333333}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 29.000666666666664}, "test_functional_optim": {"TestFunctionalOptimParity": 0.36900000000000005}, "test_functionalization": {"TestCrossRefFunctionalization": 2.1976666666666658, "TestFunctionalization": 2.566999999999999}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.02}, "test_futures": {"TestFuture": 0.9416666666666668}, "test_fx": {"AnnotationsTest": 0.012666666666666668, "TestCSEPass": 0.2356666666666667, "TestCommonPass": 0.057333333333333326, "TestConstFold": 0.14200000000000002, "TestConstParamShapeInControlFlow": 0.03866666666666666, "TestDCE": 0.026333333333333334, "TestFX": 2.756999999999996, "TestFXAPIBackwardCompatibility": 0.026333333333333334, "TestFunctionalTracing": 0.3160000000000002, "TestMatcher": 0.31800000000000006, "TestOperatorSignaturesCPU": 2.3009999999999775, "TestPassManager": 0.021, "TestSourceMatcher": 1.3056666666666668, "TestSubgraphRewriter": 0.26400000000000007, "TestVisionTracing": 231.56299999999996, "TypeCheckerTest": 1.6596666666666653}, "test_fx_experimental": {"TestFXExperimental": 14.841666666666663, "TestNormalizeOperatorsCPU": 41.207, "TestTranslationValidation": 0.142}, "test_fx_passes": {"TestFXGraphPasses": 0.6166666666666668, "TestFXMatcherUtils": 0.07766666666666668}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.4150000000000002}, "test_import_stats": {"TestImportTime": 3.1953333333333327}, "test_indexing": {"NumpyTestsCPU": 0.03800000000000002, "TestIndexingCPU": 1.716333333333332}, "test_itt": {"TestItt": 0.306}, "test_jit": {"TestAliasAnalysis": 0.24933333333333332, "TestAsync": 0.30600000000000005, "TestAtenPow": 0.007666666666666666, "TestAutodiffJit": 0.08, "TestAutodiffSubgraphSlicing": 0.26066666666666677, "TestAwait": 0.15833333333333335, "TestBackends": 0.5316666666666666, "TestBackendsWithCompiler": 0.11233333333333333, "TestBatchMM": 0.06266666666666666, "TestBuiltins": 0.04533333333333334, "TestClassType": 0.7013333333333337, "TestComplex": 0.6636666666666668, "TestCustomOperators": 0.038666666666666676, "TestDCE": 0.015, "TestDataParallel": 0.0026666666666666666, "TestDataclasses": 3.768666666666666, "TestDeviceAnalysis": 3.1229999999999993, "TestDict": 0.34066666666666684, "TestDtypeAnalysis": 0.118, "TestDtypeCustomRulesCPU": 1.8166666666666649, "TestEnum": 0.10766666666666669, "TestFreezing": 0.8180000000000004, "TestFrontend": 0.041, "TestFrozenOptimizations": 9.159, "TestFunctionalBlocks": 0.005333333333333333, "TestFunctionalToInplaceActivation": 2.2443333333333335, "TestGenerator": 0.05233333333333334, "TestGetDefaultAttr": 0.015, "TestGraphRewritePasses": 0.054, "TestHash": 0.05933333333333333, "TestHooks": 0.49566666666666687, "TestIgnorableArgs": 0.007666666666666666, "TestIgnoreContextManager": 0.03266666666666667, "TestInplaceToFunctionalActivation": 2.0243333333333333, "TestIsinstance": 0.1563333333333334, "TestJit": 4.226999999999996, "TestJitGeneratedModule": 11.891666666666675, "TestJitProfiler": 0.001, "TestJitUtils": 0.013666666666666669, "TestList": 1.0486666666666669, "TestLogging": 0.03866666666666666, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.12800000000000003, "TestMixTracingScripting": 0.8196666666666669, "TestModels": 2.505333333333333, "TestModuleAPIs": 0.10766666666666667, "TestModuleContainers": 0.8596666666666669, "TestModuleInterface": 0.2843333333333334, "TestModules": 0.012333333333333335, "TestNamedTuple": 0.055000000000000014, "TestNnapiBackend": 9.685333333333332, "TestOpDecompositions": 0.013000000000000003, "TestOptimizeForMobilePreserveDebugInfo": 0.134, "TestParametrization": 0.07066666666666667, "TestPeephole": 0.32333333333333353, "TestProducerVersion": 0.001, "TestProfiler": 0.43766666666666665, "TestPythonBindings": 0.024000000000000004, "TestPythonBuiltinOP": 0.2743333333333334, "TestPythonIr": 0.017666666666666667, "TestRecursiveScript": 0.47166666666666685, "TestRemoveMutation": 0.09866666666666668, "TestSaveLoad": 0.3056666666666667, "TestSaveLoadFlatbuffer": 0.18100000000000005, "TestSaveLoadForOpVersion": 1.864333333333333, "TestScript": 13.068666666666656, "TestScriptDict": 0.022333333333333334, "TestScriptList": 0.6173333333333334, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.10933333333333335, "TestScriptProfile": 0.2783333333333334, "TestSlice": 0.11133333333333335, "TestSparse": 0.03333333333333333, "TestStringFormatting": 0.08600000000000003, "TestSymbolicShapeAnalysis": 1.3269999999999993, "TestTensorBuiltins": 0.05833333333333333, "TestTensorCreationOps": 0.03566666666666666, "TestTensorMethods": 0.008333333333333333, "TestTorchbind": 0.10200000000000004, "TestTracer": 2.151999999999997, "TestTypeSharing": 0.3680000000000001, "TestTypesAndAnnotation": 0.08666666666666667, "TestTyping": 0.27966666666666673, "TestUnion": 0.33133333333333354, "TestUnsupportedOps": 0.022333333333333334, "TestUpgraders": 0.05566666666666668, "TestWarn": 0.04033333333333333, "TestWith": 0.2143333333333333}, "test_jit_autocast": {"TestAutocast": 0.09266666666666667, "TestJitTraceAutocast": 14.903666666666666}, "test_jit_disabled": {"TestJitDisabled": 0.391}, "test_jit_fuser_te": {"TestFuserCommon": 0.11933333333333333, "TestLoopnestRandomizationCPU": 0.045000000000000005, "TestNNCOpInfoCPU": 38.192666666667776, "TestTEFuserDynamic": 103.40033333333336, "TestTEFuserStatic": 45.471}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0006666666666666666, "TestEnableDisableLlgaFuser": 0.07066666666666667, "TestFusionPatternCPU": 5.985666666666666, "TestModel": 2.267333333333333, "TestOpCPU": 41.707}, "test_legacy_vmap": {"TestVmapAPI": 1.0799999999999985, "TestVmapAPILegacy": 1.5369999999999997, "TestVmapBatchedGradientCPU": 0.0696666666666667, "TestVmapBatchedGradientLegacyCPU": 0.08133333333333337, "TestVmapOperators": 0.9400000000000001, "TestVmapOperatorsLegacy": 1.2783333333333329}, "test_license": {"TestLicense": 0.25433333333333336}, "test_linalg": {"TestLinalgCPU": 130.0149999999997}, "test_logging": {"LoggingTest": 2.1363333333333334}, "test_masked": {"TestMaskedCPU": 15.760333333333335}, "test_maskedtensor": {"TestBasicsCPU": 0.43466666666666676, "TestBinary": 0.3770000000000002, "TestOperatorsCPU": 7.9919999999999405, "TestReductions": 0.08166666666666668, "TestUnary": 0.34133333333333354}, "test_meta": {"TestMetaCPU": 1482.440666666633, "TestMetaConverter": 0.10600000000000002}, "test_mkl_verbose": {"TestMKLVerbose": 3.3523333333333336}, "test_mkldnn": {"TestMkldnnCPU": 94.96999999999998}, "test_mkldnn_fusion": {"TestMkldnnFusion": 56.282000000000004}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 3.1793333333333336}, "test_mobile_optimizer": {"TestOptimizer": 2.396}, "test_model_dump": {"TestModelDump": 0.9003333333333333}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.166}, "test_module_init": {"TestModuleInitCPU": 2.255999999999993}, "test_module_tracker": {"TestModuleTracker": 0.262}, "test_modules": {"TestModuleCPU": 472.87199999999785}, "test_monitor": {"TestMonitor": 0.261, "TestMonitorTensorboard": 0.218}, "test_multiprocessing": {"TestMultiprocessing": 45.02166666666667}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.38166666666666665, "SpawnTest": 24.879999999999995}, "test_namedtensor": {"TestNamedTensor": 0.3920000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.8020000000000003}, "test_native_functions": {"TestNativeFunctions": 0.3763333333333334}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.19400000000000006}, "test_nestedtensor": {"TestNestedTensor": 0.1330000000000001, "TestNestedTensorAutogradCPU": 0.7433333333333336, "TestNestedTensorDeviceTypeCPU": 0.6620000000000004, "TestNestedTensorSubclassCPU": 15.625000000000009}, "test_nn": {"TestAddRelu": 0.0033333333333333335, "TestConstantPadNd": 0.0033333333333333335, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.3016666666666667, "TestFusionUtils": 0.004, "TestNN": 36.66166666666664, "TestNNDeviceTypeCPU": 111.43966666666732, "TestUtils": 0.0036666666666666666}, "test_numba_integration": {"TestNumbaIntegration": 0.004666666666666667}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.15633333333333338}, "test_openmp": {"TestOpenMP_ParallelFor": 4.9303333333333335}, "test_ops": {"TestCommonCPU": 1071.1639999999836, "TestCompositeComplianceCPU": 715.5963333333319, "TestFakeTensorCPU": 249.84100000000095, "TestMathBitsCPU": 37.40333333333336, "TestRefsOpsInfoCPU": 1.0543333333333342, "TestSelfKwarg": 0.022333333333333334, "TestTagsCPU": 9.437666666666637}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 597.9153333333226}, "test_ops_gradients": {"TestBwdGradientsCPU": 1041.0236666666212}, "test_ops_jit": {"TestJitCPU": 845.8089999999994}, "test_optim": {"TestDifferentiableOptimizer": 0.16800000000000004, "TestLRScheduler": 0.9376666666666672, "TestOptim": 48.527, "TestOptimRenewedCPU": 37.14500000000002, "TestSWAUtils": 0.27066666666666667}, "test_out_dtype_op": {"TestOutDtypeOp": 0.403}, "test_overrides": {"TestBroadcastAllOverride": 0.002, "TestDisabledTorchFunction": 0.0016666666666666668, "TestDisabledUserWarnings": 0.0016666666666666668, "TestEinsumOverride": 0.0030000000000000005, "TestGradCheckOverride": 0.016333333333333335, "TestGradNewOnesOverride": 0.0016666666666666668, "TestIndexing": 0.005666666666666667, "TestIterator": 0.001, "TestNamedTuple": 0.002, "TestPickle": 0.002, "TestRNN": 0.0026666666666666666, "TestResolveName": 0.08800000000000001, "TestTorchFunctionMode": 0.03133333333333335, "TestTorchFunctionOverride": 1.742666666666589, "TestTorchFunctionWarning": 0.011666666666666667, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.03866666666666667, "ModelTest": 0.0, "TestAnalyze": 0.17766666666666664, "TestDependencyAPI": 0.048000000000000015, "TestDependencyHooks": 0.011666666666666667, "TestDiGraph": 0.018666666666666668, "TestGlobGroup": 0.019333333333333338, "TestImporter": 0.010000000000000002, "TestLoadBCPackages": 0.06033333333333333, "TestMangling": 0.015333333333333332, "TestMisc": 0.04000000000000001, "TestPackageFX": 0.05266666666666666, "TestPackageScript": 1.7133333333333327, "TestRepackage": 0.01, "TestResources": 0.01, "TestSaveLoad": 0.033}, "test_per_overload_api": {"TestPerOverloadAPI": 0.26733333333333337}, "test_prims": {"TestDecompCPU": 0.075, "TestPrimsBasic": 0.012333333333333335, "TestPrimsCPU": 0.07866666666666668, "TestRefsCPU": 0.010333333333333335}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.09333333333333334, "TestGenericProxyTensorFake": 1.8579999999999997, "TestGenericProxyTensorReal": 2.3189999999999995, "TestGenericProxyTensorSymbolic": 17.176333333333332, "TestProxyTensorOpInfoCPU": 593.6963333333321, "TestRealProxyTensor": 0.012666666666666666, "TestSymbolicTracing": 3.118666666666666}, "test_pruning_op": {"PruningOpTest": 0.446}, "test_public_bindings": {"TestPublicBindings": 6.362333333333333}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.010666666666666666, "TestPythonDispatch": 0.18966666666666676, "TestPythonDispatcher": 0.006000000000000001, "TestPythonRegistration": 0.2783333333333334, "TestWrapperSubclassAliasingCPU": 0.09000000000000004}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 0.36100000000000004, "TestPythonPytree": 0.06000000000000003}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.015000000000000005, "TestAOMigrationNNQuantized": 0.03733333333333334, "TestAOMigrationQuantization": 0.026333333333333337, "TestAOMigrationQuantizationFx": 0.021666666666666667, "TestBackendConfig": 0.04400000000000001, "TestBiasCorrectionEager": 0.8250000000000001, "TestBits": 0.004, "TestBitsCPU": 0.30866666666666664, "TestComparatorOps": 1.5106666666666666, "TestDeprecatedJitQuantized": 2.603666666666667, "TestDistributed": 0.02066666666666667, "TestDuplicateDQPass": 2.5773333333333333, "TestDynamicQuantizedModule": 47.214666666666666, "TestDynamicQuantizedOps": 28.09266666666667, "TestEqualizeEager": 0.09266666666666667, "TestEqualizeFx": 3.8096666666666663, "TestFXGraphMatcher": 1.8010000000000002, "TestFXGraphMatcherModels": 10.461, "TestFXNumericSuiteCoreAPIs": 25.465333333333334, "TestFXNumericSuiteCoreAPIsModels": 28.28, "TestFXNumericSuiteNShadows": 36.266333333333336, "TestFakeQuantize": 0.4020000000000001, "TestFakeQuantizeOps": 3.263333333333333, "TestFloat8DtypeCPU": 0.08033333333333335, "TestFloat8DtypeCPUOnlyCPU": 0.143, "TestFuseEager": 3.6009999999999995, "TestFuseFx": 2.322333333333333, "TestFusedObsFakeQuant": 0.221, "TestFusedObsFakeQuantModule": 0.49266666666666675, "TestFusionPasses": 0.017, "TestFxDetectInputWeightEqualization": 0.17166666666666672, "TestFxDetectOutliers": 0.215, "TestFxModelReportClass": 0.45566666666666666, "TestFxModelReportDetectDynamicStatic": 0.05366666666666667, "TestFxModelReportDetector": 0.165, "TestFxModelReportObserver": 0.16766666666666663, "TestFxModelReportVisualizer": 0.19366666666666665, "TestGenerateNumericDebugHandle": 0.6256666666666667, "TestGraphUtils": 1.2633333333333334, "TestHistogramObserver": 30.786333333333335, "TestMetaDataPorting": 5.627333333333333, "TestModelNumericsEager": 1.014, "TestNumericSuiteEager": 6.579333333333332, "TestObserver": 3.3230000000000004, "TestPT2ERepresentation": 23.862666666666666, "TestPadding": 19.653000000000002, "TestQNNPackOps": 6.182666666666666, "TestQuantizationDocs": 0.005, "TestQuantizeDynamicJitOps": 1.6940000000000002, "TestQuantizeDynamicJitPasses": 4.393999999999999, "TestQuantizeEagerOps": 1.4356666666666664, "TestQuantizeEagerPTQDynamic": 7.421666666666667, "TestQuantizeEagerPTQStatic": 23.331, "TestQuantizeEagerQAT": 9.944666666666665, "TestQuantizeEagerQATNumerics": 1.7076666666666664, "TestQuantizeFx": 37.17633333333333, "TestQuantizeFxModels": 7.7589999999999995, "TestQuantizeFxOps": 107.86233333333335, "TestQuantizeJit": 18.11433333333333, "TestQuantizeJitOps": 204.97566666666668, "TestQuantizeJitPasses": 5.157, "TestQuantizePT2E": 44.57833333333334, "TestQuantizePT2EQAT": 36.041000000000004, "TestQuantizePT2EQATModels": 28.14366666666666, "TestQuantizePT2EQAT_ConvBn1d": 278.068, "TestQuantizePT2EQAT_ConvBn2d": 271.75033333333334, "TestQuantizePT2EX86Inductor": 105.829, "TestQuantizedConv": 63.171, "TestQuantizedEmbeddingOps": 0.654, "TestQuantizedFunctionalOps": 4.87, "TestQuantizedLinear": 18.410666666666668, "TestQuantizedOps": 121.48633333333335, "TestQuantizedTensor": 1.8953333333333335, "TestRecordHistogramObserver": 0.028999999999999998, "TestReferenceQuantizedModule": 0.066, "TestSerialization": 1.6363333333333336, "TestStaticQuantizedModule": 122.62966666666667, "TestSubgraphRewriter": 1.3033333333333335, "TestUtils": 0.016, "TestXNNPACKQuantizer": 34.254999999999995, "TestXNNPACKQuantizerModels": 2.922333333333333}, "test_reductions": {"TestReductionsCPU": 213.6280000000027}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 3.9643333333333346}, "test_schema_check": {"TestSchemaCheck": 0.13666666666666674, "TestSchemaCheckModeOpInfoCPU": 191.62599999999816}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.9600000000000003}, "test_serialization": {"TestBothSerializationCPU": 0.515, "TestOldSerialization": 25.284666666666663, "TestSerialization": 9.272666666666673, "TestSubclassSerialization": 0.02933333333333334}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.30633333333333335}, "test_shape_ops": {"TestShapeOpsCPU": 0.9893333333333328}, "test_show_pickle": {"TestShowPickle": 0.249}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.9783333333333302}, "test_sparse": {"TestSparseAnyCPU": 386.75333333333236, "TestSparseCPU": 23.808999999999987, "TestSparseLegacyAndDeprecation": 0.05000000000000001, "TestSparseMaskedReductionsCPU": 1.1186666666666667, "TestSparseMeta": 3.4139999999999993, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 6.447999999999915}, "test_sparse_csr": {"TestSparseCSRCPU": 72.28533333333401, "TestSparseCSRSampler": 0.4533333333333333, "TestSparseCompressedCPU": 85.74866666666645, "TestSparseCompressedTritonKernelsCPU": 0.005333333333333333}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 6.080999999999985, "TestFFTDocExamplesCPU": 0.06300000000000003}, "test_stateless": {"TestPythonOptimizeMode": 3.196333333333333, "TestStatelessDeprecation": 1.4626666666666666, "TestStatelessFunctionalAPI": 0.29266666666666674}, "test_subclass": {"TestSubclass": 0.4290000000000001}, "test_sympy_utils": {"TestNumbers": 0.045000000000000005, "TestSingletonInt": 0.005, "TestSympyInterp": 9.965000000000002, "TestSympySolve": 0.17966666666666667, "TestValueRanges": 6.1066666666666665}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.5363333333333338, "TestBufferProtocolCPU": 0.34166666666666695, "TestLikeTensorCreationCPU": 0.009000000000000001, "TestRandomTensorCreationCPU": 2.6936666666666667, "TestTensorCreationCPU": 19.525000000000038}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.01833333333333333, "TestTensorBoardFigure": 1.0976666666666666, "TestTensorBoardNumpy": 0.0036666666666666666, "TestTensorBoardPyTorchNumpy": 0.2893333333333334, "TestTensorBoardPytorchGraph": 33.038000000000004, "TestTensorBoardSummary": 0.037000000000000005, "TestTensorBoardSummaryWriter": 0.008333333333333333, "TestTensorBoardUtils": 0.14133333333333334, "TestTensorBoardWriter": 0.08466666666666667, "TestTensorProtoSummary": 0.010666666666666666}, "test_tensorexpr": {"TestTensorExprFuser": 45.44566666666666}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.007666666666666666, "TestTensorExprPyBind": 0.8620000000000001}, "test_testing": {"TestAssertClose": 0.10766666666666673, "TestAssertCloseContainer": 0.005333333333333333, "TestAssertCloseErrorMessage": 0.04966666666666667, "TestAssertCloseQuantized": 0.010666666666666666, "TestAssertCloseSparseBSC": 0.014, "TestAssertCloseSparseBSR": 0.013666666666666667, "TestAssertCloseSparseCOO": 0.019000000000000003, "TestAssertCloseSparseCSC": 0.014, "TestAssertCloseSparseCSR": 0.015, "TestFrameworkUtils": 11.847333333333333, "TestImports": 12.460333333333333, "TestMakeTensorCPU": 1.0869999999999975, "TestOpInfoSampleFunctionsCPU": 4.109666666666647, "TestOpInfos": 0.006666666666666667, "TestTestParametrization": 0.03600000000000001, "TestTestParametrizationDeviceTypeCPU": 3.5539999999999985, "TestTestingCPU": 0.21566666666666676}, "test_torch": {"TestBasicVitalSigns": 0.02766666666666667, "TestTorch": 3.4416666666666607, "TestTorchDeviceTypeCPU": 11.112000000000068, "TestVitalSignsCudaCPU": 0.0016666666666666668}, "test_transformers": {"TestAttnBiasCPU": 19.46966666666667, "TestAttnMasksCPU": 16.567666666666664, "TestSDPACPU": 271.84699999999935, "TestSDPAFailureModesCPU": 0.029000000000000012, "TestTransformersCPU": 6.2733333333333325}, "test_type_hints": {"TestTypeHints": 0.26933333333333337}, "test_type_info": {"TestDTypeInfo": 0.2966666666666667}, "test_type_promotion": {"TestTypePromotionCPU": 2.6723333333333206}, "test_typing": {"TestTyping": 73.00233333333335}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 339.34199999987646}, "test_utils": {"TestAssert": 0.05366666666666667, "TestBottleneck": 7.992999999999999, "TestCheckpoint": 0.07933333333333335, "TestCollectEnv": 0.9953333333333333, "TestCppExtensionUtils": 0.07533333333333335, "TestDataLoaderUtils": 0.17733333333333334, "TestDeviceUtilsCPU": 23.522666666667323, "TestExtensionUtils": 0.004666666666666667, "TestHipify": 0.001, "TestHipifyTrie": 0.008, "TestONNXUtils": 0.004, "TestRenderUtils": 0.012000000000000002, "TestStandaloneCPPJIT": 2.129, "TestTraceback": 0.01}, "test_view_ops": {"TestOldViewOpsCPU": 10.846000000000013, "TestViewOpsCPU": 0.6803333333333338, "TestViewOpsLAZY": 0.8450000000000003}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.017, "WeakKeyDictionaryTestCase": 0.016666666666666666, "WeakTest": 4.049666666666666}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 27.275000000000002, "TestXNNPACKOps": 3.482666666666667, "TestXNNPACKRewritePass": 1.3226666666666667, "TestXNNPACKSerDes": 3.7536666666666663}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0026666666666666666}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.32433333333333336, "TestClassGetItem": 0.002, "TestDtypeAttributeDeletion": 0.0006666666666666666, "TestFromDTypeAttribute": 0.0023333333333333335, "TestMisc": 0.004666666666666667, "TestPickling": 0.09466666666666668, "TestPromotion": 0.0023333333333333335}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 12.472333333333331, "TestEinsumPath": 0.0, "TestMisc": 0.004}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0013333333333333333, "TestHalf": 0.0, "TestIinfo": 0.2763333333333333, "TestMisc": 0.0026666666666666666, "TestPythonFloat": 0.001, "TestRepr": 0.0026666666666666666, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0026666666666666666, "TestBooleanIndexing": 0.007, "TestBroadcastedAssignments": 0.02033333333333334, "TestFancyIndexingCast": 0.0033333333333333335, "TestFloatNonIntegerArgument": 0.006999999999999999, "TestIndexing": 0.41200000000000014, "TestMultiIndexingAutomated": 0.006999999999999999, "TestMultipleEllipsisError": 0.0026666666666666666, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.020333333333333335, "TestArgmax": 0.914333333333334, "TestArgmaxArgminCommon": 0.20166666666666674, "TestArgmin": 0.9406666666666673, "TestArrayAttributeDeletion": 0.008, "TestArrayConstruction": 0.03400000000000001, "TestArrayCreationCopyArgument": 0.004000000000000001, "TestArrayInterface": 0.023999999999999997, "TestAssignment": 0.008666666666666668, "TestAttributes": 0.01966666666666667, "TestBinop": 0.014, "TestBool": 18.953999999999997, "TestCequenceMethods": 0.002, "TestChoose": 0.016666666666666666, "TestClip": 0.005333333333333333, "TestCompress": 0.004333333333333334, "TestConversion": 0.035666666666666666, "TestCreation": 0.001, "TestDelMisc": 0.0016666666666666668, "TestDot": 0.05700000000000002, "TestDtypedescr": 0.0016666666666666668, "TestFancyIndexing": 0.02366666666666667, "TestFlag": 0.013000000000000003, "TestFormat": 0.004, "TestFromBuffer": 0.011666666666666667, "TestHash": 0.17666666666666667, "TestHashing": 0.0026666666666666666, "TestIO": 0.002, "TestInner": 0.17466666666666666, "TestLexsort": 0.015333333333333336, "TestMatmul": 0.33900000000000013, "TestMatmulOperator": 0.24933333333333332, "TestMethods": 1.2830000000000004, "TestMinMax": 0.005, "TestMinScalarType": 0.005333333333333333, "TestNewaxis": 0.0030000000000000005, "TestPEP3118Dtype": 0.0013333333333333333, "TestPutmask": 0.01, "TestRepeat": 0.011000000000000001, "TestResize": 0.037666666666666675, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.016666666666666666, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.1566666666666667, "TestStats": 0.18166666666666664, "TestSubscripting": 0.0016666666666666668, "TestTake": 0.03000000000000001, "TestVdot": 0.030000000000000002, "TestViewDtype": 0.006333333333333334, "TestWarnings": 0.002, "TestWhere": 0.3286666666666667, "TestWritebackIfCopy": 0.02333333333333333}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.017, "TestArgwhere": 0.02466666666666667, "TestArrayComparisons": 0.01, "TestBaseRepr": 0.004666666666666667, "TestBinaryRepr": 0.006000000000000001, "TestBoolArray": 1.7686666666666666, "TestBoolCmp": 0.134, "TestBoolScalar": 0.009, "TestBroadcast": 0.007666666666666666, "TestClip": 0.1543333333333334, "TestConvolve": 0.018666666666666668, "TestCorrelate": 0.029666666666666664, "TestCreationFuncs": 0.8303333333333334, "TestCross": 0.04633333333333334, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.007333333333333333, "TestFromiter": 0.002, "TestIndex": 0.005333333333333333, "TestIndices": 0.037000000000000005, "TestIsclose": 0.06733333333333334, "TestIsscalar": 0.002, "TestLikeFuncs": 0.001, "TestMoveaxis": 0.011333333333333334, "TestNonarrayArgs": 0.09300000000000004, "TestNonzeroAndCountNonzero": 0.19066666666666668, "TestOuterMisc": 0.004, "TestRequire": 0.007, "TestResize": 0.27466666666666667, "TestRoll": 0.024999999999999998, "TestRollaxis": 0.004666666666666667, "TestSeterr": 0.006666666666666667, "TestStdVar": 0.024000000000000004, "TestStdVarComplex": 0.010666666666666666, "TestStringFunction": 0.0016666666666666668, "TestTensordot": 0.014666666666666666, "TestTypes": 0.011333333333333334}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0013333333333333333, "TestCommonType": 0.2873333333333333, "TestDocStrings": 0.0, "TestIsSubDType": 0.006000000000000001, "TestScalarTypeNames": 0.021666666666666678}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06333333333333337, "TestFromInt": 0.006000000000000001, "TestFromString": 0.25766666666666665}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.003666666666666667, "TestBitCount": 0.0013333333333333333, "TestClassGetItem": 0.0016666666666666668, "TestClassGetitemMisc": 0.29066666666666663, "TestIsInteger": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.08000000000000002, "TestBaseMath": 7.182666666666666, "TestBitShifts": 0.074, "TestComplexDivision": 0.05666666666666667, "TestConversion": 0.05066666666666667, "TestHash": 0.001, "TestModulus": 0.757, "TestMultiply": 0.0003333333333333333, "TestNegative": 0.015, "TestPower": 0.10633333333333335, "TestRepr": 0.0013333333333333333, "TestScalarOpsMisc": 0.04666666666666669, "TestScalarSubclassingMisc": 0.012333333333333337, "TestSubtract": 0.014666666666666666, "TestTypes": 11.572333333333333}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.26133333333333336, "TestAtleast2d": 0.013666666666666667, "TestAtleast3d": 0.012333333333333335, "TestBlock": 0.02233333333333334, "TestConcatenate": 0.12700000000000009, "TestHstack": 0.015666666666666666, "TestStackMisc": 0.004, "TestVstack": 0.015333333333333332}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.008, "TestFFTShift": 4.757333333333333, "TestIRFFTN": 0.0026666666666666666, "TestRFFTFreq": 0.008}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 2.8623333333333334, "TestFFTShift": 0.261, "TestFFTThreadSafe": 0.8850000000000001}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.3076666666666667}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.002, "TestUnique": 0.38733333333333336}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.006333333333333334, "TestAmax": 0.005, "TestAmin": 0.005, "TestAngle": 0.008, "TestAny": 0.006000000000000001, "TestAverage": 0.02666666666666667, "TestBincount": 0.035666666666666666, "TestCheckFinite": 0.002, "TestCopy": 0.007333333333333333, "TestCorrCoef": 0.03, "TestCov": 0.05166666666666667, "TestCumprod": 0.024333333333333335, "TestCumsum": 0.032, "TestDelete": 0.016, "TestDiff": 0.06566666666666666, "TestDigitize": 0.015666666666666666, "TestExtins": 0.005666666666666667, "TestFilterwindows": 0.4850000000000003, "TestFlip": 0.027666666666666673, "TestGradient": 0.11866666666666668, "TestInsert": 0.008666666666666668, "TestInterp": 0.04633333333333336, "TestKaiser": 0.009000000000000001, "TestMedian": 0.10400000000000002, "TestMeshgrid": 0.04633333333333334, "TestMsort": 0.0, "TestPercentile": 0.0726666666666667, "TestPiecewise": 0.010666666666666666, "TestProd": 0.024666666666666667, "TestPtp": 0.008, "TestQuantile": 0.01966666666666667, "TestRot90": 0.3046666666666667, "TestSelect": 0.007, "TestSinc": 0.007666666666666666, "TestSortComplex": 0.012000000000000002, "TestTrapz": 0.005333333333333333, "TestTrimZeros": 0.011333333333333334, "TestUnique": 0.004, "Test_I0": 0.011999999999999999}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.3576666666666668, "TestHistogramOptimBinNums": 0.03033333333333335, "TestHistogramdd": 0.134}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.002, "TestConcatenator": 0.008666666666666668, "TestDiagIndices": 0.004666666666666667, "TestDiagIndicesFrom": 0.009666666666666665, "TestFillDiagonal": 0.036333333333333336, "TestGrid": 0.013, "TestIndexExpression": 0.013, "TestIx_": 0.009333333333333334, "TestNdIndex": 0.0016666666666666668, "TestNdenumerate": 0.0016666666666666668, "TestRavelUnravelIndex": 0.35200000000000004}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.014666666666666668, "TestApplyOverAxes": 0.002, "TestArraySplit": 0.13366666666666668, "TestColumnStack": 0.008666666666666668, "TestDsplit": 0.009000000000000001, "TestDstack": 0.015, "TestExpandDims": 0.007, "TestHsplit": 0.010666666666666666, "TestKron": 0.012666666666666668, "TestMayShareMemory": 0.0023333333333333335, "TestPutAlongAxis": 0.009666666666666667, "TestSplit": 0.006000000000000001, "TestSqueeze": 0.026666666666666672, "TestTakeAlongAxis": 0.29233333333333333, "TestTile": 0.067, "TestVsplit": 0.007333333333333333}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.025333333333333336, "TestEye": 0.306, "TestFliplr": 0.004333333333333334, "TestFlipud": 0.004, "TestHistogram2d": 0.035, "TestTri": 0.10466666666666667, "TestTrilIndicesFrom": 0.0016666666666666668, "TestTriuIndices": 0.0033333333333333335, "TestTriuIndicesFrom": 0.0016666666666666668, "TestVander": 0.018}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.2816666666666667, "TestImag": 0.009666666666666669, "TestIscomplex": 0.004666666666666667, "TestIscomplexobj": 0.004, "TestIsfinite": 0.013333333333333334, "TestIsinf": 0.012666666666666666, "TestIsnan": 0.011999999999999999, "TestIsneginf": 0.002, "TestIsposinf": 0.002, "TestIsreal": 0.007666666666666666, "TestIsrealobj": 0.0016666666666666668, "TestIsscalar": 0.002, "TestMintypecode": 0.004, "TestNanToNum": 0.014, "TestReal": 0.011000000000000001, "TestRealIfClose": 0.0033333333333333335}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.18299999999999997, "TestCond": 0.18900000000000003, "TestDet": 0.132, "TestEig": 0.031333333333333345, "TestEigh": 0.024333333333333342, "TestEighCases": 0.0, "TestEigvals": 0.04800000000000001, "TestEigvalsh": 0.024333333333333335, "TestEigvalshCases": 0.0, "TestInv": 0.04466666666666668, "TestLstsq": 0.17466666666666666, "TestMatrixRank": 0.34833333333333333, "TestMisc": 0.019, "TestMisc2": 0.0036666666666666666, "TestMultiDot": 0.04900000000000001, "TestNormDouble": 0.6830000000000002, "TestNormInt64": 0.6773333333333333, "TestNormSingle": 0.7003333333333334, "TestNorm_NonSystematic": 0.0030000000000000005, "TestPinv": 0.09233333333333334, "TestPinvHermitian": 0.02866666666666667, "TestQR": 0.454, "TestSVD": 0.038666666666666676, "TestSVDHermitian": 0.085, "TestSolve": 0.3126666666666667, "TestTensorinv": 0.016999999999999998, "TestTensorsolve": 0.006000000000000001}, "torch_np/test_basic": {"TestArrayToSequence": 0.007, "TestCopyTo": 0.006000000000000001, "TestCtorNested": 0.0030000000000000005, "TestDefaultDtype": 0.007, "TestDivmod": 0.013333333333333334, "TestExport": 0.0, "TestMisc": 0.0016666666666666668, "TestNormalizations": 0.005333333333333333, "TestOneArr": 0.3150000000000002, "TestOneArrAndAxesTuple": 0.010000000000000002, "TestOneArrAndAxis": 0.1550000000000001, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.010000000000000002, "TestPythonArgsToArray": 0.013333333333333336, "TestSequenceOfArrays": 0.018666666666666675, "TestSequenceOfArraysToSingle": 0.01, "TestShapeLikeToArray": 0.004666666666666667, "TestSmokeNotImpl": 0.0016666666666666668}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.3616666666666668}, "torch_np/test_dtype": {"TestConvertDType": 0.319}, "torch_np/test_function_base": {"TestAppend": 0.32233333333333336}, "torch_np/test_ndarray_methods": {"TestAmax": 0.006999999999999999, "TestAmin": 0.006999999999999999, "TestArgmax": 0.9656666666666668, "TestArgmaxArgminCommon": 0.11466666666666675, "TestArgmin": 1.0143333333333338, "TestContains": 0.002, "TestIndexing": 0.27899999999999997, "TestIter": 0.005333333333333333, "TestNoExtraMethods": 0.008666666666666668, "TestNonzero": 0.117, "TestRavel": 0.006000000000000001, "TestReshape": 0.005, "TestTranspose": 0.008}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.14733333333333334, "TestNEP50Table": 0.0023333333333333335}, "torch_np/test_random": {"TestChoice": 0.011333333333333334, "TestNumpyGlobal": 0.0033333333333333335, "TestScalarReturn": 0.3336666666666667, "TestShuffle": 0.013666666666666669}, "torch_np/test_reductions": {"TestAll": 0.01, "TestAny": 0.010666666666666666, "TestFlatnonzero": 0.19499999999999998, "TestGenericCumSumProd": 0.019333333333333338, "TestGenericReductions": 2.0216666666666274, "TestMean": 0.028333333333333335, "TestSum": 0.18133333333333335}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.27666666666666667, "TestIsScalar": 0.02200000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.5520000000000004, "TestNdarrayDunderVsUfunc": 0.17533333333333342, "TestUfuncDtypeKwd": 0.004666666666666667, "TestUnaryUfuncs": 0.3033333333333334}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.38466666666666677}}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": {"TestFullyShardAutograd": 0.24933333333333332}, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormMultiThread": 0.24833333333333332, "TestClipGradNormWorldSize2": 0.24366666666666667, "TestClipGradNormWorldSize4": 0.002}, "distributed/_composable/fsdp/test_fully_shard_collectives": {"TestFullyShardCollectives": 0.002}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 0.0013333333333333333, "TestFullyShardCollectiveOps": 0.0026666666666666666, "TestFullyShardCommunication": 0.014, "TestFullyShardPrefetch": 0.005, "TestFullyShardUnshard": 0.0016666666666666668, "TestFullyShardUnshardMultiProcess": 0.0016666666666666668, "TestFullyShardUnshardMultiThread": 0.001}, "distributed/_composable/fsdp/test_fully_shard_compile": {"TestFullyShardCompile": 3.880333333333333, "TestFullyShardCompileCompute": 0.001}, "distributed/_composable/fsdp/test_fully_shard_extensions": {"TestFullyShardAllGatherExtensionsMultiProcess": 2.9309999999999996, "TestFullyShardAllGatherExtensionsMultiThread": 0.002}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 0.24666666666666667}, "distributed/_composable/fsdp/test_fully_shard_init": {"TestFullyShardDeviceDTensor": 0.002, "TestFullyShardDeviceTensor": 0.001, "TestFullyShardHSDPBroadcast": 0.001, "TestFullyShardLazyInit": 0.0016666666666666668, "TestFullyShardManagedModulesAndStates": 0.0013333333333333333, "TestFullyShardMeshArg": 0.001, "TestFullyShardMetaDeviceInit": 0.001, "TestFullyShardParamModuleInfos": 0.0013333333333333333, "TestFullyShardProcessGroupInit": 0.0003333333333333333, "TestFullyShardShardedParameterDTensor": 0.001, "TestFullyShardShardedParameterTensor": 0.001}, "distributed/_composable/fsdp/test_fully_shard_memory": {"TestFullyShardMemory": 0.24766666666666667}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionCasts": 0.008666666666666668, "TestFullyShardMixedPrecisionTraining": 0.25266666666666665}, "distributed/_composable/fsdp/test_fully_shard_overlap": {"TestFullyShardOverlap": 0.248}, "distributed/_composable/fsdp/test_fully_shard_state": {"TestFullyShardState": 0.0033333333333333335}, "distributed/_composable/fsdp/test_fully_shard_state_dict": {"TestFullyShardStateDict": 0.237, "TestFullyShardStateDictMultiProcess": 0.015333333333333332, "TestFullyShardStateDictMultiThread": 0.001}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 0.0016666666666666668, "TestFullyShard1DTrainingCore": 0.02166666666666667, "TestFullyShard2DTraining": 0.005, "TestFullyShardCastAfterInit": 0.001, "TestFullyShardCustomForwardMethod": 0.0016666666666666668, "TestFullyShardForwardInputs": 0.001, "TestFullyShardGradientAccumulation": 0.0033333333333333335, "TestFullyShardHSDPTraining": 0.0016666666666666668, "TestFullyShardNDTraining": 0.0016666666666666668, "TestFullyShardRegisteredParams": 0.0013333333333333333, "TestFullyShardSharedParams": 0.0016666666666666668, "test_fully_shard_training": 0.0}, "distributed/_composable/fully_shard/test_fully_shard_compile": {"TestCompile": 0.001}, "distributed/_composable/fully_shard/test_fully_shard_init": {"TestInitialization": 15.950333333333333}, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": {"TestMixedPrecision": 2.8313333333333333}, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": {"TestModelCheckpointing": 10.583666666666666}, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": {"TestOptimStateCheckpointing": 5.416333333333333}, "distributed/_composable/fully_shard/test_fully_shard_runtime": {"TestRuntime": 0.243}, "distributed/_composable/fully_shard/test_fully_shard_util": {"TestUtils": 2.8299999999999996}, "distributed/_composable/test_checkpoint": {"TestCheckpoint": 0.06366666666666668}, "distributed/_composable/test_compose": {"TestFSDPCheckpoint": 24.169333333333338}, "distributed/_composable/test_contract": {"TestContract": 0.25166666666666665}, "distributed/_composable/test_replicate": {"ReplicateStateDictTest": 5.799, "ReplicateTest": 18.046333333333337}, "distributed/_composable/test_replicate_with_compiler": {"DDP_TP_Test": 0.001, "ReplicateTest": 0.24466666666666667}, "distributed/_shard/sharded_optim/test_sharded_optim": {"TestShardedOptimizer": 0.002}, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": {"TestShardedTensorBinaryOps": 0.0026666666666666666}, "distributed/_shard/sharded_tensor/ops/test_embedding": {"TestShardedEmbedding": 0.002}, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": {"TestShardedEmbeddingBag": 0.002}, "distributed/_shard/sharded_tensor/ops/test_init": {"TestShardedTensorNNInit": 0.0026666666666666666}, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": {"TestTensorOps": 0.0023333333333333335}, "distributed/_shard/sharded_tensor/test_logger": {"ShardingSpecLoggerTest": 0.24466666666666667}, "distributed/_shard/sharded_tensor/test_sharded_tensor": {"TestCreateTensorFromParams": 0.001, "TestCreateTensorNoProcessGroupMode": 0.0033333333333333335, "TestLocalTensor": 0.0003333333333333333, "TestModuleHookApi": 0.001, "TestShardMetadata": 0.0016666666666666668, "TestShardParameter": 0.0016666666666666668, "TestShardTensor": 0.0016666666666666668, "TestShardedTensorChunked": 0.004666666666666667, "TestShardedTensorCustomOps": 0.002, "TestShardedTensorEnumerable": 0.0026666666666666666, "TestShardedTensorFromLocalShards": 5.423333333333335, "TestShardedTensorFromLocalTensor": 0.0003333333333333333, "TestShardedTensorMetadata": 0.27666666666666667, "TestShardedTensorSubGroupInit": 0.016}, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": {"TestReshard": 0.002}, "distributed/_shard/sharding_plan/test_sharding_plan": {"TestShardingPlan": 0.0026666666666666666}, "distributed/_shard/sharding_spec/test_sharding_spec": {"TestCustomShardingSpec": 2.997, "TestShardingSpec": 0.02466666666666667}, "distributed/_shard/test_sharder": {"TestCustomSharder": 0.002}, "distributed/_tensor/debug/test_comm_mode": {"TestCommMode": 0.26533333333333337}, "distributed/_tensor/debug/test_op_coverage": {"TestOpCoverage": 0.35766666666666663}, "distributed/_tensor/experimental/test_local_map": {"TestLocalMap": 10.617666666666667}, "distributed/_tensor/experimental/test_tp_transform": {"TensorParallelTest": 10.492666666666665}, "distributed/_tensor/test_api": {"DTensorAPITest": 22.206333333333333}, "distributed/_tensor/test_attention": {"RingAttentionTest": 2.7996666666666665}, "distributed/_tensor/test_common_rules": {"CommonRulesTest": 27.446666666666662}, "distributed/_tensor/test_convolution_ops": {"DistConvolutionOpsTest": 63.55533333333333}, "distributed/_tensor/test_device_mesh": {"DeviceMeshCollectiveTest": 16.902, "DeviceMeshTest": 11.162999999999998, "DeviceMeshTestNDim": 7.024666666666666, "InitDeviceMeshTest": 10.211333333333334, "TestDeviceMeshGetItem": 20.257}, "distributed/_tensor/test_dtensor": {"DTensorMeshTest": 41.835, "DTensorTest": 51.677666666666674, "TestDTensorPlacementTypes": 4.178666666666667}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 2.131, "TestDTensorCompileE2E": 15.541666666666666, "TestDTensorCompileWithNativeFunCol": 0.20766666666666667}, "distributed/_tensor/test_dtensor_ops": {"TestDTensorOpsCPU": 62.59200000000002}, "distributed/_tensor/test_embedding_ops": {"TestEmbeddingOp": 8.983333333333333}, "distributed/_tensor/test_experimental_ops": {"DistOtherOpsTest": 8.064}, "distributed/_tensor/test_init": {"DTensorConstructorTest": 16.512333333333334, "DTensorInitOpsTest": 2.9356666666666666}, "distributed/_tensor/test_math_ops": {"DistMathOpsTest": 30.28933333333333}, "distributed/_tensor/test_matrix_ops": {"DistMatrixOpsTest": 24.716333333333335}, "distributed/_tensor/test_op_strategy": {"TestCostModel": 0.07166666666666667, "TestEinsumDims": 0.244, "TestEinsumStrategies": 0.035}, "distributed/_tensor/test_optimizers": {"TestDTensorOptimizer": 35.166}, "distributed/_tensor/test_pointwise_ops": {"DistElementwiseOpsTest": 0.3866666666666667}, "distributed/_tensor/test_random_ops": {"DistTensorRandomInitTest": 3.013333333333333, "DistTensorRandomOpTest": 16.31433333333333}, "distributed/_tensor/test_redistribute": {"MultiDimRedistributeTest": 5.512333333333333, "RedistributeTest": 28.083333333333332}, "distributed/_tensor/test_tensor_ops": {"DistTensorOpsTest": 73.50866666666666}, "distributed/_tensor/test_utils": {"Test2DStridedLocalShard": 5.582000000000001, "UtilTest": 15.024333333333333}, "distributed/_tensor/test_view_ops": {"TestViewOps": 27.907}, "distributed/_tensor/test_xla_integration": {"DTensorXLAIntegrationTest": 0.25766666666666665}, "distributed/_tools/test_memory_tracker": {"TestMemoryTracker": 0.001}, "distributed/_tools/test_mod_tracker": {"TestModTracker": 0.25933333333333336}, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": {"DistributedDataParallelCommHookTest": 0.0030000000000000005}, "distributed/algorithms/quantization/test_quantization": {"DistQuantizationTests": 11.779666666666664}, "distributed/algorithms/test_join": {"TestJoin": 23.700666666666667}, "distributed/checkpoint/e2e/test_e2e_save_and_load": {"TestE2ELoadAndSave": 11.491333333333335, "TestE2ESaveAndLoad": 32.608333333333334, "TestNoCPU": 2.757}, "distributed/checkpoint/e2e/test_fine_tuning": {"TestFineTuning": 0.253}, "distributed/checkpoint/e2e/test_fsdp_ep": {"TestFSDPWithEP": 0.249}, "distributed/checkpoint/e2e/test_pipeline": {"TestPipeline": 0.24300000000000002}, "distributed/checkpoint/fsdp/test_fsdp_dsd": {"TestFullyShardWithDistributedStateDict": 0.23933333333333331}, "distributed/checkpoint/test_checkpoint": {"TestDistributedCheckpointing": 0.002, "TestDistributedFailure": 5.594}, "distributed/checkpoint/test_compatibility": {"TestDCPCompatbility": 0.256}, "distributed/checkpoint/test_dedup_tensors": {"TestDedupTensor": 0.33433333333333337}, "distributed/checkpoint/test_dtensor_checkpoint": {"DTensorPlanner": 2.9746666666666663}, "distributed/checkpoint/test_dtensor_resharding": {"TestDTensorReshardMeshChange": 8.304333333333334, "TestDTensorReshardPlacementChange": 5.691333333333334}, "distributed/checkpoint/test_file_system_checkpoint": {"TestDistributedReshardOnLoad": 0.0030000000000000005, "TestDistributedStateDictSaveLoad": 0.26966666666666667, "TestDistributedStateDictSaveLoadWithSharedTensor": 0.001}, "distributed/checkpoint/test_file_system_checkpoint_cpu": {"TestDistributedReshardOnLoad": 21.8, "TestDistributedStateDictSaveLoad": 0.27166666666666667, "TestDistributedStateDictSaveLoadWithSharedTensor": 5.238666666666666}, "distributed/checkpoint/test_format_utils": {"TestFormatUtils": 8.592}, "distributed/checkpoint/test_fsdp_model_state": {"FsdpModelStateCheckpoint": 5.668666666666667}, "distributed/checkpoint/test_fsdp_optim_state": {"FsdpOptimStateCheckpoint": 5.624}, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": {"TestFsdpTpCheckpointConversion": 2.962666666666667}, "distributed/checkpoint/test_fsspec": {"TestFSSpecNoDist": 0.259, "TestFSSpecWithDist": 0.002}, "distributed/checkpoint/test_hsdp_checkpoint": {"TestHSDPCheckpoint": 11.121666666666668}, "distributed/checkpoint/test_nested_dict": {"TestFlattening": 0.253}, "distributed/checkpoint/test_planner": {"TestLoadPlanner": 0.022333333333333334, "TestPlannerHelpers": 0.002, "TestSavePlan": 0.26}, "distributed/checkpoint/test_save_load_api": {"TestSaveAndLoadAPI": 2.834}, "distributed/checkpoint/test_state_dict": {"TestNoComm": 2.9629999999999996, "TestStateDict": 0.275}, "distributed/checkpoint/test_state_dict_utils": {"TestStateDictUtils": 0.26633333333333337}, "distributed/checkpoint/test_torch_save_to_dcp": {"TestTorchSaveToDCP": 5.081333333333333}, "distributed/checkpoint/test_tp_checkpoint": {"TestTpCheckpoint": 5.864666666666667}, "distributed/checkpoint/test_traverse": {"TestTraverse": 0.25633333333333336}, "distributed/checkpoint/test_utils": {"TestMedatadaIndex": 0.26066666666666666, "TestTensorProperties": 0.002}, "distributed/elastic/events/lib_test": {"EventLibTest": 0.26666666666666666, "RdzvEventLibTest": 0.04300000000000001}, "distributed/elastic/metrics/api_test": {"MetricsApiTest": 0.2703333333333333}, "distributed/elastic/multiprocessing/api_test": {"RunProcResultsTest": 0.26899999999999996, "StartProcessesListTest": 15.326333333333332, "StartProcessesTest": 11.933666666666667, "StdTest": 0.005}, "distributed/elastic/test_control_plane": {"WorkerServerTest": 3.3689999999999998}, "distributed/elastic/timer/local_timer_example": {"LocalTimerExample": 14.417333333333334}, "distributed/elastic/timer/local_timer_test": {"LocalTimerServerTest": 0.12433333333333331, "LocalTimerTest": 2.8813333333333335, "MultiprocessingRequestQueueTest": 1.444}, "distributed/elastic/utils/distributed_test": {"DistributedUtilTest": 2.286666666666667}, "distributed/elastic/utils/logging_test": {"LoggingTest": 0.27899999999999997}, "distributed/elastic/utils/util_test": {"StoreUtilTest": 0.248, "UtilTest": 0.036666666666666674}, "distributed/fsdp/test_checkpoint_wrapper": {"CheckpointWrapperTest": 0.327}, "distributed/fsdp/test_distributed_checkpoint": {"TestDistributedCheckpoint": 0.244}, "distributed/fsdp/test_fsdp_apply": {"TestApply": 7.997000000000001}, "distributed/fsdp/test_fsdp_backward_prefetch": {"TestBackwardPrefetch": 2.834}, "distributed/fsdp/test_fsdp_checkpoint": {"TestFSDPCheckpoint": 43.56733333333333, "TestFSDPCheckpointSubmodule": 2.690666666666667}, "distributed/fsdp/test_fsdp_clip_grad_norm": {"TestClipGradNorm": 11.315666666666667}, "distributed/fsdp/test_fsdp_comm": {"TestCommunication": 22.209333333333333, "TestExplicitUnshard": 0.004666666666666667}, "distributed/fsdp/test_fsdp_comm_hooks": {"TestCommunicationHooks": 44.175333333333334}, "distributed/fsdp/test_fsdp_core": {"TestAutograd": 2.724, "TestHooks": 19.168333333333333, "TestNoGrad": 5.447333333333333, "TestParamInit": 5.551333333333335, "TestParityWithDDP": 132.57366666666667}, "distributed/fsdp/test_fsdp_dtensor_state_dict": {"TestFSDPWithDeviceMeshAndDTensor": 41.288000000000004}, "distributed/fsdp/test_fsdp_exec_order": {"TestFSDPExecOrder": 22.683666666666664}, "distributed/fsdp/test_fsdp_fine_tune": {"TestFSDPFineTune": 0.24666666666666667}, "distributed/fsdp/test_fsdp_flatten_params": {"TestFlattenParams": 27.91366666666667}, "distributed/fsdp/test_fsdp_freezing_weights": {"TestFreezingWeights": 88.51466666666668}, "distributed/fsdp/test_fsdp_fx": {"TestSymbolicTracing": 0.261}, "distributed/fsdp/test_fsdp_grad_acc": {"TestGradAcc": 15.918333333333335}, "distributed/fsdp/test_fsdp_hybrid_shard": {"TestFSDPHybridShard": 15.884666666666668}, "distributed/fsdp/test_fsdp_ignored_modules": {"TestFSDPIgnoredModules": 0.27466666666666667}, "distributed/fsdp/test_fsdp_input": {"TestInput": 5.238333333333333}, "distributed/fsdp/test_fsdp_memory": {"TestFSDPMemory": 5.483}, "distributed/fsdp/test_fsdp_meta": {"TestFSDPWithMetaDevice": 21.017333333333337}, "distributed/fsdp/test_fsdp_misc": {"TestFSDPMiscMultiProcess": 36.599333333333334, "TestFSDPMiscMultiThread": 0.033, "TestFSDPMiscWorldSize1": 0.006000000000000001}, "distributed/fsdp/test_fsdp_mixed_precision": {"TestFSDPDifferentSubmodulePrecision": 15.635, "TestFSDPMixedPrecisionIgnoredModules": 2.545, "TestFSDPMixedPrecisionSharded": 117.60333333333335, "TestFSDPMixedPrecisionUnsharded": 7.535, "TestFSDPTrainEval": 2.550333333333333}, "distributed/fsdp/test_fsdp_multiple_forward": {"TestMultiForward": 3.003}, "distributed/fsdp/test_fsdp_multiple_wrapping": {"TestMultipleWrapping": 2.9446666666666665}, "distributed/fsdp/test_fsdp_optim_state": {"TestFSDPOptimState": 177.18200000000013}, "distributed/fsdp/test_fsdp_overlap": {"TestForwardOverlapWorldSizeOne": 2.763333333333333, "TestForwardOverlapWorldSizeTwo": 2.617}, "distributed/fsdp/test_fsdp_pure_fp16": {"TestPureFP16": 5.8709999999999996}, "distributed/fsdp/test_fsdp_sharded_grad_scaler": {"TestShardGradScaler": 0.0026666666666666666, "TestShardedGradScalerParityWithDDP": 47.132000000000005}, "distributed/fsdp/test_fsdp_state_dict": {"TestFSDPStateDict": 0.5410000000000003, "TestFSDPStateDict4GPUs": 0.0016666666666666668}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 8.491999999999999}, "distributed/fsdp/test_fsdp_traversal": {"TestTraversal": 2.83}, "distributed/fsdp/test_fsdp_uneven": {"TestUnevenParamShard": 2.971}, "distributed/fsdp/test_fsdp_unshard_params": {"TestUnshardParams": 23.328666666666663, "TestUnshardParamsErrors": 10.333, "TestUnshardParamsNoShard": 4.9559999999999995}, "distributed/fsdp/test_fsdp_use_orig_params": {"TestFSDPUseOrigParamsFQNs": 3.092, "TestFSDPUseOrigParamsInit": 3.1246666666666667, "TestFSDPUseOrigParamsMultipleParamGroups": 17.116333333333333, "TestFSDPUseOrigParamsNoSync": 5.867666666666666, "TestFSDPUseOrigParamsParamAccess": 2.917666666666667, "TestFSDPUseOrigParamsUnshardReshard": 11.433, "TestFSDPUseOrigParamsWriteback": 14.518333333333333, "TestMultiTensorApply": 0.009333333333333334}, "distributed/fsdp/test_hsdp_dtensor_state_dict": {"TestHSDPWithDeviceMeshAndDTensor": 21.977333333333334}, "distributed/fsdp/test_shard_utils": {"TestShardUtilsDistributed": 2.829333333333333, "TestShardUtilsDistributedDTensor": 2.5833333333333335}, "distributed/fsdp/test_utils": {"TestUtils": 0.256}, "distributed/fsdp/test_wrap": {"TestAutoWrap": 0.006000000000000001, "TestFSDPWrap": 71.32566666666666, "TestWrapUtils": 0.019666666666666666}, "distributed/launcher/test_run": {"ElasticLaunchTest": 35.296}, "distributed/nn/jit/test_instantiator": {"TestInstantiator": 0.26566666666666666}, "distributed/optim/test_zero_redundancy_optimizer": {"TestZeroRedundancyOptimizerDistributed": 46.59233333333333, "TestZeroRedundancyOptimizerSingleRank": 21.209}, "distributed/pipeline/sync/skip/test_api": {"test_api": 0.005}, "distributed/pipeline/sync/skip/test_gpipe": {"test_gpipe": 0.325}, "distributed/pipeline/sync/skip/test_inspect_skip_layout": {"test_inspect_skip_layout": 0.007}, "distributed/pipeline/sync/skip/test_leak": {"test_leak": 0.44900000000000007}, "distributed/pipeline/sync/skip/test_portal": {"TestTensorLife": 0.006000000000000001, "test_portal": 0.006000000000000001}, "distributed/pipeline/sync/skip/test_stash_pop": {"test_stash_pop": 0.009000000000000001}, "distributed/pipeline/sync/skip/test_tracker": {"test_tracker": 0.006666666666666667}, "distributed/pipeline/sync/skip/test_verify_skippables": {"test_verify_skippables": 0.010000000000000002}, "distributed/pipeline/sync/test_balance": {"test_balance": 4.022333333333333}, "distributed/pipeline/sync/test_bugs": {"test_bugs": 0.4789999999999999}, "distributed/pipeline/sync/test_checkpoint": {"test_checkpoint": 0.219}, "distributed/pipeline/sync/test_copy": {"test_copy": 0.005333333333333333}, "distributed/pipeline/sync/test_deferred_batch_norm": {"test_deferred_batch_norm": 1.206}, "distributed/pipeline/sync/test_dependency": {"test_dependency": 0.007}, "distributed/pipeline/sync/test_inplace": {"test_inplace": 0.11733333333333333}, "distributed/pipeline/sync/test_microbatch": {"test_microbatch": 0.013000000000000003}, "distributed/pipeline/sync/test_phony": {"test_phony": 0.005}, "distributed/pipeline/sync/test_pipe": {"test_pipe": 1.460333333333333}, "distributed/pipeline/sync/test_pipeline": {"test_pipeline": 0.005}, "distributed/pipeline/sync/test_stream": {"TestCurrentStream": 0.001, "TestDefaultStream": 0.001, "TestGetDevice": 0.001, "TestNewStream": 0.002, "TestRecordStream": 0.001, "TestUseDevice": 0.001, "TestUseStream": 0.001, "TestWaitStream": 0.001}, "distributed/pipeline/sync/test_transparency": {"test_transparency": 0.26033333333333336}, "distributed/pipeline/sync/test_worker": {"test_worker": 0.008666666666666668}, "distributed/pipelining/test_backward": {"StageBackwardTests": 0.26333333333333336}, "distributed/pipelining/test_chunkspec": {"ChunkSpecTests": 0.6426666666666666}, "distributed/pipelining/test_microbatch": {"MicrobatchTests": 0.598}, "distributed/pipelining/test_pipe": {"PipeTests": 0.9463333333333334}, "distributed/pipelining/test_stage_backward": {"StageBackwardTests": 0.2765}, "distributed/pipelining/test_transformer": {"TransformerTests": 0.8466666666666667}, "distributed/pipelining/test_unflatten": {"UnflattenTests": 0.7200000000000001}, "distributed/rpc/cuda/test_tensorpipe_agent": {"TensorPipeCudaDdpComparisonTest": 0.001, "TensorPipeCudaDistAutogradTest": 9.715000000000002, "TensorPipeCudaRemoteModuleTest": 12.278, "TensorPipeCudaRpcTest": 3.2776666666666663, "TensorPipePipeWithDDPTest": 11.997666666666666, "TensorPipeTensorPipeAgentCudaRpcTest": 283.0426666666667, "TensorPipeTensorPipeCudaDistAutogradTest": 9.709000000000001}, "distributed/rpc/test_faulty_agent": {"FaultyFaultyAgentDistAutogradTest": 19.854333333333333, "FaultyFaultyAgentRpcTest": 177.38566666666668, "FaultyJitFaultyAgentRpcTest": 49.06}, "distributed/rpc/test_share_memory": {"TestRPCPickler": 3.1310000000000002}, "distributed/rpc/test_tensorpipe_agent": {"TensorPipeDdpComparisonTest": 14.408000000000001, "TensorPipeDdpUnderDistAutogradTest": 5.460666666666666, "TensorPipeDistAutogradTest": 238.13166666666666, "TensorPipeDistOptimizerTest": 15.234, "TensorPipeJitDistAutogradTest": 14.283666666666667, "TensorPipeJitRpcTest": 193.28366666666668, "TensorPipeParameterServerTest": 3.5276666666666667, "TensorPipeReinforcementLearningRpcTest": 3.6926666666666663, "TensorPipeRemoteModuleTest": 42.486333333333334, "TensorPipeRpcTest": 798.1766666666668, "TensorPipeTensorPipeAgentDistAutogradTest": 112.9833333333333, "TensorPipeTensorPipeAgentRpcTest": 154.62300000000002, "TensorPipeThreeWorkersRemoteModuleTest": 9.881333333333332}, "distributed/tensor/parallel/test_ddp_2d_parallel": {"Test2dParallelIntegration": 2.94}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"Test2dParallelIntegration": 20.935333333333336, "TestNew2dParallelStateDict": 19.507, "TestNew2dParallelTraining": 14.209999999999999}, "distributed/tensor/parallel/test_micro_pipeline_tp": {"MicroPipelineTPTest": 0.0030000000000000005, "test_micro_pipeline_tp": 0.0}, "distributed/tensor/parallel/test_parallelize_api": {"TensorParallelAPITests": 28.285333333333337}, "distributed/tensor/parallel/test_tp_examples": {"DistTensorParallelExampleTest": 20.049666666666667}, "distributed/tensor/parallel/test_tp_random_state": {"TensorParallelRandomStateTests": 3.0399999999999996}, "distributed/tensor/parallel/test_tp_style": {"TensorParallelStyleTest": 25.80033333333333}, "distributed/tensor/parallel/test_view_sharding_dim_change": {"TPViewShardingDimChangeTest": 2.365}, "distributed/test_c10d_common": {"CommTest": 2.749, "ComputeBucketAssignmentTest": 0.9386666666666666, "LocalRankTest": 11.713666666666667, "ProcessGroupWithDispatchedCollectivesTests": 5.364999999999999, "PythonProcessGroupExtensionTest": 22.025666666666666, "ReduceOpTest": 0.9460000000000001, "TimeoutTest": 31.264666666666667}, "distributed/test_c10d_functional_native": {"C10DFunctionalNativeCompileTest": 0.002, "C10DFunctionalNativeTest": 0.001, "CompileTest": 0.0033333333333333335, "TestWithNCCL": 0.0013333333333333333}, "distributed/test_c10d_gloo": {"CommTest": 30.51, "CompilerTest": 30.930666666666667, "DistributedDataParallelTest": 111.11466666666665, "GlooProcessGroupWithDispatchedCollectivesTests": 18.648666666666667, "LargeCommTest": 9.161666666666667, "ProcessGroupGlooTest": 159.99733333333336, "ReducerTest": 0.126, "RendezvousEnvTest": 0.25833333333333336, "TimeoutTest": 3.2836666666666665}, "distributed/test_c10d_logger": {"C10dErrorLoggerTest": 7.825333333333333}, "distributed/test_c10d_object_collectives": {"TestObjectCollectives": 24.033666666666665}, "distributed/test_c10d_pypg": {"TestDDPWithWorkSubclass": 52.82900000000001, "TestDDPWithWorkWrapper": 52.476000000000006}, "distributed/test_c10d_spawn_gloo": {"DistributedDataParallelSingleProcessTest": 0.015333333333333332, "ProcessGroupShareTensorTest": 0.004, "TestDistributedNNFunctionsGloo": 22.397333333333336}, "distributed/test_c10d_spawn_nccl": {"ProcessGroupShareTensorTest": 0.004, "TestDistributedNNFunctionsNccl": 0.009000000000000001}, "distributed/test_c10d_spawn_ucc": {"ProcessGroupShareTensorTest": 0.0030000000000000005, "TestDistributedNNFunctionsUcc": 0.006000000000000001}, "distributed/test_compute_comm_reordering": {"TestComputeCommReorderingMultiProc": 0.0013333333333333333}, "distributed/test_control_collectives": {"TestCollectives": 0.2956666666666667}, "distributed/test_cuda_p2p": {"ProcessGroupCudaP2PTest": 0.001}, "distributed/test_data_parallel": {"TestDataParallel": 0.006666666666666667, "TestDataParallelDeviceTypeCPU": 0.019666666666666673}, "distributed/test_device_mesh": {"DeviceMeshCollectiveTest": 25.200333333333333, "DeviceMeshCollectiveTestWithNativeFunCol": 10.831000000000001, "DeviceMeshTest": 33.4, "DeviceMeshTestNDim": 21.456333333333333, "DeviceMeshTestWithNativeFunCol": 14.667000000000002, "InitDeviceMeshTest": 12.633333333333335, "TestDeviceMeshGetItem": 25.51566666666667, "TestMeshEnv": 11.161333333333332}, "distributed/test_distributed_spawn": {"TestDistBackendWithSpawn": 1384.9206666666644}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 14.190333333333333, "TestMultiProc": 0.002, "TestSingleProc": 0.0006666666666666666}, "distributed/test_fake_pg": {"TestFakePG": 0.26466666666666666}, "distributed/test_functional_api": {"TestCollectivesWithNCCL": 7.685, "TestExpand": 0.4523333333333334, "TestFunctionalAutograd": 13.210333333333333, "TestFunctionalAutogradWithNCCL": 0.001, "TestGradCollectives": 0.0030000000000000005, "TestMakeFx": 0.034333333333333334, "TestMetaCollectives": 0.002, "TestNCCLCollectivesWithWorldSize4": 8.238999999999997, "TestOpWaitiness": 11.520000000000001, "TestPgTag": 0.02733333333333333, "TestTraceableCollectives": 0.11033333333333335}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 0.002, "TestCollectivesMultiProc": 0.001}, "distributed/test_launcher": {"TestDistributedLaunch": 1.287}, "distributed/test_multi_threaded_pg": {"TestCollectivesWithBaseClass": 0.08566666666666668, "TestCollectivesWithWrapper": 0.2833333333333334}, "distributed/test_pg_wrapper": {"ProcessGroupGlooWrapperTest": 29.284666666666666, "ProcessGroupNCCLWrapperTest": 0.008}, "distributed/test_store": {"FileStoreTest": 3.0453333333333332, "HashStoreTest": 1.7076666666666664, "InitPgWithNonUvStore": 0.5323333333333334, "InitPgWithUvStore": 0.5303333333333333, "LibUvTCPStoreTest": 8.747666666666667, "PrefixFileStoreTest": 2.467333333333333, "PrefixStoreTest": 0.0030000000000000005, "PrefixTCPStoreTest": 1.9506666666666668, "PythonStoreTest": 0.24433333333333332, "RendezvousEnvTest": 0.247, "RendezvousFileTest": 0.4873333333333334, "RendezvousTCPTest": 21.49866666666667, "RendezvousTest": 0.48666666666666664, "TCPStoreTest": 8.802, "TestMultiThreadedWait": 1.244, "TestPythonStore": 1.716, "TimeoutTest": 5.250666666666667}, "distributed/test_symmetric_memory": {"SymmetricMemoryTest": 0.0003333333333333333}}, "jit_legacy": {"test_jit_fuser_legacy": {"TestFuser": 0.0016666666666666668}, "test_jit_legacy": {"TestAliasAnalysis": 0.24766666666666667, "TestAsync": 0.25666666666666677, "TestAtenPow": 0.006000000000000001, "TestAutodiffJit": 0.03666666666666667, "TestAutodiffSubgraphSlicing": 0.19066666666666673, "TestAwait": 0.138, "TestBackends": 0.543, "TestBackendsWithCompiler": 0.11266666666666668, "TestBatchMM": 0.063, "TestBuiltins": 0.043000000000000003, "TestClassType": 0.6376666666666668, "TestComplex": 0.6153333333333334, "TestCustomOperators": 0.03366666666666668, "TestDCE": 0.014333333333333332, "TestDataParallel": 0.0013333333333333333, "TestDataclasses": 2.9646666666666657, "TestDeviceAnalysis": 0.09333333333333334, "TestDict": 0.3060000000000001, "TestDtypeAnalysis": 0.1163333333333333, "TestDtypeCustomRulesCPU": 1.5823333333333318, "TestEnum": 0.10600000000000002, "TestFreezing": 0.8380000000000004, "TestFrontend": 0.04033333333333333, "TestFrozenOptimizations": 6.126, "TestFunctionalBlocks": 0.005, "TestFunctionalToInplaceActivation": 0.08166666666666667, "TestGenerator": 0.04, "TestGetDefaultAttr": 0.012333333333333335, "TestGraphRewritePasses": 0.030666666666666665, "TestHash": 0.056333333333333326, "TestHooks": 0.47766666666666674, "TestIgnorableArgs": 0.008333333333333333, "TestIgnoreContextManager": 0.032, "TestInplaceToFunctionalActivation": 0.04033333333333333, "TestIsinstance": 0.14366666666666672, "TestJit": 4.0176666666666625, "TestJitGeneratedModule": 8.552999999999981, "TestJitProfiler": 0.001, "TestJitUtils": 0.012666666666666668, "TestList": 0.9090000000000004, "TestLogging": 0.037000000000000005, "TestMKLDNNReinplacing": 0.004, "TestMisc": 0.12333333333333336, "TestMixTracingScripting": 0.7943333333333334, "TestModels": 0.6576666666666667, "TestModuleAPIs": 0.09266666666666667, "TestModuleContainers": 0.8400000000000002, "TestModuleInterface": 0.278, "TestModules": 0.010333333333333333, "TestNamedTuple": 0.05400000000000001, "TestNnapiBackend": 5.229666666666665, "TestOpDecompositions": 0.013333333333333334, "TestOptimizeForMobilePreserveDebugInfo": 0.12, "TestParametrization": 0.06633333333333334, "TestPeephole": 0.31500000000000017, "TestProducerVersion": 0.001, "TestProfiler": 0.43333333333333335, "TestPythonBindings": 0.02266666666666667, "TestPythonBuiltinOP": 0.25866666666666666, "TestPythonIr": 0.017666666666666667, "TestRecursiveScript": 0.46566666666666684, "TestRemoveMutation": 0.09400000000000001, "TestSaveLoad": 0.2873333333333334, "TestSaveLoadFlatbuffer": 0.17133333333333337, "TestSaveLoadForOpVersion": 1.8179999999999998, "TestScript": 12.074333333333328, "TestScriptDict": 0.022000000000000006, "TestScriptList": 0.5766666666666668, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.10033333333333337, "TestScriptProfile": 0.25233333333333335, "TestSlice": 0.10600000000000002, "TestSparse": 0.04033333333333334, "TestStringFormatting": 0.08366666666666671, "TestSymbolicShapeAnalysis": 1.1439999999999995, "TestTensorBuiltins": 0.05433333333333334, "TestTensorCreationOps": 0.030000000000000002, "TestTensorMethods": 0.008666666666666668, "TestTorchbind": 0.08966666666666669, "TestTracer": 5.539999999999996, "TestTypeSharing": 0.35300000000000004, "TestTypesAndAnnotation": 0.07666666666666667, "TestTyping": 0.26266666666666677, "TestUnion": 0.2993333333333335, "TestUnsupportedOps": 0.03133333333333333, "TestUpgraders": 0.053666666666666675, "TestWarn": 0.03866666666666666, "TestWith": 0.18966666666666665}}}, "macos-12-py3-arm64": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 0.0}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.4326666666666667}, "distributions/test_constraints": {"test_constraints": 0.005}, "distributions/test_distributions": {"TestAgainstScipy": 0.452, "TestConstraints": 0.052, "TestDistributionShapes": 0.09300000000000003, "TestDistributions": 24.181333333333328, "TestFunctors": 0.005, "TestJit": 7.268666666666667, "TestKL": 2.434666666666666, "TestLazyLogitsInitialization": 0.004333333333333334, "TestNumericalStability": 0.02366666666666667, "TestRsample": 0.32933333333333337, "TestValidation": 0.338}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.20966666666666667}, "dynamo/test_after_aot": {"TestAfterAot": 3.800333333333333}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.3706666666666667}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 6.895333333333333}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.38566666666666666}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 1.0999999999999996}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.272, "NormalizeIRTests": 0.014333333333333332, "TestCustomBackendAPI": 0.529, "TestExplainWithBackend": 4.217333333333333, "TestOptimizations": 0.534}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 5.572333333333334}, "dynamo/test_base_output": {"TestBaseOutput": 0.0}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 3.789}, "dynamo/test_compile": {"InPlaceCompilationTests": 4.129333333333333, "PublicTorchCompilerTests": 0.0016666666666666668}, "dynamo/test_comptime": {"ComptimeTests": 0.39333333333333337}, "dynamo/test_config": {"ConfigTests": 0.47266666666666673}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.18066666666666667, "CppGuardManagerFuncTorchHigherOrderOpTests": 5.862333333333333, "CppGuardManagerFunctionTests": 9.069666666666668, "CppGuardManagerHigherOrderOpTests": 3.9229999999999983, "CppGuardManagerMiscTests": 18.332333333333327, "CppGuardManagerReproTests": 13.657666666666662}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.8083333333333337}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.10866666666666668}, "dynamo/test_decorators": {"DecoratorTests": 0.47633333333333344}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.009666666666666665}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 464.1526666666667, "DynamicShapesCtxManagerTests": 2.8190000000000004, "DynamicShapesExportTests": 1400.8080000000002, "DynamicShapesFuncTorchHigherOrderOpTests": 89.79699999999998, "DynamicShapesFunctionTests": 39.160999999999994, "DynamicShapesHigherOrderOpTests": 10.309333333333335, "DynamicShapesMiscTests": 54.95599999999999, "DynamicShapesNNModuleTests": 3.8483333333333327, "DynamicShapesReproTests": 52.209666666666664, "DynamicShapesSubGraphTests": 5.060666666666666, "DynamicShapesTestSDPA": 0.4463333333333333}, "dynamo/test_exc": {"ExcTests": 1.1463333333333334}, "dynamo/test_export": {"ExportTests": 9.43233333333333}, "dynamo/test_export_mutations": {"MutationExportTests": 0.4116666666666667}, "dynamo/test_frame_init": {"FrameInitTests": 0.09333333333333334}, "dynamo/test_functions": {"DefaultsTests": 0.47000000000000003, "FunctionTests": 9.708333333333359}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 0.7520000000000001}, "dynamo/test_global": {"TestGlobals": 0.4436666666666668}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.11800000000000004}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.03833333333333334, "FuncTorchHigherOrderOpTests": 5.348, "HigherOrderOpTests": 3.960999999999997, "HigherOrderOpVmapGuardTests": 1.998}, "dynamo/test_hooks": {"HooksTests": 10.132333333333335}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 4.212}, "dynamo/test_interop": {"InteropTests": 0.4206666666666667}, "dynamo/test_logging": {"LoggingTests": 6.6226666666666665}, "dynamo/test_minifier": {"MinifierTests": 0.8346666666666667}, "dynamo/test_misc": {"MiscTests": 20.782000000000018, "TestTracer": 0.027999999999999997}, "dynamo/test_model_output": {"TestHFPretrained": 0.0, "TestModelOutput": 0.0}, "dynamo/test_modules": {"NNModuleTests": 1.3416666666666657, "OptimizedModuleTest": 4.380666666666664}, "dynamo/test_nops": {"NopTests": 0.345}, "dynamo/test_optimizers": {"End2EndTests": 0.4606666666666667, "OptimizerTests": 0.8616666666666667}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.3873333333333333}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.7023333333333334}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.49533333333333335}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.555}, "dynamo/test_recompiles": {"RecompileTests": 0.5620000000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.4116666666666667}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.0023333333333333335}, "dynamo/test_repros": {"ReproTests": 16.35633333333333}, "dynamo/test_sdpa": {"TestSDPA": 0.403}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.40666666666666673}, "dynamo/test_sources": {"SourceTests": 0.37666666666666665}, "dynamo/test_structured_trace": {"StructuredTraceTest": 5.077000000000001}, "dynamo/test_subclasses": {"SubclassTests": 1.162666666666666, "TestNestedTensor": 5.304666666666667}, "dynamo/test_subgraphs": {"SubGraphTests": 1.3153333333333326}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.0, "TraceRuleTests": 0.8116666666666669}, "dynamo/test_triton_kernels": {"KernelTests": 0.04033333333333333, "MutationTests": 0.0, "NoOptimizationKernelTests": 0.0006666666666666666, "no_opt_test_class": 0.0013333333333333333}, "dynamo/test_unspec": {"UnspecTests": 5.605}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.4683333333333333}, "export/test_db": {"ExampleTests": 1.5363333333333327}, "export/test_experimental": {"TestExperiment": 0.44933333333333336}, "export/test_export": {"TestDynamismExpression": 0.39599999999999996, "TestExport": 13.692333333333332, "TestExportCustomClass": 0.0, "TestOneOffModelExportResult": 0.5746666666666667}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.242, "NonStrictExportTestExport": 11.891666666666666}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.331, "PreDispatchExportTestExport": 14.277999999999993}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.353}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.4716666666666667}, "export/test_hop": {"TestHOPCPU": 1.3493333333333333, "TestHOPGeneric": 0.002}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0, "TestLift": 0.0, "TestLiftUnlift": 0.0}, "export/test_pass_infra": {"TestPassInfra": 0.5830000000000001}, "export/test_passes": {"TestPasses": 5.058000000000001}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.4313333333333333, "RetraceExportTestExport": 18.61766666666666}, "export/test_safeguard": {"TestSafeguard": 0.5750000000000001}, "export/test_schema": {"TestSchema": 0.11866666666666666}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.1396666666666667, "SerDesExportPreDispatchTestExport": 11.168999999999999, "SerDesExportTestDynamismExpression": 0.322, "SerDesExportTestExport": 14.305333333333337}, "export/test_serialize": {"TestDeserialize": 0.05300000000000004, "TestOpVersioning": 0.0036666666666666666, "TestSaveLoad": 0.14233333333333334, "TestSchemaVersioning": 0.014666666666666666, "TestSerialize": 0.5493333333333335, "TestSerializeCustomClass": 0.002}, "export/test_torchbind": {"TestCompileTorchbind": 0.0, "TestExportTorchbind": 0.0, "TestRegisterFakeClass": 0.0}, "export/test_tree_utils": {"TestTreeUtils": 0.09366666666666668}, "export/test_unflatten": {"TestUnflatten": 1.480666666666667}, "export/test_upgrade": {"TestUpgrade": 0.41133333333333333}, "export/test_verifier": {"TestVerifier": 0.5553333333333335}, "functorch/test_aotdispatch": {"TestAOTAutograd": 4.679666666666665, "TestAOTDispatch": 0.205, "TestAOTExport": 1.002, "TestAOTModuleSimplified": 0.301, "TestEagerFusionModuleInfoCPU": 418.7296666666666, "TestEagerFusionOpInfoCPU": 1371.1090000000004, "TestPartitioning": 0.5316666666666667, "TestPythonKeyCPU": 0.17966666666666664}, "functorch/test_control_flow": {"TestControlFlow": 0.5053333333333333, "TestControlFlowTraced": 47.544333333333334}, "functorch/test_dims": {"TestMin": 6.470666666666666, "TestMinFunctorchOnly": 6.018999999999999}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.07200000000000001, "TestAutogradFunctionVmapAPICPU": 0.009333333333333334, "TestCompileTransformsCPU": 4.248666666666666, "TestComposabilityCPU": 0.8180000000000001, "TestExamplesCorrectnessCPU": 2.024666666666666, "TestFunctionalizeCPU": 0.053333333333333344, "TestGradTransformCPU": 0.17933333333333337, "TestHelpersCPU": 0.005, "TestHessianCPU": 0.013333333333333334, "TestHigherOrderOperatorInteractionCPU": 0.011000000000000003, "TestJacCPU": 0.22366666666666676, "TestJvpCPU": 0.027333333333333345, "TestLinearizeCPU": 0.09933333333333334, "TestMakeFunctional": 0.048333333333333346, "TestSliceArgnums": 0.010000000000000002, "TestVmapJvpInplaceViewCPU": 0.005333333333333333, "TestVmapOfGradCPU": 0.09066666666666669}, "functorch/test_logging": {"TestAOTLogging": 0.11633333333333333}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.40666666666666673, "RandomOpTestCase": 0.03666666666666666, "ReduceTestCase": 0.03900000000000001, "TestMemoryEfficientOpAuthoring": 0.0}, "functorch/test_minifier": {"TestMinifier": 0.238}, "functorch/test_ops": {"TestOperatorsCPU": 1100.673333333332}, "functorch/test_parsing": {"TestAnonymousAxis": 0.33266666666666667, "TestParsedExpression": 0.0030000000000000005, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.35533333333333333}, "functorch/test_vmap": {"TestRandomnessCPU": 0.9593333333333341, "TestTransformFailureCPU": 0.14, "TestVmapAPI": 0.3583333333333334, "TestVmapBatchedGradientCPU": 0.06233333333333337, "TestVmapDeviceTypeCPU": 0.084, "TestVmapNestedTensorCPU": 0.023333333333333334, "TestVmapOperators": 1.2133333333333318, "TestVmapOperatorsOpInfoCPU": 337.43466666666524}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.060666666666551}, "higher_order_ops/test_with_effects": {"TestWithEffects": 0.0013333333333333333}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 217.24333333333357, "AOTInductorTestABICompatibleCpuWithStackAllocation": 149.28366666666676, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 63.140000000000015, "AOTInductorTestABICompatibleCuda": 0.002, "AOTInductorTestNonABICompatibleCpu": 0.0026666666666666666, "AOTInductorTestNonABICompatibleCuda": 0.002}, "inductor/test_codecache": {"TestFxGraphCache": 11.555666666666667, "TestFxGraphCacheHashing": 0.4709999999999999, "TestUtils": 1.1079999999999999, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.19400000000000003}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 76.53699999999998, "TestAutogradWithCompiledAutograd": 16.40233333333327, "TestCompiledAutograd": 71.409, "TestCustomOpWithCompiledAutograd": 0.1960000000000001}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 187.7603333333333, "CompiledOptimizerTests": 87.02866666666665}, "inductor/test_config": {"TestInductorConfig": 3.0033333333333325}, "inductor/test_control_flow": {"CondTests": 0.001, "WhileLoopTests": 0.0}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.001}, "inductor/test_debug_trace": {"TestDebugTrace": 2.1823333333333337}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0003333333333333333}, "inductor/test_dependencies": {"TestDependencies": 0.0003333333333333333}, "inductor/test_flex_attention": {"TestTemplatedSDPA": 0.0}, "inductor/test_foreach": {"ForeachTests": 6.388000000000002}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuTests": 11.803333333333333}, "inductor/test_fx_fusion": {"TestFxFusion": 0.17933333333333334}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.10633333333333334, "TestGroupBatchFusion": 0.0, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.03233333333333334, "TestIndexingSimplification": 0.3273333333333333}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0}, "inductor/test_metrics": {"TestMetrics": 0.107}, "inductor/test_mmdecomp": {"TestDecompCPU": 14.716999999999992}, "inductor/test_profiler": {"DynamoProfilerTests": 0.0}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 6.892666666666667}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.001}, "inductor/test_torchinductor": {"CpuTests": 252.25266666666644, "SweepInputsCpuTest": 36.998999999999995, "TestFull": 3.844333333333333}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 554.1703333333334}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 597.9646666666667, "TestInductorDynamicCPU": 0.0033333333333333335}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 1165.6926666666661}, "inductor/test_triton_kernels": {"KernelTests": 0.0023333333333333335, "MutationTests": 0.0, "NoOptimizationKernelTests": 0.0, "no_opt_test_class": 0.0013333333333333333}, "inductor/test_utils": {"TestUtils": 0.09733333333333334}, "lazy/test_debug_util": {"DebugUtilTest": 0.336}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.3506666666666667}, "lazy/test_generator": {"LazyGeneratorTest": 0.337}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.618}, "lazy/test_step_closures": {"ClosuresTest": 2.3343333333333334}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.14766666666666664, "TestLazyOpInfoCPU": 2.2579999999999965, "TestLazyTensor": 0.272}, "nn/test_convolution": {"TestConvolutionNN": 87.258, "TestConvolutionNNDeviceTypeCPU": 8.760666666666637}, "nn/test_dropout": {"TestDropoutNN": 0.29833333333333334, "TestDropoutNNDeviceTypeCPU": 0.06866666666666667}, "nn/test_embedding": {"TestEmbeddingNN": 0.261, "TestEmbeddingNNDeviceTypeCPU": 2.2819999999999974}, "nn/test_init": {"TestNNInit": 2.9199999999999995}, "nn/test_lazy_modules": {"TestLazyModules": 0.5813333333333336}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.552, "TestLoadStateDictSwap": 0.017333333333333336}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.009000000000000001, "TestModuleHookNN": 0.03833333333333334, "TestModuleHooks": 0.26533333333333337, "TestStateDictHooks": 0.011333333333333336}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 9.611333333333333, "TestMultiheadAttentionNNDeviceTypeCPU": 0.036333333333333336}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.391}, "nn/test_parametrization": {"TestNNParametrization": 0.47800000000000004, "TestNNParametrizationDeviceCPU": 0.007333333333333333}, "nn/test_pooling": {"TestAvgPool": 0.8776666666666667, "TestPoolingNN": 0.46199999999999997, "TestPoolingNNDeviceTypeCPU": 21.01200000000001}, "nn/test_pruning": {"TestPruningNN": 0.277}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.063}, "profiler/test_memory_profiler": {"TestDataFlow": 0.5063333333333332, "TestIdentifyGradients": 0.06866666666666667, "TestMemoryProfiler": 0.326, "TestMemoryProfilerE2E": 1.2843333333333335}, "profiler/test_profiler": {"TestExecutionTrace": 3.722, "TestExperimentalUtils": 3.9383333333333326, "TestProfiler": 12.357666666666665, "TestProfilerCUDA": 0.0, "TestProfilerITT": 0.0, "TestRecordFunction": 0.26333333333333336, "TestTorchTidyProfiler": 2.485}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.0}, "profiler/test_record_function": {"TestRecordFunction": 0.335}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 1.9453333333333334}, "test_ao_sparsity": {"TestActivationSparsifier": 0.11199999999999999, "TestBaseDataScheduler": 0.015, "TestBaseDataSparsifier": 0.029666666666666664, "TestBaseSparsifier": 0.011666666666666667, "TestBaseStructuredSparsifier": 0.7443333333333335, "TestCubicScheduler": 0.0036666666666666666, "TestFPGMPruner": 0.012000000000000002, "TestFakeSparsity": 0.05166666666666667, "TestNearlyDiagonalSparsifier": 0.219, "TestNormDataSparsifiers": 0.317, "TestQuantizationUtils": 0.008666666666666668, "TestQuantizedSparseKernels": 0.13833333333333334, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.015333333333333332, "TestScheduler": 0.006000000000000001, "TestSparsityUtilFunctions": 0.017666666666666667, "TestWeightNormSparsifier": 0.17266666666666666}, "test_autocast": {"TestAutocastCPU": 1.0403333333333333, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.004}, "test_autograd": {"TestAllowMutationOnSaved": 0.018000000000000006, "TestAutograd": 6.724000000000018, "TestAutogradComplex": 0.005, "TestAutogradDeviceTypeCPU": 0.07800000000000006, "TestAutogradForwardMode": 0.042000000000000016, "TestAutogradForwardModeBatchedGrad": 0.009000000000000001, "TestAutogradFunctional": 2.7276666666666607, "TestAutogradInferenceMode": 0.03833333333333335, "TestAutogradLogging": 0.006333333333333333, "TestAutogradMultipleDispatchCPU": 0.011000000000000003, "TestMultithreadAutograd": 0.07933333333333335, "TestNestedCheckpoint": 0.11833333333333336}, "test_autograd_fallback": {"TestAutogradFallback": 0.37200000000000005}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 56.388666666676045}, "test_bundled_inputs": {"TestBundledInputs": 1.2043333333333326}, "test_comparison_utils": {"TestComparisonUtils": 0.3356666666666667}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCPU": 0.25266666666666665}, "test_content_store": {"TestContentStoreCPU": 3.321333333333333}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.3293333333333333, "TestMAIATensor": 0.007, "TestORTTensor": 0.007, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.3273333333333333, "TestMAIATensor": 0.007, "TestORTTensor": 0.007, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.001, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 81.20733333333334}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.2336666666666667}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 0.23}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.23466666666666666}, "test_custom_backend": {"TestCustomBackend": 0.14533333333333334}, "test_custom_ops": {"MiniOpTest": 0.2673333333333335, "MiniOpTestOther": 0.02700000000000001, "TestCustomOp": 5.2640000000000144, "TestCustomOpAPI": 0.05866666666666668, "TestCustomOpTestingCPU": 0.6726666666666667, "TestCustomOperators": 0.19533333333333336, "TestGenerateOpcheckTests": 0.08866666666666667}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 263.7103333333334, "TestConcatDataset": 0.006000000000000001, "TestConvAfterFork": 1.2009999999999998, "TestCustomPinFn": 0.0033333333333333335, "TestDataLoader": 448.3833333333334, "TestDataLoaderDeviceTypeCPU": 5.887333333333333, "TestDataLoaderPersistentWorkers": 407.98499999999996, "TestDatasetRandomSplit": 0.47500000000000003, "TestDictDataLoader": 6.155, "TestIndividualWorkerQueue": 0.002, "TestNamedTupleDataLoader": 0.007, "TestSetAffinity": 0.001, "TestStackDataset": 0.015000000000000001, "TestStringDataLoader": 0.0006666666666666666, "TestTensorDataset": 0.008666666666666668}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.0023333333333333335, "TestDataChunk": 0.23299999999999998, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 1.7979999999999994, "TestFunctionalMapDataPipe": 0.018333333333333337, "TestGraph": 0.006000000000000001, "TestIterDataPipeCountSampleYielded": 0.005333333333333333, "TestIterDataPipeGraphFastForward": 0.018000000000000002, "TestIterDataPipeSingletonConstraint": 0.01, "TestIterableDataPipeBasic": 0.019000000000000003, "TestSerialization": 0.0, "TestSharding": 22.53233333333333, "TestStreamWrapper": 0.09433333333333334, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCPU": 0.3486666666666667, "HasDecompTest": 3.6733333333333333, "TestDecompCPU": 2195.7853333333237}, "test_deploy": {"TestFreezer": 0.3376666666666666}, "test_dispatch": {"TestDispatch": 18.489, "TestPythonDispatcher": 0.009333333333333334}, "test_dlpack": {"TestTorchDlPackCPU": 0.34433333333333344}, "test_dynamic_shapes": {"TestDimConstraints": 0.989, "TestFloorDiv": 0.027666666666666673, "TestPySymInt": 0.6883333333333336, "TestSymNumberMagicMethods": 0.6670000000000004}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 0.9763333333333337, "TestExpandedWeightHelperFunctionCPU": 0.26666666666666666, "TestExpandedWeightModuleCPU": 1.8733333333333333}, "test_fake_tensor": {"FakeTensorConstHandling": 0.03100000000000001, "FakeTensorConverterTest": 0.012333333333333335, "FakeTensorDispatchCache": 0.03566666666666667, "FakeTensorOpInfoTestCPU": 0.062, "FakeTensorOperatorInvariants": 0.128, "FakeTensorPropTest": 0.039, "FakeTensorSerialization": 0.0030000000000000005, "FakeTensorTest": 0.39399999999999996, "PropagateRealTensorsFakeTensorConstHandling": 0.08233333333333333, "PropagateRealTensorsFakeTensorConverterTest": 0.010333333333333335, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.042333333333333334, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.08066666666666666, "PropagateRealTensorsFakeTensorPropTest": 0.019666666666666666, "PropagateRealTensorsFakeTensorTest": 0.09600000000000002}, "test_flop_counter": {"TestFlopCounter": 0.29100000000000004}, "test_foreach": {"TestForeachCPU": 49.91800000000023}, "test_function_schema": {"TestFunctionSchema": 0.459}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 22.183333333333337}, "test_functional_optim": {"TestFunctionalOptimParity": 0.0}, "test_functionalization": {"TestCrossRefFunctionalization": 1.2299999999999998, "TestFunctionalization": 1.5906666666666647}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.009333333333333332}, "test_futures": {"TestFuture": 0.973}, "test_fx": {"AnnotationsTest": 0.009000000000000001, "TestCSEPass": 0.11166666666666669, "TestCommonPass": 0.028999999999999998, "TestConstFold": 0.06833333333333334, "TestConstParamShapeInControlFlow": 0.018, "TestDCE": 0.014, "TestFX": 3.723666666666652, "TestFXAPIBackwardCompatibility": 0.012333333333333335, "TestFunctionalTracing": 0.19300000000000014, "TestMatcher": 0.5743333333333335, "TestOperatorSignaturesCPU": 3.4543333333333295, "TestPassManager": 0.011000000000000003, "TestSourceMatcher": 0.532, "TestSubgraphRewriter": 0.1236666666666667, "TestVisionTracing": 217.68300000000005, "TypeCheckerTest": 0.10966666666666669}, "test_fx_experimental": {"TestFXExperimental": 0.7293333333333334, "TestNormalizeOperatorsCPU": 16.58133333333332, "TestTranslationValidation": 0.06733333333333334}, "test_fx_passes": {"TestFXGraphPasses": 0.5583333333333335, "TestFXMatcherUtils": 0.04433333333333334}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.448}, "test_import_stats": {"TestImportTime": 1.7313333333333334}, "test_indexing": {"NumpyTestsCPU": 0.08366666666666667, "TestIndexingCPU": 0.8453333333333335}, "test_itt": {"TestItt": 0.0}, "test_jit": {"TestAliasAnalysis": 0.16866666666666666, "TestAsync": 0.15233333333333335, "TestAtenPow": 0.012000000000000002, "TestAutodiffJit": 0.02466666666666667, "TestAutodiffSubgraphSlicing": 0.10900000000000004, "TestAwait": 0.08633333333333336, "TestBackends": 0.0, "TestBackendsWithCompiler": 0.0, "TestBatchMM": 0.032, "TestBuiltins": 0.025666666666666667, "TestClassType": 1.154, "TestComplex": 0.2273333333333334, "TestCustomOperators": 0.020333333333333346, "TestDCE": 0.009333333333333334, "TestDataParallel": 0.0, "TestDataclasses": 1.9193333333333331, "TestDeviceAnalysis": 0.04900000000000001, "TestDict": 0.16833333333333342, "TestDtypeAnalysis": 0.07833333333333334, "TestDtypeCustomRulesCPU": 1.4213333333333322, "TestEnum": 0.09600000000000002, "TestFreezing": 0.9730000000000002, "TestFrontend": 0.19833333333333333, "TestFrozenOptimizations": 2.7706666666666666, "TestFunctionalBlocks": 0.0030000000000000005, "TestFunctionalToInplaceActivation": 0.14433333333333334, "TestGenerator": 0.029333333333333336, "TestGetDefaultAttr": 0.007333333333333333, "TestGraphRewritePasses": 0.015, "TestHash": 0.028666666666666663, "TestHooks": 0.2826666666666668, "TestIgnorableArgs": 0.005333333333333333, "TestIgnoreContextManager": 0.0, "TestInplaceToFunctionalActivation": 0.01833333333333333, "TestIsinstance": 0.0806666666666667, "TestJit": 2.570333333333329, "TestJitGeneratedModule": 4.823000000000018, "TestJitProfiler": 0.0, "TestJitUtils": 0.013000000000000005, "TestList": 0.5013333333333335, "TestLogging": 0.02033333333333333, "TestMKLDNNReinplacing": 0.0, "TestMisc": 0.07033333333333334, "TestMixTracingScripting": 0.482, "TestModels": 0.4356666666666667, "TestModuleAPIs": 0.05266666666666667, "TestModuleContainers": 0.47633333333333344, "TestModuleInterface": 0.21900000000000006, "TestModules": 0.006666666666666667, "TestNamedTuple": 0.026000000000000006, "TestNnapiBackend": 0.0, "TestOpDecompositions": 0.007333333333333333, "TestOptimizeForMobilePreserveDebugInfo": 0.06733333333333334, "TestParametrization": 0.034333333333333334, "TestPeephole": 0.17033333333333345, "TestProducerVersion": 0.001, "TestProfiler": 0.045333333333333344, "TestPythonBindings": 0.015666666666666666, "TestPythonBuiltinOP": 0.11433333333333336, "TestPythonIr": 0.007333333333333333, "TestRecursiveScript": 0.36066666666666686, "TestRemoveMutation": 0.04466666666666667, "TestSaveLoad": 0.20800000000000005, "TestSaveLoadFlatbuffer": 0.233, "TestSaveLoadForOpVersion": 1.7156666666666665, "TestScript": 15.901333333333355, "TestScriptDict": 0.011000000000000003, "TestScriptList": 0.018000000000000006, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.061, "TestScriptProfile": 0.14233333333333334, "TestSlice": 0.05966666666666668, "TestSparse": 0.009000000000000001, "TestStringFormatting": 0.06033333333333336, "TestSymbolicShapeAnalysis": 1.3973333333333322, "TestTensorBuiltins": 0.027999999999999997, "TestTensorCreationOps": 0.01833333333333333, "TestTensorMethods": 0.005, "TestTorchbind": 0.0, "TestTracer": 1.075333333333334, "TestTypeSharing": 0.18966666666666668, "TestTypesAndAnnotation": 0.055000000000000014, "TestTyping": 0.1483333333333334, "TestUnion": 0.17766666666666678, "TestUnsupportedOps": 0.012666666666666668, "TestUpgraders": 0.03166666666666667, "TestWarn": 0.020666666666666667, "TestWith": 0.19933333333333336}, "test_jit_autocast": {"TestAutocast": 0.037666666666666675, "TestJitTraceAutocast": 17.401}, "test_jit_disabled": {"TestJitDisabled": 0.4203333333333333}, "test_jit_fuser_te": {"TestFuserCommon": 0.028999999999999998, "TestLoopnestRandomizationCPU": 0.0, "TestNNCOpInfoCPU": 7.961333333333349, "TestTEFuserDynamic": 52.24866666666667, "TestTEFuserStatic": 50.56133333333333}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.0016666666666666668, "TestFusionPatternCPU": 0.0, "TestModel": 0.0, "TestOpCPU": 0.0006666666666666666}, "test_legacy_vmap": {"TestVmapAPI": 0.6256666666666667, "TestVmapAPILegacy": 0.5586666666666668, "TestVmapBatchedGradientCPU": 0.032666666666666684, "TestVmapBatchedGradientLegacyCPU": 0.03800000000000001, "TestVmapOperators": 0.4583333333333335, "TestVmapOperatorsLegacy": 0.45900000000000013}, "test_license": {"TestLicense": 0.3826666666666667}, "test_linalg": {"TestLinalgCPU": 83.34500000000013}, "test_logging": {"LoggingTest": 1.2616666666666665}, "test_masked": {"TestMaskedCPU": 4.166666666666662}, "test_maskedtensor": {"TestBasicsCPU": 0.038666666666666676, "TestBinary": 0.12433333333333339, "TestOperatorsCPU": 2.1936666666666382, "TestReductions": 0.032, "TestUnary": 0.37233333333333346}, "test_meta": {"TestMetaCPU": 935.8046666666396, "TestMetaConverter": 0.466}, "test_mkl_verbose": {"TestMKLVerbose": 1.7816666666666665}, "test_mkldnn": {"TestMkldnnCPU": 0.002}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 2.0686666666666667}, "test_mobile_optimizer": {"TestOptimizer": 0.8073333333333333}, "test_model_dump": {"TestModelDump": 0.3863333333333334}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.0}, "test_module_init": {"TestModuleInitCPU": 1.204999999999991}, "test_module_tracker": {"TestModuleTracker": 0.3416666666666666}, "test_modules": {"TestModuleCPU": 156.8326666666743, "TestModuleMPS": 212.60933333333728}, "test_monitor": {"TestMonitor": 0.327, "TestMonitorTensorboard": 0.18466666666666667}, "test_multiprocessing": {"TestMultiprocessing": 153.85733333333334}, "test_multiprocessing_spawn": {"ErrorTest": 0.0016666666666666668, "ForkTest": 0.2186666666666667, "SpawnTest": 10.583666666666668}, "test_namedtensor": {"TestNamedTensor": 0.7533333333333335}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.2573333333333332}, "test_native_functions": {"TestNativeFunctions": 0.39966666666666667}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.3196666666666667}, "test_nestedtensor": {"TestNestedTensor": 0.1256666666666667, "TestNestedTensorAutogradCPU": 0.3250000000000001, "TestNestedTensorDeviceTypeCPU": 0.8000000000000004, "TestNestedTensorSubclassCPU": 5.676000000000002}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.35300000000000004, "TestFusionUtils": 0.002, "TestNN": 33.29666666666671, "TestNNDeviceTypeCPU": 73.17900000000039, "TestUtils": 0.002}, "test_numba_integration": {"TestNumbaIntegration": 0.23433333333333337}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.32700000000000007}, "test_openmp": {"TestOpenMP_ParallelFor": 3.237666666666667}, "test_ops": {"TestCommonCPU": 784.1056666666437, "TestCompositeComplianceCPU": 395.1533333333294, "TestFakeTensorCPU": 108.38633333333298, "TestMathBitsCPU": 13.452666666666596, "TestRefsOpsInfoCPU": 0.8760000000000007, "TestSelfKwarg": 0.20633333333333334, "TestTagsCPU": 4.056999999999979}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 160.4293333333375}, "test_ops_gradients": {"TestBwdGradientsCPU": 530.7793333333005}, "test_ops_jit": {"TestJitCPU": 803.6069999999991}, "test_optim": {"TestDifferentiableOptimizer": 0.3046666666666667, "TestLRScheduler": 0.45833333333333354, "TestOptim": 13.256499999999999, "TestOptimRenewedCPU": 8.806333333333304, "TestOptimRenewedMPS": 152.55000000000098, "TestSWAUtils": 0.04566666666666667}, "test_out_dtype_op": {"TestOutDtypeOp": 0.3076666666666667}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.0016666666666666668, "TestGradCheckOverride": 0.007, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.04700000000000001, "TestTorchFunctionMode": 0.025000000000000012, "TestTorchFunctionOverride": 1.7673333333332504, "TestTorchFunctionWarning": 0.005, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.038666666666666676, "ModelTest": 0.0, "TestAnalyze": 0.3443333333333334, "TestDependencyAPI": 0.025333333333333343, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014000000000000005, "TestImporter": 0.006000000000000001, "TestLoadBCPackages": 0.036333333333333336, "TestMangling": 0.011000000000000001, "TestMisc": 0.023666666666666673, "TestPackageFX": 0.029666666666666664, "TestPackageScript": 0.18033333333333337, "TestRepackage": 0.005333333333333333, "TestResources": 0.006333333333333334, "TestSaveLoad": 0.017}, "test_per_overload_api": {"TestPerOverloadAPI": 0.3503333333333334}, "test_prims": {"TestDecompCPU": 0.15233333333333335, "TestPrimsBasic": 0.23866666666666667, "TestPrimsCPU": 0.037333333333333336, "TestRefsCPU": 0.005333333333333333}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.038666666666666676, "TestGenericProxyTensorFake": 0.23966666666666678, "TestGenericProxyTensorReal": 0.17966666666666675, "TestGenericProxyTensorSymbolic": 0.2736666666666667, "TestProxyTensorOpInfoCPU": 291.8076666666691, "TestRealProxyTensor": 0.006333333333333334, "TestSymbolicTracing": 1.050666666666667}, "test_pruning_op": {"PruningOpTest": 0.3916666666666666}, "test_public_bindings": {"TestPublicBindings": 0.342}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.002, "TestPythonDispatch": 2.6486666666666667, "TestPythonDispatcher": 0.0030000000000000005, "TestPythonRegistration": 0.13, "TestWrapperSubclassAliasingCPU": 0.06433333333333337}, "test_pytree": {"TestCxxPytree": 0.0003333333333333333, "TestGenericPytree": 0.3923333333333334, "TestPythonPytree": 0.035333333333333355}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.019000000000000006, "TestAOMigrationQuantization": 0.011333333333333336, "TestAOMigrationQuantizationFx": 0.013333333333333336, "TestBackendConfig": 0.020333333333333346, "TestBiasCorrectionEager": 0.002, "TestBits": 0.002, "TestBitsCPU": 0.043333333333333335, "TestComparatorOps": 0.38566666666666666, "TestDeprecatedJitQuantized": 0.030000000000000002, "TestDistributed": 0.016666666666666666, "TestDuplicateDQPass": 0.7353333333333333, "TestDynamicQuantizedModule": 0.03233333333333333, "TestDynamicQuantizedOps": 0.05133333333333334, "TestEqualizeEager": 0.028666666666666663, "TestEqualizeFx": 0.371, "TestFXGraphMatcher": 0.46666666666666673, "TestFXGraphMatcherModels": 0.0, "TestFXNumericSuiteCoreAPIs": 1.2206666666666663, "TestFXNumericSuiteCoreAPIsModels": 0.011000000000000003, "TestFXNumericSuiteNShadows": 4.187333333333334, "TestFakeQuantize": 0.11733333333333335, "TestFakeQuantizeOps": 0.7560000000000001, "TestFloat8DtypeCPU": 0.09133333333333334, "TestFloat8DtypeCPUOnlyCPU": 0.14500000000000002, "TestFuseEager": 0.0, "TestFuseFx": 0.22600000000000006, "TestFusedObsFakeQuant": 0.028666666666666663, "TestFusedObsFakeQuantModule": 0.04733333333333334, "TestFusionPasses": 0.009, "TestFxDetectInputWeightEqualization": 0.0030000000000000005, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006333333333333334, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.06766666666666667, "TestFxModelReportObserver": 0.053, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.21766666666666667, "TestGraphUtils": 0.42, "TestHistogramObserver": 10.800000000000002, "TestMetaDataPorting": 1.5933333333333335, "TestModelNumericsEager": 0.021000000000000005, "TestNumericSuiteEager": 0.01800000000000001, "TestObserver": 0.9330000000000002, "TestPT2ERepresentation": 9.866333333333335, "TestPadding": 16.17233333333333, "TestQNNPackOps": 0.0006666666666666666, "TestQuantizationDocs": 0.17733333333333334, "TestQuantizeDynamicJitOps": 0.0030000000000000005, "TestQuantizeDynamicJitPasses": 0.16566666666666666, "TestQuantizeEagerOps": 0.36533333333333334, "TestQuantizeEagerPTQDynamic": 0.0, "TestQuantizeEagerPTQStatic": 0.06333333333333334, "TestQuantizeEagerQAT": 0.019000000000000003, "TestQuantizeEagerQATNumerics": 0.674, "TestQuantizeFx": 0.001, "TestQuantizeFxModels": 0.005, "TestQuantizeFxOps": 0.0006666666666666666, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.27666666666666667, "TestQuantizeJitPasses": 3.5046666666666657, "TestQuantizePT2E": 18.123, "TestQuantizePT2EQAT": 17.316333333333333, "TestQuantizePT2EQATModels": 0.0, "TestQuantizePT2EQAT_ConvBn1d": 128.00766666666667, "TestQuantizePT2EQAT_ConvBn2d": 131.29066666666668, "TestQuantizePT2EX86Inductor": 0.031000000000000017, "TestQuantizedConv": 1.061, "TestQuantizedEmbeddingOps": 0.0, "TestQuantizedFunctionalOps": 0.23833333333333337, "TestQuantizedLinear": 0.14433333333333334, "TestQuantizedOps": 20.34233333333334, "TestQuantizedTensor": 0.6426666666666668, "TestRecordHistogramObserver": 0.009333333333333334, "TestReferenceQuantizedModule": 0.016, "TestSerialization": 0.02933333333333334, "TestStaticQuantizedModule": 0.0676666666666667, "TestSubgraphRewriter": 0.06966666666666667, "TestUtils": 0.006000000000000001, "TestXNNPACKQuantizer": 11.442, "TestXNNPACKQuantizerModels": 0.0}, "test_reductions": {"TestReductionsCPU": 94.8863333333323}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 1.6886666666666652}, "test_schema_check": {"TestSchemaCheck": 0.35900000000000004, "TestSchemaCheckModeOpInfoCPU": 319.9706666666555}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.5123333333333336}, "test_serialization": {"TestBothSerializationCPU": 0.09433333333333334, "TestOldSerialization": 27.193, "TestSerialization": 3.7549999999999955, "TestSubclassSerialization": 0.006666666666666667}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.32}, "test_shape_ops": {"TestShapeOpsCPU": 0.9593333333333338}, "test_show_pickle": {"TestShowPickle": 0.31866666666666665}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.454333333333328}, "test_sparse": {"TestSparseAnyCPU": 159.60099999999838, "TestSparseCPU": 9.262333333333322, "TestSparseLegacyAndDeprecation": 0.28500000000000003, "TestSparseMaskedReductionsCPU": 0.2846666666666668, "TestSparseMeta": 1.463333333333333, "TestSparseOneOff": 0.0, "TestSparseUnaryUfuncsCPU": 3.6266666666665834}, "test_sparse_csr": {"TestSparseCSRCPU": 52.67933333333381, "TestSparseCSRSampler": 0.17633333333333331, "TestSparseCompressedCPU": 60.90933333333348, "TestSparseCompressedTritonKernelsCPU": 0.0}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0}, "test_spectral_ops": {"TestFFTCPU": 4.638999999999993, "TestFFTDocExamplesCPU": 0.20900000000000005}, "test_stateless": {"TestPythonOptimizeMode": 1.7646666666666668, "TestStatelessDeprecation": 0.7293333333333333, "TestStatelessFunctionalAPI": 0.33733333333333343}, "test_subclass": {"TestSubclass": 0.4240000000000001}, "test_sympy_utils": {"TestSingletonInt": 0.0030000000000000005, "TestSympyInterp": 0.3276666666666668, "TestSympySolve": 0.15233333333333335, "TestValueRanges": 8.13733333333333}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.23866666666666683, "TestBufferProtocolCPU": 0.2426666666666668, "TestLikeTensorCreationCPU": 0.006000000000000001, "TestRandomTensorCreationCPU": 0.9556666666666668, "TestTensorCreationCPU": 12.728333333333296}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.014333333333333335, "TestTensorBoardFigure": 0.0, "TestTensorBoardNumpy": 0.001, "TestTensorBoardPyTorchNumpy": 0.38400000000000006, "TestTensorBoardPytorchGraph": 0.13633333333333333, "TestTensorBoardSummary": 0.015333333333333336, "TestTensorBoardSummaryWriter": 0.007666666666666666, "TestTensorBoardUtils": 0.06833333333333334, "TestTensorBoardWriter": 0.26033333333333336, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 10.915999999999999}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.0033333333333333335, "TestTensorExprPyBind": 0.3406666666666667}, "test_testing": {"TestAssertClose": 0.22433333333333338, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.02233333333333334, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.006000000000000001, "TestAssertCloseSparseBSR": 0.006000000000000001, "TestAssertCloseSparseCOO": 0.008333333333333333, "TestAssertCloseSparseCSC": 0.006333333333333333, "TestAssertCloseSparseCSR": 0.006666666666666667, "TestFrameworkUtils": 4.709333333333333, "TestImports": 5.047999999999999, "TestMakeTensorCPU": 0.8333333333333339, "TestOpInfoSampleFunctionsCPU": 2.267666666666639, "TestOpInfos": 0.002, "TestTestParametrization": 0.02000000000000001, "TestTestParametrizationDeviceTypeCPU": 1.6469999999999985, "TestTestingCPU": 0.426}, "test_torch": {"TestBasicVitalSigns": 0.004, "TestTorch": 4.623999999999998, "TestTorchDeviceTypeCPU": 6.578333333333302, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 3.7569999999999997, "TestAttnMasksCPU": 15.164333333333332, "TestSDPACPU": 155.32199999999963, "TestSDPAFailureModesCPU": 0.016000000000000004, "TestTransformersCPU": 4.086666666666667}, "test_type_hints": {"TestTypeHints": 0.22899999999999998}, "test_type_info": {"TestDTypeInfo": 0.35633333333333334}, "test_type_promotion": {"TestTypePromotionCPU": 4.894999999999961}, "test_typing": {"TestTyping": 0.0}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 225.68266666664212}, "test_utils": {"TestAssert": 0.024333333333333335, "TestBottleneck": 8.106666666666667, "TestCheckpoint": 0.08300000000000002, "TestCollectEnv": 1.5713333333333335, "TestCppExtensionUtils": 0.05333333333333334, "TestDataLoaderUtils": 29.031666666666666, "TestDeviceUtilsCPU": 14.094333333334262, "TestExtensionUtils": 0.004, "TestHipify": 0.001, "TestHipifyTrie": 0.0, "TestONNXUtils": 0.002, "TestRenderUtils": 0.006666666666666667, "TestStandaloneCPPJIT": 5.305, "TestTraceback": 0.007333333333333333}, "test_view_ops": {"TestOldViewOpsCPU": 5.308666666666668, "TestViewOpsCPU": 1.7943333333333278, "TestViewOpsLAZY": 0.2790000000000002}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.0, "WeakKeyDictionaryTestCase": 0.017000000000000005, "WeakTest": 2.3729999999999993}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 17.105666666666668, "TestXNNPACKOps": 1.4873333333333332, "TestXNNPACKRewritePass": 0.27, "TestXNNPACKSerDes": 1.5680000000000003}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.10200000000000002, "TestClassGetItem": 0.039, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.047000000000000014, "TestPromotion": 0.0}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 4.847333333333334, "TestEinsumPath": 0.0, "TestMisc": 0.002}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.22966666666666669, "TestHalf": 0.0, "TestIinfo": 0.09666666666666668, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.002, "TestBooleanIndexing": 0.017, "TestBroadcastedAssignments": 0.03133333333333333, "TestFancyIndexingCast": 0.002, "TestFloatNonIntegerArgument": 0.005, "TestIndexing": 0.21300000000000008, "TestMultiIndexingAutomated": 0.004, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.018000000000000002, "TestArgmax": 0.3893333333333336, "TestArgmaxArgminCommon": 0.02066666666666667, "TestArgmin": 0.4033333333333336, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.019000000000000006, "TestArrayCreationCopyArgument": 0.0, "TestArrayInterface": 0.018333333333333337, "TestAssignment": 0.007, "TestAttributes": 0.006000000000000001, "TestBinop": 0.007666666666666666, "TestBool": 8.445666666666666, "TestCequenceMethods": 0.001, "TestChoose": 0.006000000000000001, "TestClip": 0.0023333333333333335, "TestCompress": 0.0030000000000000005, "TestConversion": 0.013000000000000003, "TestCreation": 0.0, "TestDelMisc": 0.001, "TestDot": 0.026666666666666682, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.011333333333333334, "TestFlag": 0.002, "TestFormat": 0.0030000000000000005, "TestFromBuffer": 0.009000000000000001, "TestHash": 0.13333333333333333, "TestHashing": 0.002, "TestIO": 0.0, "TestInner": 0.07233333333333332, "TestLexsort": 0.013000000000000003, "TestMatmul": 0.3400000000000001, "TestMatmulOperator": 0.3036666666666667, "TestMethods": 0.542666666666667, "TestMinMax": 0.0023333333333333335, "TestMinScalarType": 0.004, "TestNewaxis": 0.002, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008, "TestRepeat": 0.005, "TestResize": 0.018000000000000002, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.013000000000000003, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.06200000000000003, "TestStats": 0.09000000000000001, "TestSubscripting": 0.001, "TestTake": 0.02066666666666667, "TestVdot": 0.014000000000000004, "TestViewDtype": 0.006000000000000001, "TestWarnings": 0.001, "TestWhere": 0.16, "TestWritebackIfCopy": 0.012666666666666666}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.009000000000000001, "TestArgwhere": 0.014333333333333335, "TestArrayComparisons": 0.013666666666666667, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.007333333333333333, "TestBoolArray": 1.028, "TestBoolCmp": 0.06233333333333333, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.09700000000000007, "TestConvolve": 0.021666666666666667, "TestCorrelate": 0.048999999999999995, "TestCreationFuncs": 0.37533333333333335, "TestCross": 0.022000000000000002, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006000000000000001, "TestFromiter": 0.0, "TestIndex": 0.002, "TestIndices": 0.02266666666666667, "TestIsclose": 0.032, "TestIsscalar": 0.002, "TestLikeFuncs": 0.0006666666666666666, "TestMoveaxis": 0.011000000000000001, "TestNonarrayArgs": 0.051000000000000024, "TestNonzeroAndCountNonzero": 0.11733333333333336, "TestOuterMisc": 0.002, "TestRequire": 0.004, "TestResize": 0.14300000000000002, "TestRoll": 0.012000000000000002, "TestRollaxis": 0.002, "TestSeterr": 0.004, "TestStdVar": 0.01, "TestStdVarComplex": 0.004, "TestStringFunction": 0.001, "TestTensordot": 0.008666666666666668, "TestTypes": 0.006000000000000001}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.3196666666666667, "TestDocStrings": 0.0, "TestIsSubDType": 0.006000000000000001, "TestScalarTypeNames": 0.021000000000000008}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.060000000000000046, "TestFromInt": 0.0030000000000000005, "TestFromString": 0.321}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.22533333333333336, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.04000000000000001, "TestBaseMath": 3.1283333333333334, "TestBitShifts": 0.034, "TestComplexDivision": 0.021333333333333333, "TestConversion": 0.018000000000000002, "TestHash": 0.0, "TestModulus": 0.3486666666666666, "TestMultiply": 0.0, "TestNegative": 0.009333333333333334, "TestPower": 0.04466666666666667, "TestRepr": 0.001, "TestScalarOpsMisc": 0.05000000000000002, "TestScalarSubclassingMisc": 0.0016666666666666668, "TestSubtract": 0.009000000000000001, "TestTypes": 5.762999999999999}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.32266666666666666, "TestAtleast2d": 0.005, "TestAtleast3d": 0.004, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.09300000000000004, "TestHstack": 0.007, "TestStackMisc": 0.0, "TestVstack": 0.007666666666666666}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.004, "TestFFTShift": 2.3093333333333335, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.004}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.852, "TestFFTShift": 0.3193333333333333, "TestFFTThreadSafe": 0.3996666666666666}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.325}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0016666666666666668, "TestUnique": 0.14533333333333334}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.0030000000000000005, "TestAmax": 0.0030000000000000005, "TestAmin": 0.0030000000000000005, "TestAngle": 0.0030000000000000005, "TestAny": 0.0030000000000000005, "TestAverage": 0.010000000000000002, "TestBincount": 0.03333333333333335, "TestCheckFinite": 0.002, "TestCopy": 0.0036666666666666666, "TestCorrCoef": 0.016666666666666666, "TestCov": 0.03466666666666667, "TestCumprod": 0.011000000000000001, "TestCumsum": 0.015, "TestDelete": 0.005333333333333333, "TestDiff": 0.03366666666666667, "TestDigitize": 0.011000000000000003, "TestExtins": 0.0030000000000000005, "TestFilterwindows": 0.3960000000000003, "TestFlip": 0.013000000000000003, "TestGradient": 0.05233333333333334, "TestInsert": 0.008, "TestInterp": 0.029666666666666685, "TestKaiser": 0.004666666666666667, "TestMedian": 0.043666666666666666, "TestMeshgrid": 0.02166666666666667, "TestMsort": 0.0, "TestPercentile": 0.03900000000000001, "TestPiecewise": 0.008, "TestProd": 0.011000000000000001, "TestPtp": 0.004, "TestQuantile": 0.04033333333333334, "TestRot90": 0.159, "TestSelect": 0.006000000000000001, "TestSinc": 0.004, "TestSortComplex": 0.007, "TestTrapz": 0.0030000000000000005, "TestTrimZeros": 0.009000000000000001, "TestUnique": 0.0033333333333333335, "Test_I0": 0.008}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.3940000000000001, "TestHistogramOptimBinNums": 0.031666666666666676, "TestHistogramdd": 0.07733333333333335}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006000000000000001, "TestDiagIndices": 0.002, "TestDiagIndicesFrom": 0.004, "TestFillDiagonal": 0.009333333333333334, "TestGrid": 0.007, "TestIndexExpression": 0.004, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.327}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.009000000000000001, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.057000000000000016, "TestColumnStack": 0.004, "TestDsplit": 0.006000000000000001, "TestDstack": 0.006000000000000001, "TestExpandDims": 0.004, "TestHsplit": 0.006000000000000001, "TestKron": 0.004, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.007, "TestSplit": 0.0030000000000000005, "TestSqueeze": 0.011000000000000003, "TestTakeAlongAxis": 0.33899999999999997, "TestTile": 0.029333333333333336, "TestVsplit": 0.005}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.013999999999999999, "TestEye": 0.3416666666666666, "TestFliplr": 0.004, "TestFlipud": 0.002, "TestHistogram2d": 0.017, "TestTri": 0.032, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.001, "TestVander": 0.007}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.32666666666666666, "TestImag": 0.004666666666666667, "TestIscomplex": 0.0023333333333333335, "TestIscomplexobj": 0.0030000000000000005, "TestIsfinite": 0.007, "TestIsinf": 0.006333333333333334, "TestIsnan": 0.007, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.0036666666666666666, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.0030000000000000005, "TestNanToNum": 0.006000000000000001, "TestReal": 0.005, "TestRealIfClose": 0.002}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.06066666666666668, "TestCond": 0.08, "TestDet": 0.056000000000000015, "TestEig": 0.014666666666666668, "TestEigh": 0.020000000000000004, "TestEighCases": 0.0, "TestEigvals": 0.02133333333333334, "TestEigvalsh": 0.018000000000000002, "TestEigvalshCases": 0.0, "TestInv": 0.01966666666666667, "TestLstsq": 0.07733333333333332, "TestMatrixRank": 0.11900000000000001, "TestMisc": 0.06, "TestMisc2": 0.004, "TestMultiDot": 0.025333333333333336, "TestNormDouble": 0.36999999999999994, "TestNormInt64": 0.36633333333333334, "TestNormSingle": 0.36566666666666664, "TestNorm_NonSystematic": 0.002, "TestPinv": 0.03933333333333333, "TestPinvHermitian": 0.012000000000000002, "TestQR": 1.606333333333333, "TestSVD": 0.017666666666666667, "TestSVDHermitian": 0.035, "TestSolve": 0.1516666666666667, "TestTensorinv": 0.013666666666666667, "TestTensorsolve": 0.009333333333333334}, "torch_np/test_basic": {"TestArrayToSequence": 0.006000000000000001, "TestCopyTo": 0.007, "TestCtorNested": 0.0016666666666666668, "TestDefaultDtype": 0.004, "TestDivmod": 0.007, "TestExport": 0.0, "TestMisc": 0.001, "TestNormalizations": 0.0030000000000000005, "TestOneArr": 0.45966666666666683, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1320000000000001, "TestOneArrAndShape": 0.0, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.379}, "torch_np/test_dtype": {"TestConvertDType": 0.3586666666666667}, "torch_np/test_function_base": {"TestAppend": 0.3413333333333333}, "torch_np/test_ndarray_methods": {"TestAmax": 0.0030000000000000005, "TestAmin": 0.0030000000000000005, "TestArgmax": 0.3980000000000003, "TestArgmaxArgminCommon": 0.5493333333333338, "TestArgmin": 0.43733333333333363, "TestContains": 0.001, "TestIndexing": 0.13366666666666668, "TestIter": 0.0023333333333333335, "TestNoExtraMethods": 0.006000000000000001, "TestNonzero": 0.051666666666666666, "TestRavel": 0.0030000000000000005, "TestReshape": 0.002, "TestTranspose": 0.010333333333333332}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.057000000000000016, "TestNEP50Table": 0.0003333333333333333}, "torch_np/test_random": {"TestChoice": 0.004, "TestNumpyGlobal": 0.002, "TestScalarReturn": 0.1236666666666667, "TestShuffle": 0.006666666666666667}, "torch_np/test_reductions": {"TestAll": 0.005, "TestAny": 0.005, "TestFlatnonzero": 0.36033333333333334, "TestGenericCumSumProd": 0.014000000000000004, "TestGenericReductions": 0.9936666666666669, "TestMean": 0.008, "TestSum": 0.07733333333333335}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.10866666666666669, "TestIsScalar": 0.023333333333333345}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.36633333333333357, "TestNdarrayDunderVsUfunc": 0.1113333333333334, "TestUfuncDtypeKwd": 0.002, "TestUnaryUfuncs": 0.3376666666666667}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.4040000000000001}}}, "macos-12-py3-arm64-mps": {"mps": {"test_metal": {"TestMetalRewritePass": 1.109}, "test_modules": {"TestModuleCPU": 429.87200000001627, "TestModuleMPS": 466.02700000001}, "test_mps": {"MPSLeakyReluTest": 0.35433333333333333, "MPSReluTest": 0.062333333333333345, "MatmulTest": 0.19433333333333333, "TestAdvancedIndexing": 18.313666666666666, "TestAvgPool": 0.08566666666666667, "TestCommonMPS": 15.81833333333333, "TestComplex": 3.8196666666666665, "TestConsistencyCPU": 2147.3359999999825, "TestConstantPadNd": 0.001, "TestConvolutionMPS": 12.533, "TestErrorInputsMPS": 20.543333333333337, "TestFallbackWarning": 6.784, "TestGatherScatter": 0.26, "TestLinalgMPS": 2.267333333333333, "TestLinalgMPSMPS": 43.451666666666675, "TestLogical": 1.6273333333333333, "TestMPS": 126.97766666666672, "TestMemoryLeak": 0.9146666666666667, "TestNLLLoss": 1.8556666666666668, "TestNNMPS": 2.842, "TestNoRegression": 0.13033333333333333, "TestPad": 1.5279999999999998, "TestPixelShuffle": 6.114999999999999, "TestRNNMPS": 5.208666666666667, "TestSmoothL1Loss": 0.19666666666666666, "TestTopK": 2.332666666666667, "TestViewOpsMPS": 1.9210000000000003}}}, "macos-12-py3-x86-64": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 0.002}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 1.2419999999999998}, "distributions/test_constraints": {"test_constraints": 0.20700000000000007}, "distributions/test_distributions": {"TestAgainstScipy": 1.9929999999999999, "TestConstraints": 0.21400000000000002, "TestDistributionShapes": 0.1850000000000001, "TestDistributions": 57.874999999999986, "TestFunctors": 0.013000000000000001, "TestJit": 11.678999999999998, "TestKL": 3.724999999999999, "TestLazyLogitsInitialization": 0.017, "TestNumericalStability": 0.09600000000000003, "TestRsample": 0.913, "TestValidation": 0.545}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.736}, "dynamo/test_after_aot": {"TestAfterAot": 7.626}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.827}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 16.142000000000003}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.4559999999999995}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.001, "NormalizeIRTests": 0.117, "TestCustomBackendAPI": 1.564, "TestExplainWithBackend": 10.84, "TestOptimizations": 1.917999999999999}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 12.844000000000001}, "dynamo/test_base_output": {"TestBaseOutput": 0.006}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 7.616}, "dynamo/test_compile": {"InPlaceCompilationTests": 7.306, "PublicTorchCompilerTests": 0.003}, "dynamo/test_comptime": {"ComptimeTests": 1.018}, "dynamo/test_config": {"ConfigTests": 1.0}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.854999999999999}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.489}, "dynamo/test_decorators": {"DecoratorTests": 1.2109999999999999}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 75.58300000000001, "DynamicShapesCtxManagerTests": 13.455000000000002, "DynamicShapesExportTests": 885.0769999999999, "DynamicShapesFuncTorchHigherOrderOpTests": 20.315, "DynamicShapesFunctionTests": 132.178, "DynamicShapesHigherOrderOpTests": 36.937, "DynamicShapesMiscTests": 148.54099999999997, "DynamicShapesNNModuleTests": 16.505000000000003, "DynamicShapesReproTests": 210.88399999999996, "DynamicShapesSubGraphTests": 23.541}, "dynamo/test_exc": {"ExcTests": 1.871}, "dynamo/test_export": {"ExportTests": 23.538}, "dynamo/test_export_mutations": {"MutationExportTests": 0.524}, "dynamo/test_frame_init": {"FrameInitTests": 0.472}, "dynamo/test_functions": {"DefaultsTests": 9.370999999999995, "FunctionTests": 9.396999999999995}, "dynamo/test_global": {"TestGlobals": 1.0499999999999998}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.07800000000000001, "FuncTorchHigherOrderOpTests": 2.12, "HigherOrderOpTests": 7.123999999999996}, "dynamo/test_hooks": {"HooksTests": 24.942}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 9.058}, "dynamo/test_interop": {"InteropTests": 1.109}, "dynamo/test_logging": {"LoggingTests": 10.969999999999992}, "dynamo/test_minifier": {"MinifierTests": 2.185999999999999}, "dynamo/test_misc": {"MiscTests": 58.80700000000007, "TestTracer": 0.091}, "dynamo/test_model_output": {"TestHFPretrained": 0.001, "TestModelOutput": 0.008}, "dynamo/test_modules": {"NNModuleTests": 4.344999999999999, "OptimizedModuleTest": 8.911999999999999}, "dynamo/test_nops": {"NopTests": 0.598}, "dynamo/test_optimizers": {"End2EndTests": 0.297, "OptimizerTests": 2.575}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 1.1059999999999999}, "dynamo/test_profiler": {"DynamoProfilerTests": 1.9019999999999997}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.2799999999999998}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.762}, "dynamo/test_recompiles": {"RecompileTests": 1.5729999999999997}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.011}, "dynamo/test_repros": {"ReproTests": 38.666}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 1.0099999999999996}, "dynamo/test_sources": {"SourceTests": 0.474}, "dynamo/test_subclasses": {"SubclassTests": 2.0639999999999987, "TestNestedTensor": 2.5300000000000002}, "dynamo/test_subgraphs": {"SubGraphTests": 2.7679999999999993}, "dynamo/test_trace_rules": {"TraceRuleTests": 1.21}, "dynamo/test_triton_kernels": {"KernelTests": 0.12000000000000009, "MutationTests": 0.001}, "dynamo/test_unspec": {"UnspecTests": 10.144999999999996}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 1.312}, "export/test_db": {"ExampleTests": 4.087}, "export/test_export": {"TestDynamismExpression": 1.1, "TestExport": 20.653}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.935, "NonStrictExportTestExport": 15.118000000000006}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 1.12}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 1.078}, "export/test_pass_infra": {"TestPassInfra": 0.8800000000000001}, "export/test_passes": {"TestPasses": 1.994}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.301, "RetraceExportTestExport": 25.071999999999996}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 1.092, "SerDesExportTestExport": 19.489000000000004}, "export/test_serialize": {"TestDeserialize": 4.411, "TestOpVersioning": 0.006, "TestSaveLoad": 0.3459999999999999, "TestSchemaVersioning": 0.035, "TestSerialize": 0.9099999999999999, "TestSerializeCustomClass": 0.001}, "export/test_unflatten": {"TestUnflatten": 1.945}, "export/test_upgrade": {"TestUpgrade": 0.649}, "export/test_verifier": {"TestVerifier": 0.9830000000000002}, "functorch/test_aotdispatch": {"TestAOTAutograd": 13.697, "TestAOTDispatch": 0.595, "TestAOTExport": 1.356, "TestAOTModuleSimplified": 0.766, "TestEagerFusionModuleInfoCPU": 1013.711, "TestEagerFusionOpInfoCPU": 2124.4190000000017, "TestPartitioning": 1.5140000000000002, "TestPythonKeyCPU": 0.49}, "functorch/test_control_flow": {"TestControlFlow": 0.906, "TestControlFlowTraced": 84.72199999999997}, "functorch/test_dims": {"TestMin": 13.039000000000005, "TestMinFunctorchOnly": 11.078999999999999}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.22500000000000003, "TestAutogradFunctionVmapAPICPU": 0.032, "TestCompileTransformsCPU": 10.121, "TestComposabilityCPU": 2.3970000000000002, "TestExamplesCorrectnessCPU": 7.526000000000001, "TestFunctionalizeCPU": 0.15000000000000005, "TestGradTransformCPU": 0.6660000000000001, "TestHelpersCPU": 0.013000000000000001, "TestHessianCPU": 0.052000000000000005, "TestHigherOrderOperatorInteractionCPU": 0.033, "TestJacCPU": 0.7200000000000003, "TestJvpCPU": 0.07100000000000002, "TestLinearizeCPU": 0.163, "TestMakeFunctional": 0.31600000000000006, "TestSliceArgnums": 0.022000000000000006, "TestVmapJvpInplaceViewCPU": 0.02, "TestVmapOfGradCPU": 0.39899999999999997}, "functorch/test_logging": {"TestAOTLogging": 0.501}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.42400000000000004, "RandomOpTestCase": 0.174, "ReduceTestCase": 0.13, "TestMemoryEfficientOpAuthoring": 0.003}, "functorch/test_minifier": {"TestMinifier": 0.7130000000000002}, "functorch/test_ops": {"TestOperatorsCPU": 4733.245999999999}, "functorch/test_parsing": {"TestAnonymousAxis": 1.107, "TestParsedExpression": 0.006, "TestParsingUtils": 0.008, "TestValidateRearrangeExpressions": 0.008}, "functorch/test_rearrange": {"TestRearrange": 0.8170000000000001}, "functorch/test_vmap": {"TestRandomnessCPU": 2.9589999999999983, "TestTransformFailureCPU": 0.002, "TestVmapAPI": 1.9819999999999989, "TestVmapBatchedGradientCPU": 0.21400000000000002, "TestVmapDeviceTypeCPU": 0.28600000000000003, "TestVmapNestedTensorCPU": 0.077, "TestVmapOperators": 4.748999999999997, "TestVmapOperatorsOpInfoCPU": 784.7559999999993}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 4.550999999999731}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 3.5389999999999997}, "inductor/test_binary_folding": {"FreezingCpuTests": 24.897000000000002}, "inductor/test_codecache": {"TestFxGraphCache": 19.210000000000004, "TestFxGraphCacheHashing": 1.184, "test_codecache": 0.001}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.442}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 109.92600000000026, "TestCompiledAutograd": 18.886}, "inductor/test_compiled_optimizers": {"CompiledOptimizerTests": 212.36500000000018}, "inductor/test_config": {"TestInductorConfig": 4.482999999999998}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.003}, "inductor/test_debug_trace": {"TestDebugTrace": 2.567}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.002}, "inductor/test_foreach": {"ForeachTests": 11.557999999999915}, "inductor/test_fx_fusion": {"TestFxFusion": 0.49000000000000005}, "inductor/test_group_batch_fusion": {"TestGroupBatchFusion": 0.002, "TestPostGradBatchLinearFusion": 0.001}, "inductor/test_indexing": {"ExprPrinterTests": 0.06200000000000001, "TestIndexingSimplification": 0.902}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 20.400000000000002}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.002}, "inductor/test_mmdecomp": {"TestDecompCPU": 35.21}, "inductor/test_profiler": {"DynamoProfilerTests": 0.005}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 5.771999999999999}, "inductor/test_torchinductor": {"CpuTests": 783.7859999999996, "SweepInputsCpuTest": 78.38, "TestFull": 8.539}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 176.6250000000001}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 781.7459999999985, "TestInductorDynamicCPU": 13.533}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 3541.342999999999}, "lazy/test_debug_util": {"DebugUtilTest": 1.336}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 1.286}, "lazy/test_generator": {"LazyGeneratorTest": 1.163}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 1.557}, "lazy/test_step_closures": {"ClosuresTest": 3.195}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.336, "TestLazyOpInfoCPU": 9.95699999999997, "TestLazyTensor": 0.6609999999999999}, "nn/test_convolution": {"TestConvolutionNN": 12.866, "TestConvolutionNNDeviceTypeCPU": 10.037999999999967}, "nn/test_dropout": {"TestDropoutNN": 0.69, "TestDropoutNNDeviceTypeCPU": 0.253}, "nn/test_embedding": {"TestEmbeddingNN": 0.7430000000000001, "TestEmbeddingNNDeviceTypeCPU": 11.709000000000001}, "nn/test_init": {"TestNNInit": 5.921}, "nn/test_lazy_modules": {"TestLazyModules": 1.3469999999999986}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.028999999999999998, "TestModuleHookNN": 0.131, "TestModuleHooks": 0.8940000000000001, "TestStateDictHooks": 0.030999999999999996}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 8.324000000000002, "TestMultiheadAttentionNNDeviceTypeCPU": 0.027000000000000003}, "nn/test_packed_sequence": {"PackedSequenceTest": 1.4149999999999994}, "nn/test_parametrization": {"TestNNParametrization": 1.3679999999999999, "TestNNParametrizationDeviceCPU": 0.01}, "nn/test_pooling": {"TestAvgPool": 1.016, "TestPoolingNN": 0.5910000000000001, "TestPoolingNNDeviceTypeCPU": 45.16500000000001}, "nn/test_pruning": {"TestPruningNN": 0.8670000000000001}, "profiler/test_memory_profiler": {"TestDataFlow": 0.781, "TestIdentifyGradients": 0.266, "TestMemoryProfiler": 0.772, "TestMemoryProfilerE2E": 2.9060000000000006}, "profiler/test_profiler": {"TestExecutionTrace": 0.066, "TestExperimentalUtils": 9.145, "TestProfiler": 3.038, "TestProfilerCUDA": 0.001, "TestProfilerITT": 0.441, "TestRecordFunction": 0.038, "TestTorchTidyProfiler": 2.673}, "profiler/test_profiler_tree": {"TestProfilerTree": 1.2719999999999994}, "test_ao_sparsity": {"TestActivationSparsifier": 0.07, "TestBaseDataScheduler": 0.029, "TestBaseDataSparsifier": 0.069, "TestBaseSparsifier": 0.023, "TestBaseStructuredSparsifier": 1.6189999999999998, "TestComposability": 1.567, "TestCubicScheduler": 0.006, "TestFPGMPruner": 0.019999999999999997, "TestFakeSparsity": 0.07800000000000001, "TestFxComposability": 1.339, "TestNearlyDiagonalSparsifier": 0.662, "TestNormDataSparsifiers": 0.887, "TestQuantizationUtils": 0.023, "TestQuantizedSparseKernels": 0.304, "TestQuantizedSparseLayers": 0.309, "TestSaliencyPruner": 0.028, "TestScheduler": 0.012, "TestSparsityUtilFunctions": 0.036000000000000004, "TestWeightNormSparsifier": 0.448}, "test_autocast": {"TestAutocastCPU": 1.127, "TestAutocastGPU": 0.001, "TestTorchAutocast": 0.004}, "test_autograd": {"TestAllowMutationOnSaved": 0.05500000000000001, "TestAutograd": 26.57899999999995, "TestAutogradComplex": 0.018000000000000002, "TestAutogradDeviceTypeCPU": 0.3950000000000002, "TestAutogradForwardMode": 0.11700000000000006, "TestAutogradForwardModeBatchedGrad": 0.03, "TestAutogradFunctional": 13.826999999999996, "TestAutogradInferenceMode": 0.10900000000000001, "TestAutogradLogging": 0.017, "TestAutogradMultipleDispatchCPU": 0.034, "TestMultithreadAutograd": 0.327, "TestNestedCheckpoint": 0.628}, "test_autograd_fallback": {"TestAutogradFallback": 1.1879999999999984}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 182.5970000000003}, "test_bundled_inputs": {"TestBundledInputs": 2.4619999999999993}, "test_comparison_utils": {"TestComparisonUtils": 1.0729999999999997}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.7670000000000001}, "test_content_store": {"TestContentStoreCPU": 6.977}, "test_cpp_api_parity": {"TestCppApiParity": 5.110999999999999}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.71, "TestORTTensor": 0.022, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.004, "TestTorchLibrary": 0.001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.712, "TestORTTensor": 0.024, "TestPybindTypeCasters": 0.002, "TestRNGExtension": 0.004, "TestTorchLibrary": 0.001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 217.659}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 25.403}, "test_custom_backend": {"TestCustomBackend": 0.247}, "test_custom_ops": {"MiniOpTest": 0.8520000000000003, "MiniOpTestOther": 0.06100000000000001, "TestCustomOp": 0.7690000000000002, "TestCustomOpTestingCPU": 1.939, "TestCustomOperators": 0.40900000000000003, "TestGenerateOpcheckTests": 0.137}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.002, "TestConcatDataset": 0.014000000000000002, "TestConvAfterFork": 3.517, "TestCustomPinFn": 0.002, "TestDataLoader": 615.739, "TestDataLoaderDeviceTypeCPU": 18.018, "TestDataLoaderPersistentWorkers": 581.0029999999999, "TestDatasetRandomSplit": 0.676, "TestDictDataLoader": 8.672, "TestIndividualWorkerQueue": 0.001, "TestNamedTupleDataLoader": 0.006, "TestSetAffinity": 0.001, "TestStackDataset": 0.059000000000000004, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.029}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.007, "TestDataChunk": 0.5, "TestDataFramesPipes": 0.002, "TestFunctionalIterDataPipe": 3.4069999999999987, "TestFunctionalMapDataPipe": 0.034, "TestGraph": 0.015, "TestIterDataPipeCountSampleYielded": 0.01, "TestIterDataPipeGraphFastForward": 0.037000000000000005, "TestIterDataPipeSingletonConstraint": 0.019000000000000003, "TestIterableDataPipeBasic": 0.03899999999999999, "TestSerialization": 0.001, "TestSharding": 25.135, "TestStreamWrapper": 0.278, "TestTyping": 0.005}, "test_decomp": {"DecompOneOffTestsCPU": 0.17400000000000002, "HasDecompTest": 0.388, "TestDecompCPU": 6150.6549999999825}, "test_deploy": {"TestFreezer": 1.028}, "test_dispatch": {"TestDispatch": 42.580000000000005, "TestPythonDispatcher": 0.023}, "test_dlpack": {"TestTorchDlPackCPU": 0.7880000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 3.765, "TestFloorDiv": 0.167, "TestPySymInt": 1.2699999999999996, "TestSymNumberMagicMethods": 1.2689999999999988}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 16.988999999999987, "TestExpandedWeightHelperFunctionCPU": 0.728, "TestExpandedWeightModuleCPU": 6.602000000000001}, "test_fake_tensor": {"FakeTensorConstHandling": 0.07, "FakeTensorConverterTest": 0.030000000000000002, "FakeTensorOpInfoTestCPU": 0.155, "FakeTensorOperatorInvariants": 0.401, "FakeTensorPropTest": 0.049, "FakeTensorTest": 0.3300000000000001}, "test_flop_counter": {"TestFlopCounter": 0.8190000000000001}, "test_foreach": {"TestForeachCPU": 294.1369999999999}, "test_function_schema": {"TestFunctionSchema": 1.6299999999999997}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 60.281000000000006}, "test_functional_optim": {"TestFunctionalOptimParity": 0.003}, "test_functionalization": {"TestCrossRefFunctionalization": 3.636999999999999, "TestFunctionalization": 4.966}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.017}, "test_futures": {"TestFuture": 1.501}, "test_fx": {"AnnotationsTest": 0.018000000000000002, "TestCSEPass": 0.3430000000000001, "TestCommonPass": 0.086, "TestConstFold": 0.29700000000000004, "TestConstParamShapeInControlFlow": 0.048, "TestDCE": 0.036, "TestFX": 7.800999999999993, "TestFXAPIBackwardCompatibility": 0.033, "TestFunctionalTracing": 0.4260000000000003, "TestMatcher": 0.8190000000000001, "TestOperatorSignaturesCPU": 4.823999999999994, "TestPassManager": 0.032, "TestSourceMatcher": 1.406, "TestSubgraphRewriter": 0.5010000000000002, "TypeCheckerTest": 0.2800000000000001}, "test_fx_experimental": {"TestFXExperimental": 2.193999999999999, "TestNormalizeOperatorsCPU": 49.469, "TestTranslationValidation": 0.182}, "test_fx_passes": {"TestFXGraphPasses": 1.7749999999999981, "TestFXMatcherUtils": 0.11500000000000002}, "test_fx_reinplace_pass": {"TestReinplacePass": 1.5659999999999996}, "test_import_stats": {"TestImportTime": 5.752}, "test_indexing": {"NumpyTestsCPU": 0.23400000000000004, "TestIndexingCPU": 12.164000000000012}, "test_itt": {"TestItt": 1.086}, "test_jit": {"TestAliasAnalysis": 0.025, "TestAsync": 0.40299999999999997, "TestAtenPow": 0.04, "TestAutodiffJit": 0.06, "TestAutodiffSubgraphSlicing": 0.25300000000000006, "TestAwait": 0.15600000000000003, "TestBackends": 0.003, "TestBackendsWithCompiler": 0.002, "TestBatchMM": 0.081, "TestBuiltins": 0.063, "TestClassType": 0.7780000000000004, "TestComplex": 0.6730000000000002, "TestCustomOperators": 0.03500000000000001, "TestDCE": 0.018000000000000002, "TestDataParallel": 0.003, "TestDataclasses": 5.715, "TestDeviceAnalysis": 0.111, "TestDict": 0.3880000000000001, "TestDtypeAnalysis": 0.254, "TestDtypeCustomRulesCPU": 3.5979999999999928, "TestEnum": 0.15700000000000003, "TestFreezing": 1.0300000000000007, "TestFrontend": 0.056, "TestFrozenOptimizations": 9.247000000000003, "TestFunctionalBlocks": 0.006, "TestFunctionalToInplaceActivation": 0.6819999999999999, "TestGenerator": 0.063, "TestGetDefaultAttr": 0.007, "TestGraphRewritePasses": 0.033, "TestHash": 0.071, "TestHooks": 0.6840000000000002, "TestIgnorableArgs": 0.01, "TestIgnoreContextManager": 0.002, "TestInplaceToFunctionalActivation": 0.049, "TestIsinstance": 0.19200000000000006, "TestJit": 10.386999999999992, "TestJitGeneratedModule": 10.75799999999998, "TestJitProfiler": 0.001, "TestJitUtils": 0.020000000000000004, "TestList": 1.2110000000000005, "TestLogging": 0.041, "TestMKLDNNReinplacing": 0.157, "TestMisc": 0.17900000000000005, "TestMixTracingScripting": 0.9640000000000002, "TestModels": 2.0479999999999996, "TestModuleAPIs": 0.146, "TestModuleContainers": 1.159, "TestModuleInterface": 0.3780000000000001, "TestModules": 0.011, "TestNamedTuple": 0.082, "TestNnapiBackend": 0.003, "TestOpDecompositions": 0.015, "TestOptimizeForMobilePreserveDebugInfo": 0.17800000000000002, "TestParametrization": 0.2, "TestPeephole": 0.3960000000000002, "TestProducerVersion": 0.002, "TestProfiler": 0.115, "TestPythonBindings": 0.031000000000000003, "TestPythonBuiltinOP": 0.31800000000000006, "TestPythonIr": 0.005, "TestRecursiveScript": 0.6100000000000002, "TestRemoveMutation": 0.11100000000000002, "TestSaveLoad": 0.3950000000000001, "TestSaveLoadFlatbuffer": 0.25300000000000006, "TestSaveLoadForOpVersion": 6.460999999999999, "TestScript": 18.99600000000002, "TestScriptDict": 0.024, "TestScriptList": 0.06600000000000003, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.15099999999999997, "TestScriptProfile": 0.756, "TestSlice": 0.14800000000000008, "TestSparse": 0.051000000000000004, "TestStringFormatting": 0.15500000000000005, "TestSymbolicShapeAnalysis": 1.4659999999999995, "TestTensorBuiltins": 0.08399999999999999, "TestTensorCreationOps": 0.042, "TestTensorMethods": 0.009000000000000001, "TestTorchbind": 0.02900000000000002, "TestTracer": 2.711999999999996, "TestTypeSharing": 0.4420000000000001, "TestTypesAndAnnotation": 0.139, "TestTyping": 0.3510000000000002, "TestUnion": 0.4390000000000002, "TestUnsupportedOps": 0.026, "TestUpgraders": 0.068, "TestWarn": 0.044000000000000004, "TestWith": 0.269}, "test_jit_autocast": {"TestAutocast": 0.17000000000000004, "TestJitTraceAutocast": 46.95099999999999}, "test_jit_disabled": {"TestJitDisabled": 1.263}, "test_jit_fuser_te": {"TestFuserCommon": 0.096, "TestLoopnestRandomizationCPU": 0.001, "TestNNCOpInfoCPU": 25.344000000001085, "TestTEFuserDynamic": 170.60300000000004, "TestTEFuserStatic": 164.21600000000004}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCPU": 0.004, "TestModel": 0.011000000000000003, "TestOpCPU": 0.004}, "test_legacy_vmap": {"TestVmapAPI": 2.5929999999999978, "TestVmapBatchedGradientCPU": 0.12200000000000004, "TestVmapOperators": 1.8529999999999995}, "test_license": {"TestLicense": 1.091}, "test_linalg": {"TestLinalgCPU": 111.19899999999988}, "test_logging": {"LoggingTest": 4.122}, "test_masked": {"TestMaskedCPU": 44.18200000000004}, "test_maskedtensor": {"TestBasicsCPU": 0.145, "TestBinary": 0.4180000000000002, "TestOperatorsCPU": 7.558, "TestReductions": 0.09400000000000003, "TestUnary": 1.184999999999995}, "test_meta": {"TestMetaCPU": 2856.348000000317, "TestMetaConverter": 2.0939999999999994}, "test_mkl_verbose": {"TestMKLVerbose": 6.098}, "test_mkldnn": {"TestMkldnnCPU": 56.84}, "test_mkldnn_fusion": {"TestMkldnnFusion": 243.679}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 5.823}, "test_mobile_optimizer": {"TestOptimizer": 2.4779999999999998}, "test_model_dump": {"TestModelDump": 1.4189999999999998}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.001}, "test_module_init": {"TestModuleInitCPU": 2.9249999999999896}, "test_modules": {"TestModuleCPU": 546.6559999999972}, "test_monitor": {"TestMonitor": 1.107, "TestMonitorTensorboard": 0.322}, "test_multiprocessing": {"TestMultiprocessing": 217.25}, "test_multiprocessing_spawn": {"ErrorTest": 0.004, "ForkTest": 0.402, "SpawnTest": 18.087999999999997}, "test_namedtensor": {"TestNamedTensor": 2.5339999999999976}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 3.252}, "test_native_functions": {"TestNativeFunctions": 1.2549999999999997}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.7490000000000002}, "test_nestedtensor": {"TestNestedTensor": 0.40500000000000014, "TestNestedTensorAutogradCPU": 1.1969999999999998, "TestNestedTensorDeviceTypeCPU": 2.9269999999999983, "TestNestedTensorSubclassCPU": 0.4820000000000003}, "test_nn": {"TestAddRelu": 0.003, "TestConstantPadNd": 0.003, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.431, "TestFusionUtils": 0.004, "TestNN": 36.164000000000044, "TestNNDeviceTypeCPU": 107.90400000000064}, "test_numba_integration": {"TestNumbaIntegration": 0.48}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.6290000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 7.791}, "test_ops": {"TestCommonCPU": 3165.772000000034, "TestCompositeComplianceCPU": 1140.979999999999, "TestFakeTensorCPU": 256.61800000000153, "TestMathBitsCPU": 61.63099999999996, "TestRefsOpsInfoCPU": 1.1820000000000008, "TestSelfKwarg": 0.599, "TestTagsCPU": 12.703999999999972}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 457.7979999999839}, "test_ops_gradients": {"TestBwdGradientsCPU": 1457.2960000000096}, "test_ops_jit": {"TestJitCPU": 1989.9519999999982}, "test_optim": {"TestDifferentiableOptimizer": 0.271, "TestLRScheduler": 0.9730000000000004, "TestOptim": 134.642, "TestOptimRenewedCPU": 2.865999999999992, "TestSWAUtils": 0.252}, "test_out_dtype_op": {"TestOutDtypeOp": 0.6950000000000002}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.002, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.004, "TestGradCheckOverride": 0.163, "TestGradNewOnesOverride": 0.002, "TestIndexing": 0.01, "TestIterator": 0.002, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.004, "TestResolveName": 0.194, "TestTorchFunctionMode": 0.04800000000000002, "TestTorchFunctionOverride": 3.949999999999793, "TestTorchFunctionWarning": 0.012, "TestWrapTorchFunction": 0.002}, "test_package": {"DirectoryReaderTest": 0.098, "ModelTest": 0.003, "TestAnalyze": 0.004, "TestDependencyAPI": 0.06300000000000001, "TestDependencyHooks": 0.011000000000000001, "TestDiGraph": 0.024000000000000007, "TestGlobGroup": 0.02800000000000001, "TestImporter": 0.015, "TestLoadBCPackages": 0.07400000000000001, "TestMangling": 0.022000000000000002, "TestMisc": 0.061000000000000006, "TestPackageFX": 0.07500000000000001, "TestPackageScript": 0.49200000000000016, "TestRepackage": 0.013, "TestResources": 1.1849999999999998, "TestSaveLoad": 0.046000000000000006}, "test_per_overload_api": {"TestPerOverloadAPI": 0.89}, "test_prims": {"TestDecompCPU": 0.29100000000000004, "TestPrimsBasic": 0.5670000000000001, "TestPrimsCPU": 0.11000000000000001, "TestRefsCPU": 0.014}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.14600000000000002, "TestGenericProxyTensorFake": 0.6220000000000002, "TestGenericProxyTensorReal": 1.7409999999999992, "TestGenericProxyTensorSymbolic": 0.9300000000000002, "TestProxyTensorOpInfoCPU": 1079.2970000000003, "TestRealProxyTensor": 0.026, "TestSymbolicTracing": 2.3169999999999993}, "test_pruning_op": {"PruningOpTest": 1.4629999999999999}, "test_public_bindings": {"TestPublicBindings": 7.451}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006, "TestPythonDispatch": 0.2640000000000001, "TestPythonDispatcher": 0.008, "TestPythonRegistration": 0.4710000000000001, "TestWrapperSubclassAliasingCPU": 0.20400000000000007}, "test_pytree": {"TestCxxPytree": 0.034999999999999996, "TestGenericPytree": 1.2849999999999977, "TestPythonPytree": 0.050000000000000024}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.018000000000000002, "TestAOMigrationNNQuantized": 0.03800000000000001, "TestAOMigrationQuantization": 0.02, "TestAOMigrationQuantizationFx": 0.027, "TestBackendConfig": 0.05200000000000002, "TestBiasCorrectionEager": 0.004, "TestBits": 0.006, "TestBitsCPU": 0.046000000000000006, "TestComparatorOps": 1.7120000000000002, "TestDeprecatedJitQuantized": 0.6, "TestDistributed": 0.024000000000000004, "TestDuplicateDQPass": 4.623, "TestDynamicQuantizedModule": 4.553999999999999, "TestDynamicQuantizedOps": 1.67, "TestEqualizeEager": 0.125, "TestEqualizeFx": 1.881, "TestFXGraphMatcher": 0.19100000000000003, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 4.7059999999999995, "TestFXNumericSuiteCoreAPIsModels": 0.026000000000000002, "TestFXNumericSuiteNShadows": 28.049999999999997, "TestFakeQuantize": 0.38, "TestFakeQuantizeOps": 2.8139999999999987, "TestFloat8DtypeCPU": 0.257, "TestFloat8DtypeCPUOnlyCPU": 0.326, "TestFuseEager": 0.010000000000000002, "TestFuseFx": 2.508, "TestFusedObsFakeQuant": 0.108, "TestFusedObsFakeQuantModule": 0.184, "TestFusionPasses": 0.027, "TestFxDetectInputWeightEqualization": 0.007, "TestFxDetectOutliers": 0.009000000000000001, "TestFxModelReportClass": 0.013, "TestFxModelReportDetectDynamicStatic": 0.002, "TestFxModelReportDetector": 0.301, "TestFxModelReportObserver": 0.252, "TestFxModelReportVisualizer": 0.008, "TestGenerateNumericDebugHandle": 0.067, "TestGraphUtils": 1.185, "TestHistogramObserver": 60.144000000000005, "TestMetaDataPorting": 9.888, "TestModelNumericsEager": 0.31, "TestNumericSuiteEager": 2.1069999999999998, "TestObserver": 5.140000000000001, "TestPT2ERepresentation": 47.378, "TestPadding": 31.501, "TestQNNPackOps": 0.012000000000000004, "TestQuantizationDocs": 0.374, "TestQuantizeDynamicJitOps": 0.516, "TestQuantizeDynamicJitPasses": 1.8530000000000002, "TestQuantizeEagerOps": 2.022, "TestQuantizeEagerPTQDynamic": 0.013000000000000005, "TestQuantizeEagerPTQStatic": 5.212, "TestQuantizeEagerQAT": 1.8379999999999999, "TestQuantizeEagerQATNumerics": 2.464999999999999, "TestQuantizeFx": 0.1550000000000001, "TestQuantizeFxModels": 1.0429999999999997, "TestQuantizeFxOps": 0.06400000000000004, "TestQuantizeJit": 4.148, "TestQuantizeJitOps": 14.45600000000001, "TestQuantizeJitPasses": 5.068999999999999, "TestQuantizePT2E": 34.587999999999994, "TestQuantizePT2EQAT": 144.972, "TestQuantizePT2EQATModels": 0.002, "TestQuantizePT2EQAT_ConvBn1d": 203.95100000000002, "TestQuantizePT2EQAT_ConvBn2d": 219.37900000000002, "TestQuantizePT2EX86Inductor": 0.04300000000000002, "TestQuantizedConv": 11.985000000000001, "TestQuantizedEmbeddingOps": 0.009000000000000001, "TestQuantizedFunctionalOps": 0.7939999999999999, "TestQuantizedLinear": 6.338, "TestQuantizedOps": 73.83300000000001, "TestQuantizedTensor": 2.7359999999999998, "TestRecordHistogramObserver": 0.029, "TestReferenceQuantizedModule": 0.055, "TestSerialization": 0.22199999999999998, "TestStaticQuantizedModule": 31.302999999999994, "TestSubgraphRewriter": 0.9130000000000004, "TestUtils": 0.024, "TestXNNPACKQuantizer": 63.01499999999999, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCPU": 254.11799999999633}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 4.979999999999996}, "test_schema_check": {"TestSchemaCheck": 1.7630000000000003, "TestSchemaCheckModeOpInfoCPU": 840.9879999999957}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.3559999999999992}, "test_serialization": {"TestBothSerializationCPU": 0.172, "TestOldSerialization": 37.103000000000016, "TestSerialization": 9.412999999999993, "TestSubclassSerialization": 0.016}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.775}, "test_shape_ops": {"TestShapeOpsCPU": 2.879999999999998}, "test_show_pickle": {"TestShowPickle": 1.092}, "test_sort_and_select": {"TestSortAndSelectCPU": 4.358999999999993}, "test_sparse": {"TestSparseAnyCPU": 700.9889999999989, "TestSparseCPU": 26.923000000000002, "TestSparseLegacyAndDeprecation": 0.442, "TestSparseMaskedReductionsCPU": 0.8900000000000005, "TestSparseMeta": 0.004, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 6.970999999999848}, "test_sparse_csr": {"TestSparseCSRCPU": 209.84699999999827, "TestSparseCSRSampler": 0.793, "TestSparseCompressedCPU": 201.10899999999975, "TestSparseCompressedTritonKernelsCPU": 0.010000000000000002}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.002}, "test_spectral_ops": {"TestFFTCPU": 10.674999999999994, "TestFFTDocExamplesCPU": 0.07700000000000003}, "test_stateless": {"TestPythonOptimizeMode": 5.641, "TestStatelessDeprecation": 2.3850000000000002, "TestStatelessFunctionalAPI": 1.1619999999999977}, "test_subclass": {"TestSubclass": 1.3949999999999965}, "test_sympy_utils": {"TestSingletonInt": 0.007, "TestSympyInterp": 1.1449999999999996, "TestSympySolve": 0.23600000000000004, "TestValueRanges": 27.114999999999995}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.5470000000000004, "TestBufferProtocolCPU": 0.5650000000000002, "TestLikeTensorCreationCPU": 0.012, "TestRandomTensorCreationCPU": 2.769, "TestTensorCreationCPU": 35.368999999999986}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.028, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.008, "TestTensorBoardPyTorchNumpy": 1.253, "TestTensorBoardPytorchGraph": 0.37500000000000006, "TestTensorBoardSummary": 0.05400000000000002, "TestTensorBoardSummaryWriter": 0.012, "TestTensorBoardUtils": 0.215, "TestTensorBoardWriter": 0.52, "TestTensorProtoSummary": 0.014}, "test_tensorexpr": {"TestTensorExprFuser": 32.827999999999996}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.012, "TestTensorExprPyBind": 1.2469999999999988}, "test_testing": {"TestAssertClose": 0.528, "TestAssertCloseContainer": 0.007, "TestAssertCloseErrorMessage": 0.07, "TestAssertCloseQuantized": 0.013999999999999999, "TestAssertCloseSparseBSC": 0.022, "TestAssertCloseSparseBSR": 0.020000000000000004, "TestAssertCloseSparseCOO": 0.023, "TestAssertCloseSparseCSC": 0.020000000000000004, "TestAssertCloseSparseCSR": 0.020000000000000004, "TestFrameworkUtils": 13.025, "TestImports": 13.892, "TestMakeTensorCPU": 1.4830000000000005, "TestOpInfoSampleFunctionsCPU": 7.917999999999866, "TestOpInfos": 0.006, "TestTestParametrization": 0.034000000000000016, "TestTestParametrizationDeviceTypeCPU": 4.566999999999999, "TestTestingCPU": 1.1930000000000003}, "test_torch": {"TestBasicVitalSigns": 0.008, "TestTorch": 5.213999999999979, "TestTorchDeviceTypeCPU": 13.884000000000055, "TestVitalSignsCudaCPU": 0.002}, "test_transformers": {"TestAttnMasksCPU": 23.918, "TestSDPACPU": 34.751, "TestSDPAFailureModesCPU": 0.07, "TestTransformersCPU": 15.681999999999997}, "test_type_hints": {"TestTypeHints": 0.62}, "test_type_info": {"TestDTypeInfo": 1.037}, "test_type_promotion": {"TestTypePromotionCPU": 16.591999999999967}, "test_typing": {"TestTyping": 0.004}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 371.9569999999135}, "test_utils": {"TestAssert": 0.09, "TestBottleneck": 26.201999999999998, "TestCheckpoint": 0.5, "TestCollectEnv": 4.833, "TestCppExtensionUtils": 0.14, "TestDataLoaderUtils": 51.956, "TestDeviceUtilsCPU": 56.11400000000128, "TestExtensionUtils": 0.013999999999999999, "TestHipify": 0.002, "TestONNXUtils": 0.007, "TestRenderUtils": 0.03, "TestStandaloneCPPJIT": 19.554, "TestTraceback": 0.016}, "test_view_ops": {"TestOldViewOpsCPU": 14.973000000000006, "TestViewOpsCPU": 8.197000000000022, "TestViewOpsLAZY": 0.6950000000000004}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.014000000000000005, "WeakKeyDictionaryTestCase": 0.045, "WeakTest": 6.0489999999999995}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.002, "TestXNNPACKOps": 2.9579999999999997, "TestXNNPACKRewritePass": 0.562, "TestXNNPACKSerDes": 2.7449999999999997}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.002}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.41300000000000003, "TestClassGetItem": 0.003, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.003, "TestMisc": 0.005, "TestPickling": 0.15400000000000003, "TestPromotion": 0.003}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 20.054, "TestEinsumPath": 0.001, "TestMisc": 0.007}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.637, "TestHalf": 0.001, "TestIinfo": 0.502, "TestMisc": 0.005, "TestPythonFloat": 0.001, "TestRepr": 0.004, "TestSingle": 0.001}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.005, "TestBooleanIndexing": 0.063, "TestBroadcastedAssignments": 0.123, "TestFancyIndexingCast": 0.005, "TestFloatNonIntegerArgument": 0.013000000000000001, "TestIndexing": 0.7390000000000002, "TestMultiIndexingAutomated": 0.013, "TestMultipleEllipsisError": 0.002, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.04400000000000001, "TestArgmax": 1.0260000000000005, "TestArgmaxArgminCommon": 0.07000000000000003, "TestArgmin": 1.1900000000000002, "TestArrayAttributeDeletion": 0.008, "TestArrayConstruction": 0.04200000000000001, "TestArrayCreationCopyArgument": 0.002, "TestArrayInterface": 0.069, "TestAssignment": 0.034, "TestAttributes": 0.021000000000000005, "TestBinop": 0.019, "TestBool": 23.769000000000002, "TestCequenceMethods": 0.002, "TestChoose": 0.019, "TestClip": 0.007, "TestCompress": 0.005, "TestConversion": 0.034, "TestCreation": 0.003, "TestDelMisc": 0.002, "TestDot": 0.08100000000000003, "TestDtypedescr": 0.002, "TestFancyIndexing": 0.028, "TestFlag": 0.013000000000000003, "TestFormat": 0.005, "TestFromBuffer": 0.019000000000000003, "TestHash": 0.347, "TestHashing": 0.004, "TestIO": 0.007, "TestInner": 0.202, "TestLexsort": 0.019000000000000003, "TestMatmul": 1.3929999999999993, "TestMatmulOperator": 1.2069999999999996, "TestMethods": 1.56, "TestMinMax": 0.005, "TestMinScalarType": 0.005, "TestNewaxis": 0.004, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.01, "TestRepeat": 0.012, "TestResize": 0.051000000000000004, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.041, "TestSizeOf": 0.022, "TestSortFloatMisc": 0.141, "TestStats": 0.25, "TestSubscripting": 0.002, "TestTake": 0.063, "TestVdot": 0.03900000000000001, "TestViewDtype": 0.013000000000000001, "TestWarnings": 0.002, "TestWhere": 0.315, "TestWritebackIfCopy": 0.023999999999999997}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.025, "TestArgwhere": 0.037, "TestArrayComparisons": 0.032, "TestBaseRepr": 0.007, "TestBinaryRepr": 0.009000000000000001, "TestBoolArray": 2.11, "TestBoolCmp": 0.245, "TestBoolScalar": 0.006, "TestBroadcast": 0.009000000000000001, "TestClip": 0.1920000000000001, "TestConvolve": 0.023000000000000003, "TestCorrelate": 0.199, "TestCreationFuncs": 1.524, "TestCross": 0.07100000000000001, "TestDtypePositional": 0.002, "TestFloatExceptions": 0.009000000000000001, "TestFromiter": 0.0, "TestIndex": 0.007, "TestIndices": 0.051000000000000004, "TestIsclose": 0.113, "TestIsscalar": 0.002, "TestLikeFuncs": 0.002, "TestMoveaxis": 0.02500000000000001, "TestNonarrayArgs": 0.22000000000000006, "TestNonzeroAndCountNonzero": 0.35100000000000003, "TestOuterMisc": 0.007, "TestRequire": 0.007, "TestResize": 0.401, "TestRoll": 0.04200000000000001, "TestRollaxis": 0.005, "TestSeterr": 0.007, "TestStdVar": 0.032, "TestStdVarComplex": 0.014, "TestStringFunction": 0.002, "TestTensordot": 0.02, "TestTypes": 0.019000000000000003}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.79, "TestDocStrings": 0.0, "TestIsSubDType": 0.006, "TestScalarTypeNames": 0.012000000000000004}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.1210000000000001, "TestFromInt": 0.01, "TestFromString": 1.218}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.007, "TestBitCount": 0.004, "TestClassGetItem": 0.003, "TestClassGetitemMisc": 1.081, "TestIsInteger": 0.004}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.001}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.14400000000000002, "TestBaseMath": 13.479, "TestBitShifts": 0.128, "TestComplexDivision": 0.08800000000000001, "TestConversion": 0.084, "TestHash": 0.001, "TestModulus": 1.46, "TestMultiply": 0.0, "TestNegative": 0.035, "TestPower": 0.18400000000000002, "TestRepr": 0.002, "TestScalarOpsMisc": 0.235, "TestScalarSubclassingMisc": 0.07900000000000006, "TestSubtract": 0.034, "TestTypes": 1.101}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 1.0859999999999999, "TestAtleast2d": 0.020000000000000004, "TestAtleast3d": 0.017, "TestBlock": 0.03800000000000002, "TestConcatenate": 0.3280000000000001, "TestHstack": 0.022000000000000006, "TestStackMisc": 0.02100000000000001, "TestVstack": 0.024000000000000007}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.01, "TestFFTShift": 6.053999999999999, "TestIRFFTN": 0.108, "TestRFFTFreq": 0.009}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 4.499999999999999, "TestFFTShift": 1.165, "TestFFTThreadSafe": 1.1380000000000001}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 1.1359999999999997}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.069, "TestUnique": 0.6000000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.01, "TestAmax": 0.009, "TestAmin": 0.009, "TestAngle": 0.01, "TestAny": 0.009000000000000001, "TestAverage": 0.04100000000000001, "TestBincount": 0.09500000000000003, "TestCheckFinite": 0.004, "TestCopy": 0.011, "TestCorrCoef": 0.17400000000000004, "TestCov": 0.11700000000000002, "TestCumprod": 0.045, "TestCumsum": 0.059, "TestDelete": 0.023, "TestDiff": 0.131, "TestDigitize": 0.022000000000000006, "TestExtins": 0.008, "TestFilterwindows": 1.0770000000000002, "TestFlip": 0.044, "TestGradient": 0.20200000000000004, "TestInsert": 0.022000000000000002, "TestInterp": 0.06500000000000003, "TestKaiser": 0.015, "TestMedian": 0.15500000000000003, "TestMeshgrid": 0.08000000000000002, "TestMsort": 0.001, "TestPercentile": 0.20800000000000013, "TestPiecewise": 0.018, "TestProd": 0.044, "TestPtp": 0.014, "TestQuantile": 0.041000000000000016, "TestRot90": 0.556, "TestSelect": 0.012, "TestSinc": 0.012, "TestSortComplex": 0.014, "TestTrapz": 0.008, "TestTrimZeros": 0.018000000000000002, "TestUnique": 0.012, "Test_I0": 0.028999999999999998}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 1.3559999999999988, "TestHistogramOptimBinNums": 0.03600000000000001, "TestHistogramdd": 0.259}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.002, "TestConcatenator": 0.011000000000000001, "TestDiagIndices": 0.007, "TestDiagIndicesFrom": 0.011000000000000001, "TestFillDiagonal": 0.035, "TestGrid": 0.016, "TestIndexExpression": 0.014, "TestIx_": 0.01, "TestNdIndex": 0.002, "TestNdenumerate": 0.002, "TestRavelUnravelIndex": 1.2349999999999997}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.019000000000000003, "TestApplyOverAxes": 0.002, "TestArraySplit": 0.22900000000000004, "TestColumnStack": 0.013000000000000001, "TestDsplit": 0.015000000000000001, "TestDstack": 0.023, "TestExpandDims": 0.009000000000000001, "TestHsplit": 0.016, "TestKron": 0.023000000000000007, "TestMayShareMemory": 0.002, "TestPutAlongAxis": 0.024, "TestSplit": 0.009000000000000001, "TestSqueeze": 0.04000000000000001, "TestTakeAlongAxis": 1.1309999999999998, "TestTile": 0.118, "TestVsplit": 0.013}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.05199999999999999, "TestEye": 1.1569999999999996, "TestFliplr": 0.012, "TestFlipud": 0.007, "TestHistogram2d": 0.061, "TestTri": 0.13, "TestTrilIndicesFrom": 0.002, "TestTriuIndices": 0.004, "TestTriuIndicesFrom": 0.002, "TestVander": 0.026}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.002, "TestCommonType": 1.106, "TestImag": 0.017, "TestIscomplex": 0.008, "TestIscomplexobj": 0.006, "TestIsfinite": 0.016, "TestIsinf": 0.02, "TestIsnan": 0.017, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.011, "TestIsrealobj": 0.002, "TestIsscalar": 0.002, "TestMintypecode": 0.006, "TestNanToNum": 0.023000000000000007, "TestReal": 0.019, "TestRealIfClose": 0.006}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.18900000000000006, "TestCond": 0.31200000000000006, "TestDet": 0.21500000000000002, "TestEig": 0.04700000000000001, "TestEigh": 0.068, "TestEighCases": 0.002, "TestEigvals": 0.07600000000000001, "TestEigvalsh": 0.06300000000000001, "TestEigvalshCases": 0.001, "TestInv": 0.068, "TestLstsq": 0.31199999999999994, "TestMatrixRank": 0.513, "TestMisc": 0.15999999999999998, "TestMisc2": 0.015, "TestMultiDot": 0.08400000000000002, "TestNormDouble": 1.493, "TestNormInt64": 1.5570000000000002, "TestNormSingle": 1.526, "TestNorm_NonSystematic": 0.005, "TestPinv": 0.159, "TestPinvHermitian": 0.047, "TestQR": 0.6790000000000002, "TestSVD": 0.06100000000000001, "TestSVDHermitian": 0.21100000000000002, "TestSolve": 0.591, "TestTensorinv": 0.044, "TestTensorsolve": 0.017}, "torch_np/test_basic": {"TestArrayToSequence": 0.013999999999999999, "TestCopyTo": 0.035, "TestCtorNested": 0.01, "TestDefaultDtype": 0.008, "TestDivmod": 0.023999999999999997, "TestExport": 0.001, "TestMisc": 0.003, "TestNormalizations": 0.007, "TestOneArr": 1.3389999999999989, "TestOneArrAndAxesTuple": 0.022000000000000006, "TestOneArrAndAxis": 0.2850000000000002, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.018000000000000002, "TestPythonArgsToArray": 0.021000000000000005, "TestSequenceOfArrays": 0.032000000000000015, "TestSequenceOfArraysToSingle": 0.014, "TestShapeLikeToArray": 0.008, "TestSmokeNotImpl": 0.002}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 1.4389999999999994}, "torch_np/test_dtype": {"TestConvertDType": 1.141}, "torch_np/test_function_base": {"TestAppend": 1.153}, "torch_np/test_ndarray_methods": {"TestAmax": 0.011, "TestAmin": 0.011, "TestArgmax": 1.4610000000000003, "TestArgmaxArgminCommon": 0.20900000000000016, "TestArgmin": 1.6049999999999993, "TestContains": 0.002, "TestIndexing": 0.41100000000000003, "TestIter": 0.006, "TestNoExtraMethods": 0.012, "TestNonzero": 0.295, "TestRavel": 0.011, "TestReshape": 0.007, "TestTranspose": 0.045}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.20900000000000013, "TestNEP50Table": 0.005}, "torch_np/test_random": {"TestChoice": 0.14400000000000002, "TestNumpyGlobal": 0.005, "TestScalarReturn": 0.541, "TestShuffle": 0.017}, "torch_np/test_reductions": {"TestAll": 0.018000000000000002, "TestAny": 0.021, "TestFlatnonzero": 1.267, "TestGenericCumSumProd": 0.05, "TestGenericReductions": 3.229999999999926, "TestMean": 0.028999999999999998, "TestSum": 0.344}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.503, "TestIsScalar": 0.05100000000000002}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.8800000000000007, "TestNdarrayDunderVsUfunc": 0.4610000000000002, "TestUfuncDtypeKwd": 0.007, "TestUnaryUfuncs": 1.1279999999999977}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 1.255}}}, "macos-13-py3-arm64": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 0.0}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.5526666666666668}, "distributions/test_constraints": {"test_constraints": 0.013666666666666672}, "distributions/test_distributions": {"TestAgainstScipy": 0.48466666666666675, "TestConstraints": 0.056999999999999995, "TestDistributionShapes": 0.0596666666666667, "TestDistributions": 22.02633333333333, "TestFunctors": 0.005, "TestJit": 4.852666666666667, "TestKL": 1.742666666666666, "TestLazyLogitsInitialization": 0.005, "TestNumericalStability": 0.026666666666666672, "TestRsample": 0.31433333333333335, "TestValidation": 0.14033333333333334}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.326}, "dynamo/test_after_aot": {"TestAfterAot": 4.7026666666666666}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 9.415666666666665}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.47633333333333344}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.0099999999999993}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.4186666666666666, "NormalizeIRTests": 0.015666666666666666, "TestCustomBackendAPI": 0.6453333333333333, "TestExplainWithBackend": 5.153, "TestOptimizations": 1.0926666666666665}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 6.411999999999999}, "dynamo/test_base_output": {"TestBaseOutput": 0.0}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 4.254333333333332}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.160666666666667, "BytecodeTests": 0.301}, "dynamo/test_compile": {"InPlaceCompilationTests": 4.4093333333333335, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.512}, "dynamo/test_config": {"ConfigTests": 0.5499999999999999}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.124, "CppGuardManagerFuncTorchHigherOrderOpTests": 5.797, "CppGuardManagerFunctionTests": 10.97366666666669, "CppGuardManagerHigherOrderOpTests": 3.9166666666666656, "CppGuardManagerMiscTests": 19.26733333333334, "CppGuardManagerReproTests": 15.813666666666661}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.0063333333333335}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.18000000000000002}, "dynamo/test_decorators": {"DecoratorTests": 0.5673333333333336}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.009000000000000001}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 25.96066666666667, "DynamicShapesCtxManagerTests": 2.8316666666666666, "DynamicShapesExportTests": 918.1796666666665, "DynamicShapesFuncTorchHigherOrderOpTests": 89.99766666666666, "DynamicShapesFunctionTests": 42.24033333333333, "DynamicShapesHigherOrderOpTests": 9.809333333333333, "DynamicShapesMiscTests": 67.40033333333338, "DynamicShapesNNModuleTests": 5.859333333333331, "DynamicShapesReproTests": 58.61166666666667, "DynamicShapesSubGraphTests": 7.078666666666667, "DynamicShapesTestSDPA": 0.22633333333333336}, "dynamo/test_exc": {"ExcTests": 1.165}, "dynamo/test_export": {"ExportTests": 10.060999999999998}, "dynamo/test_export_mutations": {"MutationExportTests": 0.5013333333333334}, "dynamo/test_frame_init": {"FrameInitTests": 0.119}, "dynamo/test_functions": {"DefaultsTests": 0.4120000000000001, "FunctionTests": 12.021666666666704}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.0073333333333334}, "dynamo/test_global": {"TestGlobals": 0.7349999999999998}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.15033333333333335}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.04533333333333334, "FuncTorchHigherOrderOpTests": 6.713999999999998, "HigherOrderOpTests": 5.076666666666665, "HigherOrderOpVmapGuardTests": 2.468}, "dynamo/test_hooks": {"HooksTests": 13.665000000000001}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 5.383}, "dynamo/test_interop": {"InteropTests": 0.4953333333333334}, "dynamo/test_logging": {"LoggingTests": 9.386000000000001}, "dynamo/test_minifier": {"MinifierTests": 1.002}, "dynamo/test_misc": {"MiscTests": 27.781333333333354, "TestTracer": 0.048999999999999995}, "dynamo/test_model_output": {"TestHFPretrained": 0.0003333333333333333, "TestModelOutput": 0.0003333333333333333}, "dynamo/test_modules": {"NNModuleTests": 1.550999999999999, "OptimizedModuleTest": 5.572666666666667}, "dynamo/test_nops": {"NopTests": 0.36566666666666664}, "dynamo/test_optimizers": {"End2EndTests": 0.453}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.49866666666666676}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.7403333333333334}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.5673333333333334}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.6023333333333333}, "dynamo/test_recompiles": {"RecompileTests": 0.6233333333333334}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.39300000000000007}, "dynamo/test_repros": {"ReproTests": 25.210000000000008}, "dynamo/test_resume": {"ResumeFunctionTests": 0.327}, "dynamo/test_sdpa": {"TestSDPA": 0.4713333333333334}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.49}, "dynamo/test_sources": {"SourceTests": 0.36566666666666664}, "dynamo/test_structured_trace": {"StructuredTraceTest": 6.224}, "dynamo/test_subclasses": {"SubclassTests": 1.9259999999999993, "TestNestedTensor": 7.174666666666667}, "dynamo/test_subgraphs": {"SubGraphTests": 1.6803333333333328}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.0003333333333333333, "TraceRuleTests": 0.9113333333333333}, "dynamo/test_unspec": {"UnspecTests": 7.28}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.462}, "export/test_converter": {"TestConverter": 0.504}, "export/test_db": {"ExampleTests": 2.0789999999999997}, "export/test_experimental": {"TestExperiment": 0.5793333333333334}, "export/test_export": {"TestDynamismExpression": 0.39166666666666666, "TestExport": 19.60066666666667, "TestExportCustomClass": 0.0003333333333333333, "TestOneOffModelExportResult": 0.6343333333333333}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.26066666666666666, "NonStrictExportTestExport": 13.956666666666663}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.36000000000000004, "PreDispatchExportTestExport": 17.666333333333327}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.37999999999999995}, "export/test_hop": {"TestHOPCPU": 1.8393333333333335, "TestHOPGeneric": 0.0033333333333333335}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0, "TestLift": 0.001}, "export/test_pass_infra": {"TestPassInfra": 0.6790000000000002}, "export/test_passes": {"TestPasses": 7.163}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.5226666666666667, "RetraceExportTestExport": 25.315}, "export/test_schema": {"TestSchema": 0.207}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.14533333333333331, "SerDesExportPreDispatchTestExport": 12.982999999999999, "SerDesExportTestDynamismExpression": 0.40633333333333327, "SerDesExportTestExport": 19.534666666666666}, "export/test_serialize": {"TestDeserialize": 0.06900000000000005, "TestSaveLoad": 0.19933333333333333, "TestSchemaVersioning": 0.02266666666666667, "TestSerialize": 0.8806666666666669, "TestSerializeCustomClass": 0.0026666666666666666}, "export/test_sparse": {"TestSparseProp": 30.878333333333376}, "export/test_tools": {"TestExportTools": 0.532}, "export/test_torchbind": {"TestCompileTorchbind": 0.0, "TestExportTorchbind": 0.001, "TestRegisterFakeClass": 0.0}, "export/test_tree_utils": {"TestTreeUtils": 0.122}, "export/test_unflatten": {"TestUnflatten": 1.7023333333333335}, "export/test_verifier": {"TestVerifier": 0.6503333333333334}, "functorch/test_aotdispatch": {"TestAOTAutograd": 7.258999999999997, "TestAOTDispatch": 0.25366666666666665, "TestAOTExport": 1.268, "TestAOTModuleSimplified": 0.403, "TestEagerFusionModuleInfoCPU": 443.82333333333327, "TestEagerFusionOpInfoCPU": 1159.0496666666643, "TestPartitioning": 0.6489999999999999, "TestPythonKeyCPU": 0.20766666666666667}, "functorch/test_control_flow": {"TestControlFlow": 0.6003333333333334, "TestControlFlowTraced": 68.71066666666663}, "functorch/test_dims": {"TestMin": 6.971666666666668, "TestMinFunctorchOnly": 6.396000000000001}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.052000000000000025, "TestAutogradFunctionVmapAPICPU": 0.013000000000000003, "TestCompileTransformsCPU": 5.509333333333334, "TestComposabilityCPU": 1.188666666666666, "TestExamplesCorrectnessCPU": 2.8386666666666662, "TestFunctionalizeCPU": 0.07500000000000002, "TestGradTransformCPU": 0.25100000000000006, "TestHelpersCPU": 0.007666666666666668, "TestHessianCPU": 0.02, "TestHigherOrderOperatorInteractionCPU": 0.015000000000000001, "TestJacCPU": 0.30600000000000016, "TestJvpCPU": 0.03500000000000002, "TestLinearizeCPU": 0.13433333333333333, "TestMakeFunctional": 0.06033333333333335, "TestSliceArgnums": 0.013333333333333336, "TestVmapJvpInplaceViewCPU": 0.008666666666666668, "TestVmapOfGradCPU": 0.12866666666666668}, "functorch/test_logging": {"TestAOTLogging": 0.16366666666666665}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.36600000000000005, "RandomOpTestCase": 0.041666666666666664, "ReduceTestCase": 0.043000000000000003, "TestMemoryEfficientOpAuthoring": 0.0}, "functorch/test_minifier": {"TestMinifier": 0.24866666666666667}, "functorch/test_ops": {"TestOperatorsCPU": 1250.7816666666388}, "functorch/test_parsing": {"TestAnonymousAxis": 0.35233333333333333, "TestParsedExpression": 0.0030000000000000005, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.38866666666666666}, "functorch/test_vmap": {"TestRandomnessCPU": 0.5543333333333337, "TestTransformFailureCPU": 0.16533333333333336, "TestVmapAPI": 0.39833333333333343, "TestVmapBatchedGradientCPU": 0.07533333333333336, "TestVmapDeviceTypeCPU": 0.009333333333333334, "TestVmapNestedTensorCPU": 0.02066666666666667, "TestVmapOperators": 1.3049999999999982, "TestVmapOperatorsOpInfoCPU": 430.97666666666527}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 2.1799999999998736}, "higher_order_ops/test_with_effects": {"TestWithEffects": 0.0}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 288.1156666666668, "AOTInductorTestABICompatibleCpuWithStackAllocation": 195.85400000000027, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 75.18433333333323, "AOTInductorTestABICompatibleCuda": 0.005666666666666667, "AOTInductorTestNonABICompatibleCpu": 0.001, "AOTInductorTestNonABICompatibleCuda": 0.0013333333333333333}, "inductor/test_codecache": {"TestFxGraphCache": 16.670666666666666, "TestFxGraphCacheHashing": 0.49133333333333334, "TestUtils": 1.5523333333333333, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.147}, "inductor/test_compile_worker": {"TestCompileWorker": 2.8539999999999996}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 75.4143333333334, "TestCompiledAutograd": 93.22900000000003, "TestCustomOpWithCompiledAutograd": 0.21333333333333346}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 196.28266666666664, "CompiledOptimizerTests": 105.23900000000003}, "inductor/test_config": {"TestInductorConfig": 3.6706666666666656}, "inductor/test_control_flow": {"CondTests": 0.0003333333333333333, "WhileLoopTests": 0.0}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.001}, "inductor/test_debug_trace": {"TestDebugTrace": 2.308666666666667}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0}, "inductor/test_flex_attention": {"TestFlexAttention": 0.002, "TestTemplatedSDPA": 0.0016666666666666668}, "inductor/test_foreach": {"ForeachTests": 7.593333333333334}, "inductor/test_fx_fusion": {"TestFxFusion": 0.19499999999999998}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.11733333333333333, "TestGroupBatchFusion": 0.0, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.050666666666666665, "TestIndexingSimplification": 0.36599999999999994}, "inductor/test_mmdecomp": {"TestDecompCPU": 18.636000000000006}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 8.493333333333334}, "inductor/test_torchbind": {"TestTorchbind": 0.15266666666666664}, "inductor/test_torchinductor": {"CpuTests": 539.1636666666662, "SweepInputsCpuTest": 48.644000000000005, "TestFull": 4.210666666666667}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 589.1179999999998}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 725.2399999999998, "TestInductorDynamicCPU": 0.0030000000000000005}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 2216.41433333333}, "inductor/test_triton_kernels": {"KernelTests": 0.006666666666666668, "MutationTests": 0.0013333333333333333}, "inductor/test_utils": {"TestUtils": 0.1433333333333333}, "lazy/test_debug_util": {"DebugUtilTest": 0.4036666666666667}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.37266666666666665}, "lazy/test_generator": {"LazyGeneratorTest": 0.45166666666666666}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.605}, "lazy/test_step_closures": {"ClosuresTest": 2.427}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.18266666666666667, "TestLazyOpInfoCPU": 3.0133333333333288, "TestLazyTensor": 0.351}, "nn/test_convolution": {"TestConvolutionNN": 78.36866666666667, "TestConvolutionNNDeviceTypeCPU": 7.6566666666666405}, "nn/test_dropout": {"TestDropoutNN": 0.40066666666666667, "TestDropoutNNDeviceTypeCPU": 0.08766666666666667}, "nn/test_embedding": {"TestEmbeddingNN": 0.306, "TestEmbeddingNNDeviceTypeCPU": 2.2096666666666596}, "nn/test_init": {"TestNNInit": 3.6573333333333333}, "nn/test_lazy_modules": {"TestLazyModules": 0.8040000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.6750000000000002, "TestLoadStateDictSwap": 0.021333333333333333}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.013000000000000003, "TestModuleHookNN": 0.03466666666666667, "TestModuleHooks": 0.4406666666666667, "TestStateDictHooks": 0.012333333333333335}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 12.600999999999999, "TestMultiheadAttentionNNDeviceTypeCPU": 0.02366666666666667}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.5066666666666667}, "nn/test_parametrization": {"TestNNParametrization": 0.7193333333333335, "TestNNParametrizationDeviceCPU": 0.007666666666666666}, "nn/test_pooling": {"TestAvgPool": 0.6783333333333333, "TestPoolingNN": 0.7623333333333333, "TestPoolingNNDeviceTypeCPU": 23.31200000000001}, "nn/test_pruning": {"TestPruningNN": 0.36466666666666675}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.135}, "profiler/test_memory_profiler": {"TestDataFlow": 0.593, "TestIdentifyGradients": 0.08433333333333333, "TestMemoryProfiler": 0.41766666666666663, "TestMemoryProfilerE2E": 1.6273333333333333}, "profiler/test_profiler": {"TestExperimentalUtils": 4.769666666666667, "TestProfiler": 12.941999999999998, "TestProfilerCUDA": 0.0, "TestProfilerITT": 0.0}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.0}, "profiler/test_record_function": {"TestRecordFunction": 0.48533333333333334}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 2.42}, "test_ao_sparsity": {"TestActivationSparsifier": 0.053, "TestBaseDataScheduler": 0.015666666666666666, "TestBaseDataSparsifier": 0.032999999999999995, "TestBaseSparsifier": 0.014666666666666666, "TestBaseStructuredSparsifier": 0.7786666666666667, "TestCubicScheduler": 0.0030000000000000005, "TestFPGMPruner": 0.011333333333333334, "TestFakeSparsity": 0.06466666666666666, "TestNearlyDiagonalSparsifier": 0.31033333333333335, "TestNormDataSparsifiers": 0.3293333333333333, "TestQuantizationUtils": 0.011333333333333334, "TestQuantizedSparseKernels": 0.15633333333333332, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.016666666666666666, "TestScheduler": 0.008, "TestSparsityUtilFunctions": 0.021, "TestWeightNormSparsifier": 0.11166666666666668}, "test_autocast": {"TestAutocastCPU": 1.2599999999999998, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.0030000000000000005}, "test_autograd": {"TestAllowMutationOnSaved": 0.016000000000000004, "TestAutograd": 17.39333333333337, "TestAutogradComplex": 0.0026666666666666666, "TestAutogradDeviceTypeCPU": 0.07933333333333338, "TestAutogradForwardMode": 0.046000000000000034, "TestAutogradForwardModeBatchedGrad": 0.009, "TestAutogradFunctional": 3.40766666666666, "TestAutogradInferenceMode": 0.02300000000000001, "TestAutogradLogging": 0.008333333333333333, "TestAutogradMultipleDispatchCPU": 0.01, "TestMultithreadAutograd": 0.08433333333333336, "TestNestedCheckpoint": 0.15800000000000003}, "test_autograd_fallback": {"TestAutogradFallback": 0.3783333333333334}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 54.7483333333363}, "test_bundled_inputs": {"TestBundledInputs": 1.4759999999999998}, "test_comparison_utils": {"TestComparisonUtils": 0.5526666666666666}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCPU": 0.27466666666666667}, "test_content_store": {"TestContentStoreCPU": 4.781333333333333}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.313, "TestMAIATensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.0016666666666666668, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.30200000000000005, "TestMAIATensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.0016666666666666668, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 85.16033333333334}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.25666666666666665}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 0.2373333333333333}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.248}, "test_custom_backend": {"TestCustomBackend": 0.1466666666666667}, "test_custom_ops": {"MiniOpTest": 0.3313333333333334, "MiniOpTestOther": 0.028333333333333346, "TestCustomOp": 5.843666666666681, "TestCustomOpAPI": 0.05233333333333335, "TestCustomOpTestingCPU": 0.7233333333333335, "TestCustomOperators": 0.21566666666666667, "TestGenerateOpcheckTests": 1.4783333333333335}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 178.00833333333333, "TestConcatDataset": 0.006333333333333334, "TestConvAfterFork": 1.264, "TestCustomPinFn": 0.0013333333333333333, "TestDataLoader": 462.4019999999998, "TestDataLoaderDeviceTypeCPU": 6.349333333333334, "TestDataLoaderPersistentWorkers": 417.9313333333332, "TestDatasetRandomSplit": 0.2883333333333334, "TestDictDataLoader": 6.228000000000001, "TestIndividualWorkerQueue": 0.0006666666666666666, "TestNamedTupleDataLoader": 0.006000000000000001, "TestSetAffinity": 0.0003333333333333333, "TestStackDataset": 0.015333333333333332, "TestStringDataLoader": 0.0006666666666666666, "TestTensorDataset": 0.010666666666666666}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.004, "TestDataChunk": 0.3, "TestDataFramesPipes": 0.0, "TestFunctionalIterDataPipe": 2.5213333333333323, "TestFunctionalMapDataPipe": 0.025000000000000005, "TestGraph": 0.01, "TestIterDataPipeCountSampleYielded": 0.006666666666666668, "TestIterDataPipeGraphFastForward": 0.021666666666666667, "TestIterDataPipeSingletonConstraint": 0.012000000000000002, "TestIterableDataPipeBasic": 0.024333333333333335, "TestSerialization": 0.0, "TestSharding": 23.415666666666667, "TestStreamWrapper": 0.12366666666666666, "TestTyping": 0.0030000000000000005}, "test_decomp": {"DecompOneOffTestsCPU": 0.29, "HasDecompTest": 0.10566666666666667, "TestDecompCPU": 2182.3133333333167}, "test_deploy": {"TestFreezer": 0.37000000000000005}, "test_dispatch": {"TestDispatch": 20.746, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCPU": 0.4503333333333335}, "test_dynamic_shapes": {"TestDimConstraints": 1.2009999999999998, "TestFloorDiv": 0.033, "TestPySymInt": 0.831666666666667, "TestSymNumberMagicMethods": 0.8503333333333333}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 1.0293333333333337, "TestExpandedWeightHelperFunctionCPU": 0.283, "TestExpandedWeightModuleCPU": 1.958666666666667}, "test_fake_tensor": {"FakeTensorConstHandling": 0.02933333333333334, "FakeTensorConverterTest": 0.012333333333333335, "FakeTensorDispatchCache": 0.037666666666666675, "FakeTensorOpInfoTestCPU": 0.06433333333333334, "FakeTensorOperatorInvariants": 0.19333333333333336, "FakeTensorPropTest": 0.038, "FakeTensorSerialization": 0.0030000000000000005, "FakeTensorTest": 0.3956666666666668, "PropagateRealTensorsFakeTensorConstHandling": 0.08566666666666667, "PropagateRealTensorsFakeTensorConverterTest": 0.012000000000000002, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.044000000000000004, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.09633333333333334, "PropagateRealTensorsFakeTensorPropTest": 0.026333333333333334, "PropagateRealTensorsFakeTensorTest": 0.11733333333333336}, "test_flop_counter": {"TestFlopCounter": 0.3766666666666667}, "test_foreach": {"TestForeachCPU": 24.791333333333057}, "test_function_schema": {"TestFunctionSchema": 0.6063333333333333}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 25.706333333333333}, "test_functional_optim": {"TestFunctionalOptimParity": 0.0}, "test_functionalization": {"TestCrossRefFunctionalization": 1.676333333333332, "TestFunctionalization": 1.842333333333331}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.010333333333333333}, "test_futures": {"TestFuture": 1.0403333333333336}, "test_fx": {"AnnotationsTest": 0.009000000000000001, "TestCSEPass": 0.1206666666666667, "TestCommonPass": 0.03266666666666667, "TestConstFold": 0.07900000000000001, "TestConstParamShapeInControlFlow": 0.02, "TestDCE": 0.015666666666666666, "TestFX": 3.9963333333333204, "TestFXAPIBackwardCompatibility": 0.013333333333333334, "TestFunctionalTracing": 0.20100000000000015, "TestMatcher": 0.533, "TestOperatorSignaturesCPU": 1.405333333333324, "TestPassManager": 0.012666666666666668, "TestSourceMatcher": 0.5696666666666667, "TestSubgraphRewriter": 0.1373333333333334, "TypeCheckerTest": 0.11933333333333336}, "test_fx_experimental": {"TestFXExperimental": 1.0026666666666666, "TestNormalizeOperatorsCPU": 23.450333333333344, "TestTranslationValidation": 0.164}, "test_fx_passes": {"TestFXGraphPasses": 0.682, "TestFXMatcherUtils": 0.053666666666666675}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5746666666666668}, "test_import_stats": {"TestImportTime": 2.421}, "test_indexing": {"NumpyTestsCPU": 0.028000000000000014, "TestIndexingCPU": 0.9076666666666665}, "test_itt": {"TestItt": 0.0}, "test_jit": {"TestAliasAnalysis": 0.218, "TestAsync": 0.17500000000000004, "TestAtenPow": 0.004666666666666667, "TestAutodiffJit": 0.03133333333333333, "TestAutodiffSubgraphSlicing": 0.13666666666666671, "TestAwait": 0.10733333333333335, "TestBackends": 0.0003333333333333333, "TestBackendsWithCompiler": 0.0, "TestBatchMM": 0.044333333333333336, "TestBuiltins": 0.036000000000000004, "TestClassType": 1.436, "TestComplex": 0.30233333333333334, "TestCustomOperators": 0.02400000000000001, "TestDCE": 0.013, "TestDataParallel": 0.0, "TestDataclasses": 2.7943333333333324, "TestDeviceAnalysis": 0.07233333333333333, "TestDict": 0.20066666666666674, "TestDtypeAnalysis": 0.06666666666666667, "TestDtypeCustomRulesCPU": 1.4379999999999988, "TestEnum": 0.11800000000000001, "TestFreezing": 1.1763333333333337, "TestFrontend": 0.25033333333333335, "TestFrozenOptimizations": 3.716333333333333, "TestFunctionalBlocks": 0.0033333333333333335, "TestFunctionalToInplaceActivation": 0.053, "TestGenerator": 0.03833333333333334, "TestGetDefaultAttr": 0.009333333333333334, "TestGraphRewritePasses": 0.021333333333333333, "TestHash": 0.03733333333333333, "TestHooks": 0.33466666666666683, "TestIgnorableArgs": 0.007666666666666666, "TestIgnoreContextManager": 0.0, "TestInplaceToFunctionalActivation": 0.024000000000000004, "TestIsinstance": 0.10633333333333339, "TestJit": 3.219666666666663, "TestJitGeneratedModule": 6.736333333333338, "TestJitProfiler": 0.009, "TestJitUtils": 0.01466666666666667, "TestList": 0.5540000000000002, "TestLogging": 0.027000000000000007, "TestMKLDNNReinplacing": 0.0, "TestMisc": 0.08300000000000002, "TestMixTracingScripting": 0.6093333333333333, "TestModels": 0.5916666666666667, "TestModuleAPIs": 0.06533333333333334, "TestModuleContainers": 0.6566666666666668, "TestModuleInterface": 0.281, "TestModules": 0.008333333333333333, "TestNamedTuple": 0.03533333333333334, "TestNnapiBackend": 0.0013333333333333333, "TestOpDecompositions": 0.008666666666666666, "TestOptimizeForMobilePreserveDebugInfo": 0.08733333333333333, "TestParametrization": 0.042666666666666665, "TestPeephole": 0.23933333333333343, "TestProducerVersion": 0.001, "TestProfiler": 0.054333333333333345, "TestPythonBindings": 0.016666666666666666, "TestPythonBuiltinOP": 0.15700000000000003, "TestPythonIr": 0.009, "TestRecursiveScript": 0.4520000000000002, "TestRemoveMutation": 0.061333333333333344, "TestSaveLoad": 0.27033333333333337, "TestSaveLoadFlatbuffer": 0.2790000000000001, "TestSaveLoadForOpVersion": 1.482, "TestScript": 19.829, "TestScriptDict": 0.01466666666666667, "TestScriptList": 0.023000000000000007, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.10166666666666668, "TestScriptProfile": 0.16366666666666665, "TestSlice": 0.07500000000000001, "TestSparse": 0.013333333333333334, "TestStringFormatting": 0.061000000000000026, "TestSymbolicShapeAnalysis": 1.6999999999999993, "TestTensorBuiltins": 0.036000000000000004, "TestTensorCreationOps": 0.022333333333333334, "TestTensorMethods": 0.008, "TestTorchbind": 0.0016666666666666668, "TestTracer": 1.3799999999999997, "TestTypeSharing": 0.23300000000000007, "TestTypesAndAnnotation": 0.06933333333333334, "TestTyping": 0.18366666666666673, "TestUnion": 0.31966666666666677, "TestUnsupportedOps": 0.018000000000000002, "TestUpgraders": 0.038000000000000006, "TestWarn": 0.02666666666666667, "TestWith": 0.16766666666666666}, "test_jit_autocast": {"TestAutocast": 0.054333333333333324, "TestJitTraceAutocast": 23.67866666666667}, "test_jit_disabled": {"TestJitDisabled": 0.4749999999999999}, "test_jit_fuser_te": {"TestFuserCommon": 0.033, "TestLoopnestRandomizationCPU": 0.0, "TestNNCOpInfoCPU": 12.501666666667598, "TestTEFuserDynamic": 66.43733333333334, "TestTEFuserStatic": 61.792}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.0, "TestFusionPatternCPU": 0.0, "TestModel": 0.0, "TestOpCPU": 0.0}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.71, "TestVmapBatchedGradientLegacyCPU": 0.04966666666666669, "TestVmapOperatorsLegacy": 0.4623333333333335}, "test_license": {"TestLicense": 0.37599999999999995}, "test_linalg": {"TestLinalgCPU": 98.39700000000006}, "test_logging": {"LoggingTest": 1.7530000000000001}, "test_masked": {"TestMaskedCPU": 6.953666666666662}, "test_maskedtensor": {"TestBasicsCPU": 0.05200000000000001, "TestBinary": 0.17900000000000013, "TestOperatorsCPU": 2.8183333333333143, "TestReductions": 0.04033333333333334, "TestUnary": 0.48400000000000004}, "test_meta": {"TestMetaCPU": 652.1909999999694, "TestMetaConverter": 0.32333333333333336}, "test_mkl_verbose": {"TestMKLVerbose": 2.3669999999999995}, "test_mkldnn": {"TestMkldnnCPU": 0.0030000000000000005}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 2.356333333333333}, "test_mobile_optimizer": {"TestOptimizer": 0.6779999999999999}, "test_model_dump": {"TestModelDump": 0.4870000000000001}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.0006666666666666666}, "test_module_tracker": {"TestModuleTracker": 0.4076666666666666}, "test_modules": {"TestModuleCPU": 207.20666666667137, "TestModuleMPS": 250.829999999999}, "test_monitor": {"TestMonitor": 0.454, "TestMonitorTensorboard": 0.26166666666666666}, "test_multiprocessing": {"TestMultiprocessing": 158.96466666666672}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.23833333333333337, "SpawnTest": 11.574}, "test_namedtensor": {"TestNamedTensor": 0.5280000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.3863333333333332}, "test_native_functions": {"TestNativeFunctions": 0.5023333333333334}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.36133333333333345}, "test_nestedtensor": {"TestNestedTensor": 0.07266666666666671, "TestNestedTensorAutogradCPU": 0.3863333333333334, "TestNestedTensorDeviceTypeCPU": 0.38500000000000023, "TestNestedTensorSubclassCPU": 7.140666666666669}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.23833333333333337, "TestFusionUtils": 0.0026666666666666666, "TestNN": 21.908666666666644, "TestNNDeviceTypeCPU": 72.31000000000067, "TestUtils": 0.0023333333333333335}, "test_numba_integration": {"TestNumbaIntegration": 0.2823333333333333}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.47366666666666674}, "test_openmp": {"TestOpenMP_ParallelFor": 4.231}, "test_ops": {"TestCommonCPU": 594.6093333333162, "TestCompositeComplianceCPU": 316.8803333333289, "TestFakeTensorCPU": 136.64166666666634, "TestMathBitsCPU": 17.042, "TestRefsOpsInfoCPU": 0.9616666666666654, "TestSelfKwarg": 0.26733333333333337, "TestTagsCPU": 5.351333333333305}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 198.7676666666715}, "test_ops_gradients": {"TestBwdGradientsCPU": 321.97833333333307}, "test_ops_jit": {"TestJitCPU": 545.0590000000005}, "test_optim": {"TestDifferentiableOptimizer": 0.059666666666666666, "TestLRScheduler": 0.734666666666667, "TestOptimRenewedCPU": 9.98199999999998, "TestOptimRenewedMPS": 149.18733333333387, "TestSWAUtils": 0.04866666666666667}, "test_out_dtype_op": {"TestOutDtypeOp": 0.2803333333333333}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.002, "TestGradCheckOverride": 0.008, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.0013333333333333333, "TestResolveName": 0.05000000000000001, "TestTorchFunctionMode": 0.02400000000000001, "TestTorchFunctionOverride": 1.7636666666665846, "TestTorchFunctionWarning": 0.005333333333333333, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.04466666666666667, "ModelTest": 0.0, "TestAnalyze": 0.37133333333333335, "TestDependencyAPI": 0.031333333333333345, "TestDependencyHooks": 0.005333333333333333, "TestDiGraph": 0.013000000000000003, "TestGlobGroup": 0.059000000000000004, "TestImporter": 0.006000000000000001, "TestLoadBCPackages": 0.038000000000000006, "TestMangling": 0.011666666666666667, "TestMisc": 0.02600000000000001, "TestPackageFX": 0.034666666666666665, "TestPackageScript": 0.15600000000000003, "TestRepackage": 0.007333333333333333, "TestResources": 0.008333333333333333, "TestSaveLoad": 0.021}, "test_per_overload_api": {"TestPerOverloadAPI": 0.4253333333333333}, "test_prims": {"TestDecompCPU": 0.12833333333333333, "TestPrimsBasic": 0.3423333333333333, "TestPrimsCPU": 0.045000000000000005, "TestRefsCPU": 0.007666666666666666}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.056000000000000015, "TestGenericProxyTensorFake": 0.35000000000000014, "TestGenericProxyTensorReal": 0.35833333333333345, "TestGenericProxyTensorSymbolic": 0.38466666666666677, "TestProxyTensorOpInfoCPU": 376.68099999999805, "TestRealProxyTensor": 0.011000000000000001, "TestSymbolicTracing": 1.5066666666666662}, "test_pruning_op": {"PruningOpTest": 0.5213333333333333}, "test_public_bindings": {"TestPublicBindings": 0.429}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.0023333333333333335, "TestPythonDispatch": 2.8509999999999995, "TestPythonDispatcher": 0.0030000000000000005, "TestPythonRegistration": 0.14400000000000002, "TestWrapperSubclassAliasingCPU": 0.07866666666666669}, "test_pytree": {"TestCxxPytree": 0.002, "TestGenericPytree": 0.4133333333333334, "TestPythonPytree": 0.03566666666666669}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.022000000000000006, "TestAOMigrationQuantization": 0.012333333333333335, "TestAOMigrationQuantizationFx": 0.014000000000000004, "TestBackendConfig": 0.028666666666666674, "TestBiasCorrectionEager": 0.002, "TestBitsCPU": 0.025000000000000005, "TestComparatorOps": 0.41100000000000003, "TestDeprecatedJitQuantized": 0.034, "TestDistributed": 0.012333333333333335, "TestDuplicateDQPass": 0.8373333333333332, "TestDynamicQuantizedModule": 0.03333333333333333, "TestDynamicQuantizedOps": 0.05233333333333334, "TestEqualizeEager": 0.03266666666666667, "TestEqualizeFx": 0.39033333333333337, "TestFXGraphMatcher": 0.06033333333333334, "TestFXGraphMatcherModels": 0.0, "TestFXNumericSuiteCoreAPIs": 1.208333333333333, "TestFXNumericSuiteCoreAPIsModels": 0.011000000000000003, "TestFXNumericSuiteNShadows": 4.767000000000002, "TestFakeQuantize": 0.18000000000000002, "TestFakeQuantizeOps": 0.742, "TestFloat8DtypeCPU": 0.03900000000000002, "TestFloat8DtypeCPUOnlyCPU": 0.2866666666666667, "TestFuseEager": 0.0, "TestFuseFx": 0.2763333333333334, "TestFusedObsFakeQuant": 0.034666666666666665, "TestFusedObsFakeQuantModule": 0.05933333333333334, "TestFusionPasses": 0.010333333333333332, "TestFxDetectInputWeightEqualization": 0.0030000000000000005, "TestFxDetectOutliers": 0.004, "TestFxModelReportClass": 0.006333333333333333, "TestFxModelReportDetectDynamicStatic": 0.001, "TestFxModelReportDetector": 0.06533333333333334, "TestFxModelReportObserver": 0.053, "TestFxModelReportVisualizer": 0.004, "TestGenerateNumericDebugHandle": 0.23266666666666666, "TestGraphUtils": 0.4896666666666667, "TestHistogramObserver": 11.007333333333333, "TestMetaDataPorting": 1.7803333333333333, "TestModelNumericsEager": 0.02366666666666667, "TestNumericSuiteEager": 0.02000000000000001, "TestObserver": 0.9806666666666667, "TestPT2ERepresentation": 10.615333333333334, "TestPadding": 16.22566666666667, "TestQNNPackOps": 0.001, "TestQuantizationDocs": 0.09866666666666668, "TestQuantizeDynamicJitOps": 0.0030000000000000005, "TestQuantizeDynamicJitPasses": 0.17166666666666663, "TestQuantizeEagerOps": 0.37033333333333335, "TestQuantizeEagerPTQDynamic": 0.0006666666666666666, "TestQuantizeEagerPTQStatic": 0.07666666666666667, "TestQuantizeEagerQAT": 0.027666666666666673, "TestQuantizeEagerQATNumerics": 1.1026666666666665, "TestQuantizeFx": 0.0016666666666666668, "TestQuantizeFxModels": 0.005, "TestQuantizeFxOps": 0.0006666666666666666, "TestQuantizeJit": 0.009000000000000001, "TestQuantizeJitOps": 0.24300000000000002, "TestQuantizeJitPasses": 2.564333333333332, "TestQuantizePT2E": 20.088333333333335, "TestQuantizePT2EQATModels": 0.0, "TestQuantizePT2EQAT_ConvBn1d": 138.57366666666667, "TestQuantizePT2EQAT_ConvBn2d": 139.54533333333333, "TestQuantizePT2EX86Inductor": 0.03500000000000002, "TestQuantizedConv": 1.2763333333333333, "TestQuantizedEmbeddingOps": 0.0003333333333333333, "TestQuantizedFunctionalOps": 0.3716666666666666, "TestQuantizedLinear": 0.1516666666666667, "TestQuantizedOps": 18.913333333333338, "TestQuantizedTensor": 0.7330000000000001, "TestRecordHistogramObserver": 0.012666666666666666, "TestReferenceQuantizedModule": 0.018666666666666668, "TestSerialization": 0.029666666666666675, "TestStaticQuantizedModule": 0.08300000000000003, "TestSubgraphRewriter": 0.072, "TestUtils": 0.007666666666666668, "TestXNNPACKQuantizer": 11.578666666666669, "TestXNNPACKQuantizerModels": 0.0}, "test_reductions": {"TestReductionsCPU": 102.95599999999867}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 2.1873333333333327}, "test_schema_check": {"TestSchemaCheck": 0.41500000000000004, "TestSchemaCheckModeOpInfoCPU": 71.26266666666798}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.7086666666666671}, "test_serialization": {"TestBothSerializationCPU": 0.10766666666666667, "TestOldSerialization": 37.01133333333334, "TestSerialization": 4.203999999999994, "TestSubclassSerialization": 0.04066666666666667}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.39999999999999997}, "test_shape_ops": {"TestShapeOpsCPU": 0.7116666666666668}, "test_show_pickle": {"TestShowPickle": 0.3433333333333333}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.514333333333327}, "test_sparse": {"TestSparseAnyCPU": 176.44399999999928, "TestSparseCPU": 10.42866666666666, "TestSparseLegacyAndDeprecation": 0.36833333333333335, "TestSparseMaskedReductionsCPU": 0.45066666666666694, "TestSparseMeta": 1.7666666666666666, "TestSparseOneOff": 0.001, "TestSparseUnaryUfuncsCPU": 4.365666666666585}, "test_sparse_csr": {"TestSparseCSRCPU": 23.44466666666685, "TestSparseCSRSampler": 0.167, "TestSparseCompressedCPU": 32.519999999999904, "TestSparseCompressedTritonKernelsCPU": 0.0006666666666666666}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0003333333333333333}, "test_spectral_ops": {"TestFFTCPU": 5.457333333333324, "TestFFTDocExamplesCPU": 0.22766666666666668}, "test_stateless": {"TestPythonOptimizeMode": 1.9756666666666665, "TestStatelessDeprecation": 0.8756666666666666, "TestStatelessFunctionalAPI": 0.3576666666666668}, "test_subclass": {"TestSubclass": 0.4870000000000001}, "test_sympy_utils": {"TestSingletonInt": 0.0033333333333333335, "TestSympyInterp": 0.41833333333333345, "TestSympySolve": 0.19466666666666668, "TestValueRanges": 12.12066666666667}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.2650000000000002, "TestBufferProtocolCPU": 0.17166666666666677, "TestLikeTensorCreationCPU": 0.006000000000000001, "TestRandomTensorCreationCPU": 0.75, "TestTensorCreationCPU": 9.630999999999952}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.018333333333333337, "TestTensorBoardFigure": 0.0, "TestTensorBoardNumpy": 0.001, "TestTensorBoardPyTorchNumpy": 0.40266666666666673, "TestTensorBoardPytorchGraph": 0.14200000000000002, "TestTensorBoardSummary": 0.017666666666666667, "TestTensorBoardSummaryWriter": 0.008333333333333333, "TestTensorBoardUtils": 0.07100000000000001, "TestTensorBoardWriter": 0.24266666666666667, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 13.155333333333331}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.0030000000000000005, "TestTensorExprPyBind": 0.36633333333333334}, "test_testing": {"TestAssertClose": 0.24533333333333338, "TestAssertCloseContainer": 0.004, "TestAssertCloseErrorMessage": 0.021000000000000005, "TestAssertCloseQuantized": 0.004, "TestAssertCloseSparseBSC": 0.006333333333333333, "TestAssertCloseSparseBSR": 0.007, "TestAssertCloseSparseCOO": 0.04666666666666667, "TestAssertCloseSparseCSC": 0.006333333333333333, "TestAssertCloseSparseCSR": 0.006333333333333333, "TestFrameworkUtils": 5.484000000000001, "TestImports": 6.1610000000000005, "TestMakeTensorCPU": 0.8966666666666674, "TestOpInfoSampleFunctionsCPU": 2.65766666666663, "TestOpInfos": 0.0030000000000000005, "TestTestParametrization": 0.024333333333333346, "TestTestParametrizationDeviceTypeCPU": 1.7366666666666652, "TestTestingCPU": 0.3726666666666667}, "test_torch": {"TestBasicVitalSigns": 0.004, "TestTorch": 2.503999999999991, "TestTorchDeviceTypeCPU": 4.07066666666663, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 6.740666666666667, "TestSDPACPU": 219.22566666666637, "TestSDPAFailureModesCPU": 0.017000000000000005, "TestTransformersCPU": 8.465333333333334}, "test_type_hints": {"TestTypeHints": 0.3016666666666667}, "test_type_info": {"TestDTypeInfo": 0.3766666666666667}, "test_type_promotion": {"TestTypePromotionCPU": 2.0229999999999904}, "test_typing": {"TestTyping": 0.0}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 230.20866666661757}, "test_utils": {"TestAssert": 0.026333333333333337, "TestBottleneck": 8.217, "TestCheckpoint": 0.08500000000000002, "TestCollectEnv": 1.6476666666666666, "TestCppExtensionUtils": 0.04900000000000001, "TestDataLoaderUtils": 32.739, "TestDeviceUtilsCPU": 15.606333333333987, "TestExtensionUtils": 0.0030000000000000005, "TestHipify": 0.001, "TestHipifyTrie": 0.0003333333333333333, "TestONNXUtils": 0.0030000000000000005, "TestRenderUtils": 0.007333333333333333, "TestStandaloneCPPJIT": 4.493333333333333, "TestTraceback": 0.009333333333333334}, "test_view_ops": {"TestOldViewOpsCPU": 6.143000000000007, "TestViewOpsCPU": 0.6860000000000003, "TestViewOpsLAZY": 0.3116666666666668}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.0, "WeakKeyDictionaryTestCase": 0.01466666666666667, "WeakTest": 3.026666666666666}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 13.857666666666669, "TestXNNPACKOps": 1.7103333333333335, "TestXNNPACKRewritePass": 0.3376666666666666, "TestXNNPACKSerDes": 2.0963333333333334}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.12966666666666668, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.056333333333333346, "TestPromotion": 0.0006666666666666666}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 6.156666666666667, "TestEinsumPath": 0.0, "TestMisc": 0.0030000000000000005}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.2876666666666667, "TestHalf": 0.001, "TestIinfo": 0.12166666666666666, "TestMisc": 0.002, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.0016666666666666668, "TestBooleanIndexing": 0.0036666666666666666, "TestBroadcastedAssignments": 0.010666666666666666, "TestFancyIndexingCast": 0.002, "TestFloatNonIntegerArgument": 0.005666666666666667, "TestIndexing": 0.19400000000000006, "TestMultiIndexingAutomated": 0.004666666666666667, "TestMultipleEllipsisError": 0.0013333333333333333, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.015666666666666672, "TestArgmax": 0.6323333333333337, "TestArgmaxArgminCommon": 0.03333333333333335, "TestArgmin": 0.6090000000000004, "TestArrayAttributeDeletion": 0.004333333333333334, "TestArrayConstruction": 0.021000000000000005, "TestArrayCreationCopyArgument": 0.0006666666666666666, "TestAssignment": 0.006333333333333333, "TestAttributes": 0.011333333333333336, "TestBinop": 0.011000000000000001, "TestBool": 11.865666666666668, "TestCequenceMethods": 0.0016666666666666668, "TestChoose": 0.010000000000000002, "TestClip": 0.005999999999999999, "TestCompress": 0.005666666666666667, "TestConversion": 0.015666666666666666, "TestCreation": 0.0, "TestDelMisc": 0.0013333333333333333, "TestDot": 0.03566666666666668, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.016333333333333335, "TestFlag": 0.005666666666666667, "TestFormat": 0.004, "TestFromBuffer": 0.011000000000000001, "TestHash": 0.17333333333333334, "TestHashing": 0.0026666666666666666, "TestIO": 0.0, "TestInner": 0.10599999999999998, "TestLexsort": 0.016666666666666666, "TestMatmul": 0.19766666666666668, "TestMatmulOperator": 0.168, "TestMethods": 0.6903333333333336, "TestMinMax": 0.005, "TestMinScalarType": 0.004, "TestNewaxis": 0.0026666666666666666, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.011666666666666667, "TestRepeat": 0.006333333333333333, "TestResize": 0.025000000000000005, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.008, "TestSortFloatMisc": 0.08833333333333336, "TestStats": 0.11033333333333334, "TestSubscripting": 0.0013333333333333333, "TestTake": 0.026, "TestVdot": 0.01933333333333333, "TestWarnings": 0.001, "TestWhere": 0.19666666666666668, "TestWritebackIfCopy": 0.018}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.011333333333333334, "TestArgwhere": 0.014666666666666666, "TestArrayComparisons": 0.007666666666666666, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.007333333333333334, "TestBoolArray": 1.415333333333333, "TestBoolCmp": 0.08166666666666668, "TestBoolScalar": 0.008, "TestBroadcast": 0.005, "TestClip": 0.12200000000000007, "TestConvolve": 0.008333333333333333, "TestCorrelate": 0.013, "TestCreationFuncs": 0.5043333333333334, "TestCross": 0.02466666666666667, "TestDtypePositional": 0.0013333333333333333, "TestFloatExceptions": 0.008, "TestFromiter": 0.0, "TestIndex": 0.004333333333333334, "TestIndices": 0.025333333333333336, "TestIsclose": 0.03900000000000001, "TestIsscalar": 0.0026666666666666666, "TestLikeFuncs": 0.0003333333333333333, "TestMoveaxis": 0.006000000000000001, "TestNonarrayArgs": 0.06733333333333337, "TestNonzeroAndCountNonzero": 0.136, "TestOuterMisc": 0.0026666666666666666, "TestRequire": 0.004333333333333334, "TestResize": 0.19933333333333336, "TestRoll": 0.015666666666666666, "TestRollaxis": 0.0026666666666666666, "TestSeterr": 0.005666666666666667, "TestStdVar": 0.014666666666666666, "TestStdVarComplex": 0.005333333333333333, "TestStringFunction": 0.0013333333333333333, "TestTensordot": 0.009333333333333334, "TestTypes": 0.008}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.397, "TestDocStrings": 0.0, "TestIsSubDType": 0.006666666666666667, "TestScalarTypeNames": 0.02200000000000001}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06233333333333338, "TestFromInt": 0.0036666666666666666, "TestFromString": 0.4063333333333334}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0006666666666666666, "TestClassGetitemMisc": 0.2733333333333333, "TestIsInteger": 0.0}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.04900000000000001, "TestBaseMath": 4.245, "TestBitShifts": 0.04700000000000001, "TestComplexDivision": 0.028333333333333332, "TestConversion": 0.02466666666666667, "TestHash": 0.0, "TestModulus": 0.4383333333333333, "TestMultiply": 0.0, "TestNegative": 0.01, "TestPower": 0.056333333333333346, "TestRepr": 0.0013333333333333333, "TestScalarOpsMisc": 0.033333333333333354, "TestScalarSubclassingMisc": 0.004666666666666667, "TestSubtract": 0.008666666666666668, "TestTypes": 7.4686666666666675}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.405, "TestAtleast2d": 0.009333333333333334, "TestAtleast3d": 0.008333333333333333, "TestBlock": 0.020333333333333342, "TestConcatenate": 0.08466666666666672, "TestHstack": 0.01, "TestStackMisc": 0.0013333333333333333, "TestVstack": 0.010666666666666666}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.005333333333333333, "TestFFTShift": 3.029666666666667, "TestIRFFTN": 0.0016666666666666668, "TestRFFTFreq": 0.005}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.9856666666666665, "TestFFTShift": 0.36766666666666664, "TestFFTThreadSafe": 0.429}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.41300000000000003}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.0013333333333333333, "TestUnique": 0.21133333333333337}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.005, "TestAmax": 0.0036666666666666666, "TestAmin": 0.0036666666666666666, "TestAngle": 0.0036666666666666666, "TestAny": 0.004, "TestAverage": 0.013333333333333334, "TestBincount": 0.026000000000000006, "TestCheckFinite": 0.0023333333333333335, "TestCopy": 0.004666666666666667, "TestCorrCoef": 0.022333333333333334, "TestCov": 0.036333333333333336, "TestCumprod": 0.013666666666666666, "TestCumsum": 0.019666666666666666, "TestDelete": 0.008666666666666668, "TestDiff": 0.034666666666666665, "TestDigitize": 0.015333333333333336, "TestExtins": 0.004666666666666666, "TestFilterwindows": 0.33900000000000025, "TestFlip": 0.019333333333333338, "TestGradient": 0.07233333333333335, "TestInsert": 0.006666666666666667, "TestInterp": 0.034666666666666686, "TestKaiser": 0.006333333333333334, "TestMedian": 0.05833333333333335, "TestMeshgrid": 0.03366666666666667, "TestMsort": 0.0003333333333333333, "TestPercentile": 0.050666666666666686, "TestPiecewise": 0.01, "TestProd": 0.013666666666666666, "TestPtp": 0.004666666666666667, "TestQuantile": 0.040000000000000015, "TestRot90": 0.19066666666666668, "TestSelect": 0.007, "TestSinc": 0.004666666666666667, "TestSortComplex": 0.009000000000000001, "TestTrapz": 0.0036666666666666666, "TestTrimZeros": 0.008666666666666668, "TestUnique": 0.0030000000000000005, "Test_I0": 0.007666666666666666}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.4013333333333334, "TestHistogramOptimBinNums": 0.017000000000000008, "TestHistogramdd": 0.053}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006000000000000001, "TestDiagIndices": 0.0023333333333333335, "TestDiagIndicesFrom": 0.004333333333333334, "TestFillDiagonal": 0.012000000000000002, "TestGrid": 0.007, "TestIndexExpression": 0.004666666666666667, "TestIx_": 0.005, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.373}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.010666666666666666, "TestApplyOverAxes": 0.0013333333333333333, "TestArraySplit": 0.07300000000000001, "TestColumnStack": 0.004666666666666667, "TestDsplit": 0.006333333333333334, "TestDstack": 0.007333333333333333, "TestExpandDims": 0.005, "TestHsplit": 0.006666666666666667, "TestKron": 0.005333333333333333, "TestMayShareMemory": 0.0013333333333333333, "TestPutAlongAxis": 0.005333333333333333, "TestSplit": 0.0033333333333333335, "TestSqueeze": 0.014000000000000004, "TestTakeAlongAxis": 0.403, "TestTile": 0.036000000000000004, "TestVsplit": 0.005666666666666667}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.015333333333333332, "TestEye": 0.3973333333333333, "TestFliplr": 0.0026666666666666666, "TestFlipud": 0.0023333333333333335, "TestHistogram2d": 0.017, "TestTri": 0.03866666666666667, "TestTrilIndicesFrom": 0.0013333333333333333, "TestTriuIndices": 0.0013333333333333333, "TestTriuIndicesFrom": 0.0013333333333333333, "TestVander": 0.008333333333333333}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.422, "TestImag": 0.006333333333333334, "TestIscomplex": 0.0030000000000000005, "TestIscomplexobj": 0.0033333333333333335, "TestIsfinite": 0.008666666666666668, "TestIsinf": 0.006666666666666667, "TestIsnan": 0.007, "TestIsneginf": 0.0013333333333333333, "TestIsposinf": 0.0013333333333333333, "TestIsreal": 0.004333333333333334, "TestIsrealobj": 0.001, "TestIsscalar": 0.0013333333333333333, "TestMintypecode": 0.0036666666666666666, "TestNanToNum": 0.007333333333333333, "TestReal": 0.007666666666666666, "TestRealIfClose": 0.0023333333333333335}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.07866666666666668, "TestCond": 0.09499999999999999, "TestDet": 0.076, "TestEig": 0.015333333333333332, "TestEigh": 0.01466666666666667, "TestEighCases": 0.0, "TestEigvals": 0.025333333333333336, "TestEigvalsh": 0.013333333333333336, "TestEigvalshCases": 0.0, "TestInv": 0.023000000000000003, "TestLstsq": 0.10100000000000002, "TestMatrixRank": 0.1446666666666667, "TestMisc": 0.05100000000000001, "TestMisc2": 0.0013333333333333333, "TestMultiDot": 0.027000000000000007, "TestNormDouble": 0.3426666666666667, "TestNormInt64": 0.3256666666666667, "TestNormSingle": 0.3413333333333333, "TestNorm_NonSystematic": 0.0023333333333333335, "TestPinv": 0.07433333333333333, "TestPinvHermitian": 0.018666666666666665, "TestQR": 2.1099999999999994, "TestSVD": 0.020000000000000004, "TestSVDHermitian": 0.041, "TestSolve": 0.17200000000000001, "TestTensorinv": 0.012000000000000002, "TestTensorsolve": 0.008}, "torch_np/test_basic": {"TestArrayToSequence": 0.006000000000000001, "TestCopyTo": 0.0036666666666666666, "TestCtorNested": 0.0026666666666666666, "TestDefaultDtype": 0.004333333333333334, "TestDivmod": 0.008, "TestExport": 0.0, "TestMisc": 0.0013333333333333333, "TestNormalizations": 0.0030000000000000005, "TestOneArr": 0.5640000000000002, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1620000000000001, "TestOneArrAndShape": 0.0, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5373333333333333}, "torch_np/test_dtype": {"TestConvertDType": 0.49566666666666676}, "torch_np/test_function_base": {"TestAppend": 0.4686666666666666}, "torch_np/test_ndarray_methods": {"TestAmax": 0.0036666666666666666, "TestAmin": 0.0036666666666666666, "TestArgmax": 0.4933333333333336, "TestArgmaxArgminCommon": 0.6580000000000005, "TestArgmin": 0.5120000000000003, "TestContains": 0.0013333333333333333, "TestIndexing": 0.16066666666666665, "TestIter": 0.0030000000000000005, "TestNoExtraMethods": 0.006333333333333334, "TestNonzero": 0.06533333333333333, "TestRavel": 0.003666666666666667, "TestReshape": 0.0026666666666666666, "TestTranspose": 0.004333333333333334}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.053666666666666675, "TestNEP50Table": 0.0}, "torch_np/test_random": {"TestChoice": 0.005666666666666667, "TestNumpyGlobal": 0.002, "TestScalarReturn": 0.18466666666666667, "TestShuffle": 0.007}, "torch_np/test_reductions": {"TestAll": 0.007, "TestAny": 0.006999999999999999, "TestFlatnonzero": 0.4326666666666667, "TestGenericCumSumProd": 0.012000000000000002, "TestGenericReductions": 1.3253333333333193, "TestMean": 0.010666666666666666, "TestSum": 0.09866666666666668}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.13333333333333333, "TestIsScalar": 0.020333333333333346}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.47133333333333366, "TestNdarrayDunderVsUfunc": 0.10300000000000005, "TestUfuncDtypeKwd": 0.0030000000000000005, "TestUnaryUfuncs": 0.49833333333333335}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5183333333333334}}}, "macos-py3-arm64": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 0.0}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.20566666666666666}, "distributions/test_constraints": {"test_constraints": 0.008}, "distributions/test_distributions": {"TestAgainstScipy": 0.4253333333333334, "TestConstraints": 0.043333333333333335, "TestDistributionShapes": 0.05600000000000003, "TestDistributions": 19.368333333333336, "TestFunctors": 0.006333333333333333, "TestJit": 3.9070000000000005, "TestKL": 1.3616666666666661, "TestLazyLogitsInitialization": 0.004, "TestNumericalStability": 0.022666666666666672, "TestRsample": 0.268, "TestValidation": 0.15466666666666667}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.44166666666666665}, "dynamo/test_after_aot": {"TestAfterAot": 4.332000000000001}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 7.355999999999999}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 0.15533333333333335, "AOTAutogradCacheTests": 8.185}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 2.022}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.37633333333333335, "NormalizeIRTests": 0.017666666666666667, "TestCustomBackendAPI": 0.743, "TestExplainWithBackend": 5.845, "TestOptimizations": 1.4079999999999995}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 7.4383333333333335}, "dynamo/test_base_output": {"TestBaseOutput": 0.0}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 4.02, "BytecodeTests": 0.25866666666666666}, "dynamo/test_compile": {"InPlaceCompilationTests": 5.494, "PublicTorchCompilerTests": 0.002}, "dynamo/test_comptime": {"ComptimeTests": 0.4913333333333334}, "dynamo/test_config": {"ConfigTests": 0.413}, "dynamo/test_ctx_manager": {"CtxManagerTests": 0.8590000000000003}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.14666666666666664}, "dynamo/test_decorators": {"DecoratorTests": 4.2926666666666655}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.052333333333333336}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 236.57099999999994, "DynamicShapesCtxManagerTests": 2.7373333333333334, "DynamicShapesExportTests": 15.379999999999995, "DynamicShapesFuncTorchHigherOrderOpTests": 89.86333333333333, "DynamicShapesFunctionTests": 43.27333333333331, "DynamicShapesHigherOrderOpTests": 9.756, "DynamicShapesMiscTests": 50.56033333333335, "DynamicShapesNNModuleTests": 3.533333333333332, "DynamicShapesReproTests": 61.077666666666666, "DynamicShapesSubGraphTests": 7.0413333333333314, "DynamicShapesTestSDPA": 0.20766666666666667}, "dynamo/test_exc": {"ExcTests": 1.4333333333333333}, "dynamo/test_exceptions": {"ExceptionTests": 0.3763333333333334}, "dynamo/test_export": {"ExportTests": 10.229666666666661}, "dynamo/test_export_mutations": {"MutationExportTests": 0.5156666666666667}, "dynamo/test_frame_init": {"FrameInitTests": 0.143}, "dynamo/test_functions": {"DefaultsTests": 0.47266666666666673, "FunctionTests": 19.47600000000002}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 1.1356666666666666}, "dynamo/test_global": {"TestGlobals": 0.387}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.20100000000000004}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.038666666666666676, "FuncTorchHigherOrderOpTests": 5.522333333333333, "HigherOrderOpTests": 4.445999999999995, "HigherOrderOpVmapGuardTests": 1.982}, "dynamo/test_hooks": {"HooksTests": 14.077333333333337}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 5.174333333333333, "InlineInbuiltNNModulesExportTests": 9.389666666666663, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 6.103666666666666, "InlineInbuiltNNModulesFunctionTests": 11.703000000000012, "InlineInbuiltNNModulesHigherOrderOpTests": 4.204999999999997, "InlineInbuiltNNModulesMiscTests": 41.74966666666674, "InlineInbuiltNNModulesNNModuleTests": 2.4429999999999987}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 5.397333333333333}, "dynamo/test_interop": {"InteropTests": 0.4043333333333334}, "dynamo/test_logging": {"LoggingTests": 9.178666666666667}, "dynamo/test_minifier": {"MinifierTests": 0.8716666666666667}, "dynamo/test_misc": {"MiscTests": 35.71933333333337, "TestTracer": 0.04833333333333333}, "dynamo/test_model_output": {"TestHFPretrained": 0.0003333333333333333, "TestModelOutput": 0.0003333333333333333}, "dynamo/test_modules": {"NNModuleTests": 1.6953333333333316, "OptimizedModuleTest": 8.290666666666665}, "dynamo/test_nops": {"NopTests": 0.31233333333333335}, "dynamo/test_optimizers": {"End2EndTests": 0.47833333333333333}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.41533333333333333}, "dynamo/test_profiler": {"DynamoProfilerTests": 0.8756666666666667}, "dynamo/test_python_autograd": {"TestPythonAutograd": 0.6546666666666668}, "dynamo/test_recompile_ux": {"RecompileUxTests": 0.5830000000000001}, "dynamo/test_recompiles": {"RecompileTests": 0.5656666666666667}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.37100000000000005}, "dynamo/test_repros": {"ReproTests": 23.072999999999997}, "dynamo/test_resume": {"ResumeFunctionTests": 0.38400000000000006}, "dynamo/test_sdpa": {"TestSDPA": 0.34500000000000003}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.38599999999999995}, "dynamo/test_sources": {"SourceTests": 0.3473333333333333}, "dynamo/test_structured_trace": {"StructuredTraceTest": 7.531999999999999}, "dynamo/test_subclasses": {"SubclassTests": 2.6663333333333323, "TestNestedTensor": 5.921666666666667}, "dynamo/test_subgraphs": {"SubGraphTests": 1.2729999999999995}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.0, "TraceRuleTests": 0.9113333333333333}, "dynamo/test_unspec": {"UnspecTests": 7.9766666666666675}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.39566666666666667}, "dynamo/test_view": {"ViewTests": 0.4443333333333333}, "export/test_converter": {"TestConverter": 4.196000000000001}, "export/test_db": {"ExampleTests": 1.6216666666666661}, "export/test_experimental": {"TestExperiment": 0.5466666666666667}, "export/test_export": {"TestDynamismExpression": 0.36366666666666664, "TestExport": 17.215666666666664, "TestExportCustomClass": 0.0, "TestOneOffModelExportResult": 0.5586666666666668}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.33233333333333337, "NonStrictExportTestExport": 16.794666666666664}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.139}, "export/test_hop": {"TestHOPCPU": 1.6209999999999998, "TestHOPGeneric": 0.0023333333333333335}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0003333333333333333, "TestLift": 0.001}, "export/test_pass_infra": {"TestPassInfra": 0.6476666666666668}, "export/test_passes": {"TestPasses": 5.514666666666667}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 0.47766666666666663, "RetraceExportTestExport": 22.980666666666668}, "export/test_schema": {"TestSchema": 0.19366666666666665}, "export/test_serdes": {"SerDesExportTestDynamismExpression": 0.3933333333333333, "SerDesExportTestExport": 19.087}, "export/test_serialize": {"TestDeserialize": 0.06133333333333338, "TestSaveLoad": 0.19233333333333333, "TestSchemaVersioning": 0.018666666666666665, "TestSerialize": 0.7590000000000002, "TestSerializeCustomClass": 0.0026666666666666666}, "export/test_sparse": {"TestSparseProp": 27.66700000000007}, "export/test_tools": {"TestExportTools": 0.38800000000000007}, "export/test_torchbind": {"TestCompileTorchbind": 0.0, "TestExportTorchbind": 0.001, "TestRegisterFakeClass": 0.0}, "export/test_tree_utils": {"TestTreeUtils": 0.15966666666666665}, "export/test_unflatten": {"TestUnflatten": 2.2553333333333336}, "export/test_verifier": {"TestVerifier": 0.6790000000000002}, "functorch/test_aotdispatch": {"TestAOTAutograd": 6.526666666666665, "TestAOTAutogradWithDynamo": 6.649999999999999, "TestAOTDispatch": 0.24, "TestAOTExport": 1.1876666666666666, "TestAOTModuleSimplified": 0.38233333333333336, "TestEagerFusionModuleInfoCPU": 412.6509999999999, "TestEagerFusionOpInfoCPU": 1094.7733333333317, "TestPartitioning": 0.5996666666666667, "TestPythonKeyCPU": 0.23633333333333337}, "functorch/test_control_flow": {"TestControlFlow": 0.48200000000000004, "TestControlFlowTraced": 60.51733333333332}, "functorch/test_dims": {"TestMin": 7.869666666666667, "TestMinFunctorchOnly": 7.469333333333334}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.054333333333333365, "TestAutogradFunctionVmapAPICPU": 0.012666666666666668, "TestCompileTransformsCPU": 4.902666666666668, "TestComposabilityCPU": 0.8916666666666667, "TestExamplesCorrectnessCPU": 2.3633333333333333, "TestFunctionalizeCPU": 0.06600000000000002, "TestGradTransformCPU": 0.19433333333333339, "TestHelpersCPU": 0.006333333333333334, "TestHessianCPU": 0.014666666666666666, "TestHigherOrderOperatorInteractionCPU": 0.012333333333333335, "TestJacCPU": 0.29333333333333345, "TestJvpCPU": 0.02700000000000001, "TestLinearizeCPU": 0.11699999999999999, "TestMakeFunctional": 0.05100000000000002, "TestSliceArgnums": 0.010000000000000002, "TestVmapJvpInplaceViewCPU": 0.005999999999999999, "TestVmapOfGradCPU": 0.09800000000000002}, "functorch/test_logging": {"TestAOTLogging": 0.164}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.37300000000000005, "RandomOpTestCase": 0.036, "ReduceTestCase": 0.035, "TestMemoryEfficientOpAuthoring": 0.0}, "functorch/test_minifier": {"TestMinifier": 0.29433333333333334}, "functorch/test_ops": {"TestOperatorsCPU": 1099.3726666666569}, "functorch/test_parsing": {"TestAnonymousAxis": 0.14200000000000002, "TestParsedExpression": 0.0030000000000000005, "TestParsingUtils": 0.004, "TestValidateRearrangeExpressions": 0.004}, "functorch/test_rearrange": {"TestRearrange": 0.16933333333333334}, "functorch/test_vmap": {"TestRandomnessCPU": 0.45700000000000035, "TestTransformFailureCPU": 0.06266666666666666, "TestVmapAPI": 0.11100000000000004, "TestVmapBatchedGradientCPU": 0.05600000000000003, "TestVmapDeviceTypeCPU": 0.007333333333333333, "TestVmapNestedTensorCPU": 0.015000000000000006, "TestVmapOperators": 0.9956666666666671, "TestVmapOperatorsOpInfoCPU": 336.2346666666656}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 1.8609999999999072}, "higher_order_ops/test_with_effects": {"TestWithEffects": 0.0}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 261.46800000000013, "AOTInductorTestABICompatibleCpuWithStackAllocation": 201.55766666666673, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 75.76633333333324, "AOTInductorTestABICompatibleCuda": 0.0023333333333333335, "AOTInductorTestNonABICompatibleCpu": 0.0013333333333333333, "AOTInductorTestNonABICompatibleCuda": 0.0013333333333333333}, "inductor/test_codecache": {"TestFxGraphCache": 16.251333333333335, "TestFxGraphCacheHashing": 0.3986666666666667, "TestUtils": 1.3036666666666668, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.14866666666666664}, "inductor/test_compile_worker": {"TestCompileWorker": 4.076333333333333}, "inductor/test_compiled_autograd": {"TestAutogradWithCompiledAutograd": 123.5983333333337, "TestCompiledAutograd": 98.22966666666667, "TestCustomOpWithCompiledAutograd": 0.2180000000000001}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 244.10299999999998, "CompiledOptimizerTests": 106.66733333333336}, "inductor/test_config": {"TestInductorConfig": 3.705999999999998}, "inductor/test_control_flow": {"CondTests": 0.058666666666666666, "WhileLoopTests": 0.0}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.001}, "inductor/test_debug_trace": {"TestDebugTrace": 2.4303333333333335}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0003333333333333333}, "inductor/test_flex_attention": {"TestFlexAttention": 0.001}, "inductor/test_foreach": {"ForeachTests": 8.470666666666665}, "inductor/test_fx_fusion": {"TestFxFusion": 0.1386666666666667}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.11733333333333335, "TestGroupBatchFusion": 0.0, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.03133333333333333, "TestIndexingSimplification": 0.35799999999999993}, "inductor/test_mmdecomp": {"TestDecompCPU": 0.0}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 9.953}, "inductor/test_torchbind": {"TestTorchbind": 0.15866666666666665}, "inductor/test_torchinductor": {"CpuTests": 690.6806666666662, "SweepInputsCpuTest": 53.87900000000001, "TestFull": 4.690666666666666}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 671.5829999999997}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 780.4879999999998, "TestInductorDynamicCPU": 0.005666666666666667}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 11340.254666666677}, "inductor/test_triton_kernels": {"KernelTests": 0.009000000000000001, "MutationTests": 0.0013333333333333333}, "inductor/test_utils": {"TestUtils": 0.151}, "lazy/test_debug_util": {"DebugUtilTest": 0.16633333333333333}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.18400000000000002}, "lazy/test_generator": {"LazyGeneratorTest": 0.17066666666666666}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.39066666666666666}, "lazy/test_step_closures": {"ClosuresTest": 2.1769999999999996}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.22999999999999998, "TestLazyOpInfoCPU": 2.971666666666662, "TestLazyTensor": 0.03866666666666666}, "nn/test_convolution": {"TestConvolutionNN": 62.882, "TestConvolutionNNDeviceTypeCPU": 1.9776666666666312}, "nn/test_dropout": {"TestDropoutNN": 0.08666666666666667, "TestDropoutNNDeviceTypeCPU": 0.08133333333333334}, "nn/test_embedding": {"TestEmbeddingNN": 0.02933333333333335, "TestEmbeddingNNDeviceTypeCPU": 1.9533333333333267}, "nn/test_init": {"TestNNInit": 3.0786666666666656}, "nn/test_lazy_modules": {"TestLazyModules": 0.34066666666666673}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.29000000000000004, "TestLoadStateDictSwap": 0.018000000000000002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.009000000000000001, "TestModuleHookNN": 0.027333333333333338, "TestModuleHooks": 0.04300000000000001, "TestStateDictHooks": 0.02333333333333334}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 10.766333333333334, "TestMultiheadAttentionNNDeviceTypeCPU": 0.017000000000000005}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.22433333333333336}, "nn/test_parametrization": {"TestNNParametrization": 0.3153333333333334, "TestNNParametrizationDeviceCPU": 0.007}, "nn/test_pooling": {"TestAvgPool": 0.075, "TestPoolingNN": 0.12166666666666666, "TestPoolingNNDeviceTypeCPU": 14.974333333333329}, "nn/test_pruning": {"TestPruningNN": 0.06600000000000004}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.10433333333333335}, "profiler/test_memory_profiler": {"TestDataFlow": 0.5386666666666667, "TestIdentifyGradients": 0.075, "TestMemoryProfiler": 0.14666666666666667, "TestMemoryProfilerE2E": 1.4466666666666665}, "profiler/test_profiler": {"TestExperimentalUtils": 3.917, "TestProfiler": 11.896999999999998, "TestProfilerCUDA": 0.0, "TestProfilerITT": 0.0}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.0}, "profiler/test_record_function": {"TestRecordFunction": 0.15533333333333335}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 1.9123333333333334}, "test_ao_sparsity": {"TestActivationSparsifier": 0.05100000000000001, "TestBaseDataScheduler": 0.012333333333333335, "TestBaseDataSparsifier": 0.028999999999999998, "TestBaseSparsifier": 0.012333333333333335, "TestBaseStructuredSparsifier": 0.6666666666666669, "TestCubicScheduler": 0.0026666666666666666, "TestFPGMPruner": 0.010666666666666666, "TestFakeSparsity": 0.05466666666666667, "TestNearlyDiagonalSparsifier": 0.231, "TestNormDataSparsifiers": 0.2886666666666667, "TestQuantizationUtils": 0.010333333333333333, "TestQuantizedSparseKernels": 0.14566666666666664, "TestQuantizedSparseLayers": 0.002, "TestSaliencyPruner": 0.013333333333333334, "TestScheduler": 0.007, "TestSparsityUtilFunctions": 0.018333333333333337, "TestWeightNormSparsifier": 0.11133333333333334}, "test_autocast": {"TestAutocastCPU": 0.48966666666666664, "TestAutocastGPU": 0.0, "TestTorchAutocast": 0.0030000000000000005}, "test_autograd": {"TestAllowMutationOnSaved": 0.013000000000000005, "TestAutograd": 15.698666666666659, "TestAutogradComplex": 0.0036666666666666666, "TestAutogradDeviceTypeCPU": 0.09300000000000007, "TestAutogradForwardMode": 0.036000000000000025, "TestAutogradForwardModeBatchedGrad": 0.007333333333333333, "TestAutogradFunctional": 3.3159999999999936, "TestAutogradInferenceMode": 0.019333333333333345, "TestAutogradLogging": 0.008333333333333333, "TestAutogradMultipleDispatchCPU": 0.02866666666666667, "TestMultithreadAutograd": 0.08233333333333336, "TestNestedCheckpoint": 0.14733333333333334, "TestSelectiveActivationCheckpoint": 0.02033333333333334}, "test_autograd_fallback": {"TestAutogradFallback": 0.17333333333333337}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 49.88433333333678}, "test_bundled_inputs": {"TestBundledInputs": 1.2013333333333331}, "test_comparison_utils": {"TestComparisonUtils": 0.14200000000000002}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0}, "test_complex": {"TestComplexTensorCPU": 0.025000000000000005}, "test_content_store": {"TestContentStoreCPU": 3.81}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.08566666666666667, "TestMAIATensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.0013333333333333333, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.06633333333333334, "TestMAIATensor": 0.004, "TestPybindTypeCasters": 0.001, "TestRNGExtension": 0.0013333333333333333, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 89.66133333333333}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 0.0013333333333333333}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0}, "test_custom_backend": {"TestCustomBackend": 0.15433333333333335}, "test_custom_ops": {"MiniOpTest": 0.46333333333333354, "MiniOpTestOther": 0.04600000000000001, "TestCustomOp": 8.331000000000017, "TestCustomOpAPI": 0.09133333333333338, "TestCustomOpTestingCPU": 0.9276666666666668, "TestCustomOperators": 0.214, "TestGenerateOpcheckTests": 1.873}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 91.36666666666666, "TestConcatDataset": 0.006666666666666667, "TestConvAfterFork": 1.5353333333333332, "TestCustomPinFn": 0.0013333333333333333, "TestDataLoader": 437.5319999999999, "TestDataLoaderDeviceTypeCPU": 0.0003333333333333333, "TestDataLoaderPersistentWorkers": 400.0556666666666, "TestDatasetRandomSplit": 0.03133333333333333, "TestDictDataLoader": 6.465333333333334, "TestIndividualWorkerQueue": 0.0006666666666666666, "TestNamedTupleDataLoader": 0.004333333333333334, "TestSetAffinity": 0.0, "TestStackDataset": 0.015666666666666666, "TestStringDataLoader": 0.0, "TestTensorDataset": 0.011000000000000001}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.0023333333333333335, "TestDataChunk": 0.001, "TestDataFramesPipes": 0.001, "TestFunctionalIterDataPipe": 1.9403333333333326, "TestFunctionalMapDataPipe": 0.022000000000000002, "TestGraph": 0.007666666666666666, "TestIterDataPipeCountSampleYielded": 0.005666666666666667, "TestIterDataPipeGraphFastForward": 0.019, "TestIterDataPipeSingletonConstraint": 0.012333333333333333, "TestIterableDataPipeBasic": 0.021666666666666667, "TestSerialization": 0.0, "TestSharding": 23.23433333333333, "TestStreamWrapper": 0.139, "TestTyping": 0.002}, "test_decomp": {"DecompOneOffTestsCPU": 0.347, "HasDecompTest": 0.18266666666666667, "TestDecompCPU": 1984.0093333333182}, "test_deploy": {"TestFreezer": 0.14933333333333335}, "test_dispatch": {"TestDispatch": 22.024333333333335, "TestPythonDispatcher": 0.007}, "test_dlpack": {"TestTorchDlPackCPU": 0.1300000000000001}, "test_dynamic_shapes": {"TestDimConstraints": 1.31, "TestFloorDiv": 0.009333333333333334, "TestGuardsExpressions": 0.018, "TestPySymInt": 0.8346666666666668, "TestSymNumberMagicMethods": 1.066333333333332}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 0.8690000000000005, "TestExpandedWeightHelperFunctionCPU": 0.011000000000000003, "TestExpandedWeightModuleCPU": 1.8963333333333334}, "test_fake_tensor": {"FakeTensorConstHandling": 0.02566666666666667, "FakeTensorConverterTest": 0.011000000000000003, "FakeTensorDispatchCache": 0.03400000000000001, "FakeTensorOpInfoTestCPU": 0.05200000000000001, "FakeTensorOperatorInvariants": 0.18333333333333335, "FakeTensorPropTest": 0.03733333333333333, "FakeTensorSerialization": 0.0030000000000000005, "FakeTensorTest": 0.39833333333333343, "PropagateRealTensorsFakeTensorConstHandling": 0.07400000000000001, "PropagateRealTensorsFakeTensorConverterTest": 0.010000000000000002, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.038000000000000006, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.07500000000000001, "PropagateRealTensorsFakeTensorPropTest": 0.02266666666666667, "PropagateRealTensorsFakeTensorTest": 0.09966666666666668}, "test_flop_counter": {"TestFlopCounter": 0.09133333333333336}, "test_foreach": {"TestForeachCPU": 23.966333333333107}, "test_function_schema": {"TestFunctionSchema": 0.28400000000000003}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 22.523333333333337}, "test_functional_optim": {"TestFunctionalOptimParity": 0.0}, "test_functionalization": {"TestCrossRefFunctionalization": 1.2049999999999998, "TestFunctionalization": 1.437999999999999}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.01}, "test_futures": {"TestFuture": 0.786}, "test_fx": {"AnnotationsTest": 0.009000000000000001, "TestCSEPass": 0.10600000000000002, "TestCommonPass": 0.027666666666666662, "TestConstFold": 0.0676666666666667, "TestConstParamShapeInControlFlow": 0.018, "TestDCE": 0.014, "TestFX": 3.6586666666666505, "TestFXAPIBackwardCompatibility": 0.012000000000000002, "TestFunctionalTracing": 0.19600000000000015, "TestMatcher": 0.5623333333333335, "TestOperatorSignaturesCPU": 1.051999999999998, "TestPassManager": 0.011000000000000001, "TestSourceMatcher": 0.5616666666666666, "TestSubgraphRewriter": 0.12200000000000005, "TypeCheckerTest": 0.10566666666666669}, "test_fx_experimental": {"TestFXExperimental": 0.7070000000000002, "TestNormalizeOperatorsCPU": 18.11899999999999, "TestTranslationValidation": 0.07100000000000001}, "test_fx_passes": {"TestFXGraphPasses": 0.3700000000000001, "TestFXMatcherUtils": 0.054666666666666676}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.23066666666666671}, "test_import_stats": {"TestImportTime": 1.9323333333333332}, "test_indexing": {"NumpyTestsCPU": 0.021666666666666678, "TestIndexingCPU": 0.661}, "test_itt": {"TestItt": 0.0}, "test_jit": {"TestAliasAnalysis": 0.18466666666666667, "TestAsync": 0.1576666666666667, "TestAtenPow": 0.004, "TestAutodiffJit": 0.033999999999999996, "TestAutodiffSubgraphSlicing": 0.11400000000000005, "TestAwait": 0.09033333333333336, "TestBackends": 0.0, "TestBackendsWithCompiler": 0.0, "TestBatchMM": 0.038000000000000006, "TestBuiltins": 0.03, "TestClassType": 1.564333333333333, "TestComplex": 0.25366666666666665, "TestCustomOperators": 0.022333333333333344, "TestDCE": 0.01, "TestDataParallel": 0.0, "TestDataclasses": 2.1066666666666665, "TestDeviceAnalysis": 0.05266666666666666, "TestDict": 0.16900000000000004, "TestDtypeAnalysis": 0.053, "TestDtypeCustomRulesCPU": 1.2169999999999994, "TestEnum": 0.18066666666666673, "TestFreezing": 1.273666666666667, "TestFrontend": 0.20800000000000005, "TestFrozenOptimizations": 3.5293333333333323, "TestFunctionalBlocks": 0.0033333333333333335, "TestFunctionalToInplaceActivation": 0.048666666666666664, "TestGenerator": 0.03166666666666667, "TestGetDefaultAttr": 0.007333333333333333, "TestGraphRewritePasses": 0.02, "TestHash": 0.033, "TestHooks": 0.27866666666666673, "TestIgnorableArgs": 0.006000000000000001, "TestIgnoreContextManager": 0.0, "TestInplaceToFunctionalActivation": 0.01933333333333333, "TestIsinstance": 0.08666666666666671, "TestJit": 3.1679999999999957, "TestJitGeneratedModule": 5.368333333333356, "TestJitProfiler": 0.0006666666666666666, "TestJitUtils": 0.020000000000000004, "TestList": 0.48133333333333345, "TestLogging": 0.02566666666666667, "TestMKLDNNReinplacing": 0.0, "TestMisc": 0.09300000000000003, "TestMixTracingScripting": 0.6096666666666667, "TestModels": 0.5853333333333334, "TestModuleAPIs": 0.07166666666666667, "TestModuleContainers": 0.5433333333333334, "TestModuleInterface": 0.22533333333333339, "TestModules": 0.008, "TestNamedTuple": 0.03133333333333333, "TestNnapiBackend": 0.0, "TestOpDecompositions": 0.009000000000000001, "TestOptimizeForMobilePreserveDebugInfo": 0.07266666666666667, "TestParametrization": 0.036333333333333336, "TestPeephole": 0.17866666666666675, "TestProducerVersion": 0.001, "TestProfiler": 0.04766666666666667, "TestPythonBindings": 0.016666666666666666, "TestPythonBuiltinOP": 0.12900000000000003, "TestPythonIr": 0.007666666666666666, "TestRecursiveScript": 0.33833333333333343, "TestRemoveMutation": 0.061666666666666675, "TestSaveLoad": 0.22766666666666668, "TestSaveLoadFlatbuffer": 0.31133333333333335, "TestSaveLoadForOpVersion": 1.2553333333333334, "TestScript": 17.014000000000006, "TestScriptDict": 0.019333333333333338, "TestScriptList": 0.36633333333333334, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.08733333333333336, "TestScriptProfile": 0.1396666666666667, "TestSlice": 0.06366666666666669, "TestSparse": 0.011333333333333334, "TestStringFormatting": 0.04633333333333336, "TestSymbolicShapeAnalysis": 1.7246666666666657, "TestTensorBuiltins": 0.036666666666666674, "TestTensorCreationOps": 0.028999999999999998, "TestTensorMethods": 0.005999999999999999, "TestTorchbind": 0.0006666666666666666, "TestTracer": 1.1836666666666666, "TestTypeSharing": 0.21333333333333337, "TestTypesAndAnnotation": 0.056333333333333346, "TestTyping": 0.15500000000000008, "TestUnion": 0.18633333333333346, "TestUnsupportedOps": 0.015333333333333332, "TestUpgraders": 0.04200000000000001, "TestWarn": 0.020666666666666667, "TestWith": 0.13599999999999998}, "test_jit_autocast": {"TestAutocast": 0.046000000000000006, "TestJitTraceAutocast": 16.967}, "test_jit_disabled": {"TestJitDisabled": 0.25033333333333335}, "test_jit_fuser_te": {"TestFuserCommon": 0.028, "TestLoopnestRandomizationCPU": 0.0, "TestNNCOpInfoCPU": 7.09766666666695, "TestTEFuserDynamic": 56.992, "TestTEFuserStatic": 56.08599999999999}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0, "TestEnableDisableLlgaFuser": 0.0, "TestFusionPatternCPU": 0.0, "TestModel": 0.0, "TestOpCPU": 0.001}, "test_legacy_vmap": {"TestVmapAPILegacy": 0.3766666666666667, "TestVmapBatchedGradientLegacyCPU": 0.04900000000000002, "TestVmapOperatorsLegacy": 0.41666666666666674}, "test_license": {"TestLicense": 0.14733333333333334}, "test_linalg": {"TestLinalgCPU": 75.19366666666652}, "test_logging": {"LoggingTest": 1.2263333333333335}, "test_masked": {"TestMaskedCPU": 5.028333333333327}, "test_maskedtensor": {"TestBasicsCPU": 0.05133333333333334, "TestBinary": 0.15433333333333343, "TestOperatorsCPU": 2.467999999999997, "TestReductions": 0.04066666666666668, "TestUnary": 0.19633333333333347}, "test_meta": {"TestMetaCPU": 517.5513333332228, "TestMetaConverter": 0.030666666666666686}, "test_mkl_verbose": {"TestMKLVerbose": 1.8463333333333332}, "test_mkldnn": {"TestMkldnnCPU": 0.002}, "test_mkldnn_fusion": {"TestMkldnnFusion": 0.0}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 1.7953333333333334}, "test_mobile_optimizer": {"TestOptimizer": 0.47233333333333344}, "test_model_dump": {"TestModelDump": 0.2106666666666667}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.0003333333333333333}, "test_module_tracker": {"TestModuleTracker": 0.1446666666666667}, "test_modules": {"TestModuleCPU": 162.80766666667216, "TestModuleMPS": 192.61133333333575}, "test_monitor": {"TestMonitor": 0.13733333333333334, "TestMonitorTensorboard": 0.3586666666666667}, "test_multiprocessing": {"TestMultiprocessing": 160.2146666666667}, "test_multiprocessing_spawn": {"ErrorTest": 0.002, "ForkTest": 0.2436666666666667, "SpawnTest": 13.727666666666666}, "test_namedtensor": {"TestNamedTensor": 0.18566666666666679}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 1.048}, "test_native_functions": {"TestNativeFunctions": 0.22400000000000006}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.10333333333333335}, "test_nestedtensor": {"TestNestedTensor": 0.07266666666666671, "TestNestedTensorAutogradCPU": 0.3920000000000001, "TestNestedTensorDeviceTypeCPU": 0.37233333333333346, "TestNestedTensorSubclassCPU": 9.522000000000004}, "test_nn": {"TestAddRelu": 0.002, "TestConstantPadNd": 0.002, "TestFunctionalPickle": 0.001, "TestFusionEval": 0.20033333333333334, "TestFusionUtils": 0.002, "TestNN": 16.80899999999996, "TestNNDeviceTypeCPU": 59.82166666666629, "TestUtils": 0.002}, "test_numba_integration": {"TestNumbaIntegration": 0.041666666666666664}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.1056666666666667}, "test_openmp": {"TestOpenMP_ParallelFor": 3.8023333333333333}, "test_ops": {"TestCommonCPU": 577.2996666666464, "TestCompositeComplianceCPU": 300.2623333333313, "TestFakeTensorCPU": 122.69133333333544, "TestMathBitsCPU": 14.397999999999952, "TestRefsOpsInfoCPU": 0.9050000000000007, "TestSelfKwarg": 0.0026666666666666666, "TestTagsCPU": 4.248333333333307}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 200.49833333333706}, "test_ops_gradients": {"TestBwdGradientsCPU": 391.1559999999909}, "test_ops_jit": {"TestJitCPU": 536.1909999999998}, "test_optim": {"TestDifferentiableOptimizer": 0.06766666666666667, "TestLRScheduler": 0.6330000000000003, "TestOptimRenewedCPU": 11.230333333333327, "TestOptimRenewedMPS": 125.76733333333372, "TestSWAUtils": 0.06133333333333333}, "test_out_dtype_op": {"TestOutDtypeOp": 0.274}, "test_overrides": {"TestBroadcastAllOverride": 0.001, "TestDisabledTorchFunction": 0.001, "TestDisabledUserWarnings": 0.001, "TestEinsumOverride": 0.002, "TestGradCheckOverride": 0.008, "TestGradNewOnesOverride": 0.001, "TestIndexing": 0.005, "TestIterator": 0.001, "TestNamedTuple": 0.001, "TestPickle": 0.001, "TestRNN": 0.001, "TestResolveName": 0.04533333333333334, "TestTorchFunctionMode": 0.02400000000000001, "TestTorchFunctionOverride": 1.572666666666607, "TestTorchFunctionWarning": 0.005666666666666667, "TestWrapTorchFunction": 0.001}, "test_package": {"DirectoryReaderTest": 0.055333333333333325, "ModelTest": 0.0, "TestAnalyze": 0.19899999999999998, "TestDependencyAPI": 0.02800000000000001, "TestDependencyHooks": 0.005, "TestDiGraph": 0.012000000000000004, "TestGlobGroup": 0.014333333333333337, "TestImporter": 0.006000000000000001, "TestLoadBCPackages": 0.037333333333333336, "TestMangling": 0.011000000000000001, "TestMisc": 0.026333333333333337, "TestPackageFX": 0.033, "TestPackageScript": 0.1546666666666667, "TestRepackage": 0.006000000000000001, "TestResources": 0.007333333333333333, "TestSaveLoad": 0.018000000000000002}, "test_per_overload_api": {"TestPerOverloadAPI": 0.15366666666666665}, "test_prims": {"TestDecompCPU": 0.07833333333333335, "TestPrimsBasic": 0.012666666666666668, "TestPrimsCPU": 0.04333333333333334, "TestRefsCPU": 0.006666666666666667}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.043333333333333335, "TestGenericProxyTensorFake": 0.24933333333333343, "TestGenericProxyTensorReal": 0.19100000000000006, "TestGenericProxyTensorSymbolic": 0.30366666666666675, "TestProxyTensorOpInfoCPU": 318.9959999999956, "TestRealProxyTensor": 0.007666666666666666, "TestSymbolicTracing": 1.004666666666667}, "test_pruning_op": {"PruningOpTest": 0.20366666666666666}, "test_public_bindings": {"TestPublicBindings": 0.17366666666666666}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.0023333333333333335, "TestPythonDispatch": 2.5963333333333334, "TestPythonDispatcher": 0.0030000000000000005, "TestPythonRegistration": 0.29233333333333333, "TestWrapperSubclassAliasingCPU": 0.11433333333333336}, "test_pytree": {"TestCxxPytree": 0.005000000000000002, "TestGenericPytree": 0.2323333333333334, "TestPythonPytree": 0.04500000000000003}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.011000000000000003, "TestAOMigrationNNQuantized": 0.03266666666666667, "TestAOMigrationQuantization": 0.014000000000000004, "TestAOMigrationQuantizationFx": 0.032, "TestBackendConfig": 0.025333333333333347, "TestBiasCorrectionEager": 0.0023333333333333335, "TestBitsCPU": 0.025000000000000005, "TestComparatorOps": 0.45, "TestDeprecatedJitQuantized": 0.03233333333333333, "TestDistributed": 0.009000000000000001, "TestDuplicateDQPass": 0.8893333333333334, "TestDynamicQuantizedModule": 0.039, "TestDynamicQuantizedOps": 0.05833333333333334, "TestEqualizeEager": 0.057999999999999996, "TestEqualizeFx": 0.435, "TestFXGraphMatcher": 0.07566666666666667, "TestFXGraphMatcherModels": 0.0, "TestFXNumericSuiteCoreAPIs": 1.187333333333333, "TestFXNumericSuiteCoreAPIsModels": 0.011333333333333336, "TestFXNumericSuiteNShadows": 5.4623333333333335, "TestFakeQuantize": 0.15933333333333333, "TestFakeQuantizeOps": 0.8109999999999999, "TestFloat8DtypeCPU": 0.04966666666666669, "TestFloat8DtypeCPUOnlyCPU": 0.16, "TestFuseEager": 0.0003333333333333333, "TestFuseFx": 0.2853333333333334, "TestFusedObsFakeQuant": 0.034333333333333334, "TestFusedObsFakeQuantModule": 0.05633333333333334, "TestFusionPasses": 0.011000000000000001, "TestFxDetectInputWeightEqualization": 0.0033333333333333335, "TestFxDetectOutliers": 0.006333333333333334, "TestFxModelReportClass": 0.006333333333333334, "TestFxModelReportDetectDynamicStatic": 0.0013333333333333333, "TestFxModelReportDetector": 0.07733333333333335, "TestFxModelReportObserver": 0.06333333333333334, "TestFxModelReportVisualizer": 0.004333333333333334, "TestGenerateNumericDebugHandle": 0.26899999999999996, "TestGraphUtils": 0.4656666666666666, "TestHistogramObserver": 10.938, "TestMetaDataPorting": 1.970666666666667, "TestModelNumericsEager": 0.04733333333333334, "TestNumericSuiteEager": 0.019333333333333345, "TestObserver": 1.1773333333333333, "TestPT2ERepresentation": 12.115666666666664, "TestPadding": 15.253666666666668, "TestQNNPackOps": 0.0013333333333333333, "TestQuantizationDocs": 0.11233333333333335, "TestQuantizeDynamicJitOps": 0.0033333333333333335, "TestQuantizeDynamicJitPasses": 0.18200000000000002, "TestQuantizeEagerOps": 0.4003333333333334, "TestQuantizeEagerPTQDynamic": 0.0003333333333333333, "TestQuantizeEagerPTQStatic": 0.08566666666666667, "TestQuantizeEagerQAT": 0.026666666666666672, "TestQuantizeEagerQATNumerics": 0.7606666666666667, "TestQuantizeFx": 0.0013333333333333333, "TestQuantizeFxModels": 0.005333333333333333, "TestQuantizeFxOps": 0.0, "TestQuantizeJit": 0.009666666666666669, "TestQuantizeJitOps": 0.276, "TestQuantizeJitPasses": 2.418333333333333, "TestQuantizePT2E": 22.35733333333333, "TestQuantizePT2EQATModels": 0.0, "TestQuantizePT2EQAT_ConvBn1d": 156.977, "TestQuantizePT2EQAT_ConvBn2d": 160.524, "TestQuantizePT2EX86Inductor": 0.048000000000000036, "TestQuantizedConv": 1.3333333333333333, "TestQuantizedEmbeddingOps": 0.0003333333333333333, "TestQuantizedFunctionalOps": 0.31266666666666665, "TestQuantizedLinear": 0.19000000000000003, "TestQuantizedOps": 18.17633333333333, "TestQuantizedTensor": 0.7373333333333335, "TestRecordHistogramObserver": 0.011999999999999999, "TestReferenceQuantizedModule": 0.02, "TestSerialization": 0.03400000000000001, "TestStaticQuantizedModule": 0.08733333333333336, "TestSubgraphRewriter": 0.19066666666666673, "TestUtils": 0.008333333333333333, "TestXNNPACKQuantizer": 12.774333333333333, "TestXNNPACKQuantizerModels": 0.0003333333333333333}, "test_reductions": {"TestReductionsCPU": 83.18900000000514}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 1.5430000000000004}, "test_schema_check": {"TestSchemaCheck": 0.0506666666666667, "TestSchemaCheckModeOpInfoCPU": 61.09466666666817}, "test_segment_reductions": {"TestSegmentReductionsCPU": 0.33633333333333354}, "test_serialization": {"TestBothSerializationCPU": 0.15, "TestOldSerialization": 53.29633333333334, "TestSerialization": 4.660000000000003, "TestSubclassSerialization": 0.014}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.154}, "test_shape_ops": {"TestShapeOpsCPU": 0.35100000000000015}, "test_show_pickle": {"TestShowPickle": 0.19033333333333333}, "test_sort_and_select": {"TestSortAndSelectCPU": 1.113666666666665}, "test_sparse": {"TestSparseAnyCPU": 139.19033333333357, "TestSparseCPU": 9.641666666666659, "TestSparseLegacyAndDeprecation": 0.011666666666666667, "TestSparseMaskedReductionsCPU": 0.4110000000000002, "TestSparseMeta": 1.486, "TestSparseOneOff": 0.0, "TestSparseUnaryUfuncsCPU": 3.3323333333332434}, "test_sparse_csr": {"TestSparseCSRCPU": 21.429666666666773, "TestSparseCSRSampler": 0.17266666666666666, "TestSparseCompressedCPU": 34.2149999999999, "TestSparseCompressedTritonKernelsCPU": 0.0003333333333333333}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0003333333333333333}, "test_spectral_ops": {"TestFFTCPU": 2.7066666666666612, "TestFFTDocExamplesCPU": 0.19666666666666668}, "test_stateless": {"TestPythonOptimizeMode": 2.0986666666666665, "TestStatelessDeprecation": 0.8446666666666666, "TestStatelessFunctionalAPI": 0.09466666666666669}, "test_subclass": {"TestSubclass": 0.28100000000000014}, "test_sympy_utils": {"TestNumbers": 0.025666666666666667, "TestSingletonInt": 0.004666666666666666, "TestSympyInterp": 4.887333333333332, "TestSympySolve": 0.231, "TestValueRanges": 3.626666666666665}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.22866666666666682, "TestBufferProtocolCPU": 0.16066666666666676, "TestLikeTensorCreationCPU": 0.006000000000000001, "TestRandomTensorCreationCPU": 0.7276666666666668, "TestTensorCreationCPU": 8.249000000000004}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.019000000000000003, "TestTensorBoardFigure": 0.0, "TestTensorBoardNumpy": 0.001, "TestTensorBoardPyTorchNumpy": 0.18533333333333335, "TestTensorBoardPytorchGraph": 0.15433333333333335, "TestTensorBoardSummary": 0.018666666666666668, "TestTensorBoardSummaryWriter": 0.010666666666666666, "TestTensorBoardUtils": 0.08200000000000002, "TestTensorBoardWriter": 0.26366666666666666, "TestTensorProtoSummary": 0.007}, "test_tensorexpr": {"TestTensorExprFuser": 10.241333333333332}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.0036666666666666666, "TestTensorExprPyBind": 0.16866666666666666}, "test_testing": {"TestAssertClose": 0.2286666666666667, "TestAssertCloseContainer": 0.004666666666666667, "TestAssertCloseErrorMessage": 0.027000000000000007, "TestAssertCloseQuantized": 0.006333333333333334, "TestAssertCloseSparseBSC": 0.008, "TestAssertCloseSparseBSR": 0.008333333333333333, "TestAssertCloseSparseCOO": 0.011666666666666667, "TestAssertCloseSparseCSC": 0.008666666666666666, "TestAssertCloseSparseCSR": 0.008666666666666666, "TestFrameworkUtils": 6.597666666666666, "TestImports": 7.473666666666667, "TestMakeTensorCPU": 0.901333333333334, "TestOpInfoSampleFunctionsCPU": 2.685333333333322, "TestOpInfos": 0.0030000000000000005, "TestTestParametrization": 0.023333333333333345, "TestTestParametrizationDeviceTypeCPU": 2.0759999999999983, "TestTestingCPU": 0.1493333333333334}, "test_torch": {"TestBasicVitalSigns": 0.004333333333333334, "TestTorch": 2.0206666666666613, "TestTorchDeviceTypeCPU": 3.3369999999999442, "TestVitalSignsCudaCPU": 0.001}, "test_transformers": {"TestAttnBiasCPU": 4.382999999999999, "TestSDPACPU": 151.38166666666652, "TestSDPAFailureModesCPU": 0.010333333333333335, "TestTransformersCPU": 4.155}, "test_type_hints": {"TestTypeHints": 0.0003333333333333333}, "test_type_info": {"TestDTypeInfo": 0.16033333333333336}, "test_type_promotion": {"TestTypePromotionCPU": 1.3489999999999975}, "test_typing": {"TestTyping": 0.0}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 163.22400000001608}, "test_utils": {"TestAssert": 0.024000000000000004, "TestBottleneck": 8.244333333333334, "TestCheckpoint": 0.027000000000000007, "TestCollectEnv": 1.5696666666666668, "TestCppExtensionUtils": 0.04866666666666667, "TestDataLoaderUtils": 30.665999999999997, "TestDeviceUtilsCPU": 13.063333333334148, "TestExtensionUtils": 0.0026666666666666666, "TestHipify": 0.001, "TestHipifyTrie": 0.0, "TestONNXUtils": 0.0023333333333333335, "TestRenderUtils": 0.007, "TestStandaloneCPPJIT": 5.937333333333334, "TestTraceback": 0.009333333333333334}, "test_view_ops": {"TestOldViewOpsCPU": 5.20200000000001, "TestViewOpsCPU": 0.3690000000000002, "TestViewOpsLAZY": 0.29500000000000015}, "test_vulkan": {"TestVulkanRewritePass": 0.0}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.0, "WeakKeyDictionaryTestCase": 0.014000000000000005, "WeakTest": 2.4113333333333324}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 7.410000000000001, "TestXNNPACKOps": 1.1853333333333333, "TestXNNPACKRewritePass": 0.24866666666666667, "TestXNNPACKSerDes": 1.567}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.1526666666666667, "TestClassGetItem": 0.0, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.001, "TestMisc": 0.002, "TestPickling": 0.04833333333333334, "TestPromotion": 0.0}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 5.867333333333334, "TestEinsumPath": 0.0, "TestMisc": 0.0023333333333333335}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.0, "TestHalf": 0.0, "TestIinfo": 0.11466666666666668, "TestMisc": 0.001, "TestPythonFloat": 0.0, "TestRepr": 0.002, "TestSingle": 0.0}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.001, "TestBooleanIndexing": 0.0030000000000000005, "TestBroadcastedAssignments": 0.008, "TestFancyIndexingCast": 0.0016666666666666668, "TestFloatNonIntegerArgument": 0.004, "TestIndexing": 0.19666666666666674, "TestMultiIndexingAutomated": 0.004, "TestMultipleEllipsisError": 0.001, "TestNonIntegerArrayLike": 0.0}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.013666666666666667, "TestArgmax": 0.4290000000000003, "TestArgmaxArgminCommon": 0.022666666666666672, "TestArgmin": 0.45366666666666694, "TestArrayAttributeDeletion": 0.004, "TestArrayConstruction": 0.02033333333333334, "TestArrayCreationCopyArgument": 0.0, "TestAssignment": 0.004, "TestAttributes": 0.008666666666666668, "TestBinop": 0.007, "TestBool": 8.976999999999999, "TestCequenceMethods": 0.001, "TestChoose": 0.007666666666666666, "TestClip": 0.0023333333333333335, "TestCompress": 0.0030000000000000005, "TestConversion": 0.012000000000000002, "TestCreation": 0.001, "TestDelMisc": 0.001, "TestDot": 0.028666666666666684, "TestDtypedescr": 0.001, "TestFancyIndexing": 0.015333333333333332, "TestFlag": 0.0033333333333333335, "TestFormat": 0.0030000000000000005, "TestFromBuffer": 0.009333333333333334, "TestHash": 0.15266666666666667, "TestHashing": 0.002, "TestIO": 0.0, "TestInner": 0.07466666666666666, "TestLexsort": 0.014333333333333335, "TestMatmul": 0.15133333333333335, "TestMatmulOperator": 0.11599999999999999, "TestMethods": 0.5460000000000003, "TestMinMax": 0.0026666666666666666, "TestMinScalarType": 0.004, "TestNewaxis": 0.0023333333333333335, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.008333333333333333, "TestRepeat": 0.006999999999999999, "TestResize": 0.019333333333333338, "TestRichcompareScalar": 0.0, "TestScalarIndexing": 0.006333333333333334, "TestSortFloatMisc": 0.06733333333333336, "TestStats": 0.09500000000000001, "TestSubscripting": 0.001, "TestTake": 0.015666666666666666, "TestVdot": 0.017333333333333336, "TestWarnings": 0.001, "TestWhere": 0.16033333333333333, "TestWritebackIfCopy": 0.013333333333333334}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.010333333333333333, "TestArgwhere": 0.012000000000000002, "TestArrayComparisons": 0.006999999999999999, "TestBaseRepr": 0.004, "TestBinaryRepr": 0.006333333333333334, "TestBoolArray": 1.0693333333333335, "TestBoolCmp": 0.06133333333333333, "TestBoolScalar": 0.007, "TestBroadcast": 0.004, "TestClip": 0.0953333333333334, "TestConvolve": 0.009000000000000001, "TestCorrelate": 0.013999999999999999, "TestCreationFuncs": 0.41466666666666674, "TestCross": 0.021, "TestDtypePositional": 0.001, "TestFloatExceptions": 0.006333333333333334, "TestFromiter": 0.0003333333333333333, "TestIndex": 0.0023333333333333335, "TestIndices": 0.02466666666666667, "TestIsclose": 0.036333333333333336, "TestIsscalar": 0.0013333333333333333, "TestLikeFuncs": 0.0003333333333333333, "TestMoveaxis": 0.005666666666666667, "TestNonarrayArgs": 0.054333333333333365, "TestNonzeroAndCountNonzero": 0.10100000000000002, "TestOuterMisc": 0.0023333333333333335, "TestRequire": 0.005, "TestResize": 0.16433333333333336, "TestRoll": 0.014, "TestRollaxis": 0.0023333333333333335, "TestSeterr": 0.004, "TestStdVar": 0.011999999999999999, "TestStdVarComplex": 0.004666666666666667, "TestStringFunction": 0.001, "TestTensordot": 0.008, "TestTypes": 0.006333333333333334}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.001, "TestCommonType": 0.09933333333333334, "TestDocStrings": 0.0, "TestIsSubDType": 0.006000000000000001, "TestScalarTypeNames": 0.021000000000000008}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.06400000000000004, "TestFromInt": 0.0033333333333333335, "TestFromString": 0.11666666666666665}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0, "TestBitCount": 0.0, "TestClassGetItem": 0.0, "TestClassGetitemMisc": 0.0, "TestIsInteger": 0.0016666666666666668}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0003333333333333333}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.043333333333333335, "TestBaseMath": 3.536, "TestBitShifts": 0.04, "TestComplexDivision": 0.025333333333333336, "TestConversion": 0.01966666666666667, "TestHash": 0.0, "TestModulus": 0.385, "TestMultiply": 0.0, "TestNegative": 0.007333333333333333, "TestPower": 0.04900000000000001, "TestRepr": 0.001, "TestScalarOpsMisc": 0.026666666666666682, "TestScalarSubclassingMisc": 0.0023333333333333335, "TestSubtract": 0.007333333333333333, "TestTypes": 6.150333333333333}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.11533333333333334, "TestAtleast2d": 0.007, "TestAtleast3d": 0.007333333333333333, "TestBlock": 0.01900000000000001, "TestConcatenate": 0.07533333333333338, "TestHstack": 0.008333333333333333, "TestStackMisc": 0.0, "TestVstack": 0.051}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.004, "TestFFTShift": 2.2263333333333333, "TestIRFFTN": 0.001, "TestRFFTFreq": 0.004}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 0.9283333333333336, "TestFFTShift": 0.13333333333333333, "TestFFTThreadSafe": 0.422}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.14833333333333334}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.001, "TestUnique": 0.1606666666666667}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.0033333333333333335, "TestAmax": 0.0026666666666666666, "TestAmin": 0.0026666666666666666, "TestAngle": 0.0030000000000000005, "TestAny": 0.0030000000000000005, "TestAverage": 0.011000000000000001, "TestBincount": 0.021000000000000005, "TestCheckFinite": 0.002, "TestCopy": 0.0033333333333333335, "TestCorrCoef": 0.016, "TestCov": 0.027333333333333338, "TestCumprod": 0.011333333333333334, "TestCumsum": 0.015, "TestDelete": 0.006999999999999999, "TestDiff": 0.029666666666666664, "TestDigitize": 0.011333333333333336, "TestExtins": 0.0036666666666666666, "TestFilterwindows": 0.2603333333333335, "TestFlip": 0.013666666666666667, "TestGradient": 0.055000000000000014, "TestInsert": 0.005333333333333333, "TestInterp": 0.030666666666666686, "TestKaiser": 0.005, "TestMedian": 0.04466666666666668, "TestMeshgrid": 0.02333333333333334, "TestMsort": 0.0, "TestPercentile": 0.03833333333333334, "TestPiecewise": 0.008, "TestProd": 0.012666666666666666, "TestPtp": 0.004, "TestQuantile": 0.03200000000000001, "TestRot90": 0.17200000000000001, "TestSelect": 0.006000000000000001, "TestSinc": 0.004, "TestSortComplex": 0.007333333333333333, "TestTrapz": 0.0030000000000000005, "TestTrimZeros": 0.008, "TestUnique": 0.0023333333333333335, "Test_I0": 0.006333333333333333}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.18000000000000005, "TestHistogramOptimBinNums": 0.020666666666666677, "TestHistogramdd": 0.06466666666666666}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.001, "TestConcatenator": 0.006000000000000001, "TestDiagIndices": 0.0033333333333333335, "TestDiagIndicesFrom": 0.004333333333333334, "TestFillDiagonal": 0.013666666666666667, "TestGrid": 0.007, "TestIndexExpression": 0.005, "TestIx_": 0.005333333333333333, "TestNdIndex": 0.001, "TestNdenumerate": 0.001, "TestRavelUnravelIndex": 0.18933333333333335}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.010333333333333335, "TestApplyOverAxes": 0.001, "TestArraySplit": 0.067, "TestColumnStack": 0.006333333333333334, "TestDsplit": 0.006333333333333334, "TestDstack": 0.009333333333333334, "TestExpandDims": 0.005, "TestHsplit": 0.007333333333333333, "TestKron": 0.004333333333333334, "TestMayShareMemory": 0.001, "TestPutAlongAxis": 0.004333333333333334, "TestSplit": 0.0033333333333333335, "TestSqueeze": 0.012333333333333335, "TestTakeAlongAxis": 0.12466666666666666, "TestTile": 0.031, "TestVsplit": 0.005}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.012333333333333335, "TestEye": 0.13233333333333333, "TestFliplr": 0.0023333333333333335, "TestFlipud": 0.002, "TestHistogram2d": 0.016666666666666666, "TestTri": 0.037000000000000005, "TestTrilIndicesFrom": 0.001, "TestTriuIndices": 0.001, "TestTriuIndicesFrom": 0.0013333333333333333, "TestVander": 0.007333333333333333}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.001, "TestCommonType": 0.104, "TestImag": 0.005666666666666667, "TestIscomplex": 0.0030000000000000005, "TestIscomplexobj": 0.0030000000000000005, "TestIsfinite": 0.007, "TestIsinf": 0.006000000000000001, "TestIsnan": 0.007666666666666666, "TestIsneginf": 0.001, "TestIsposinf": 0.001, "TestIsreal": 0.0036666666666666666, "TestIsrealobj": 0.001, "TestIsscalar": 0.001, "TestMintypecode": 0.0030000000000000005, "TestNanToNum": 0.006333333333333334, "TestReal": 0.007, "TestRealIfClose": 0.002}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.05800000000000002, "TestCond": 0.07833333333333335, "TestDet": 0.05666666666666668, "TestEig": 0.014333333333333337, "TestEigh": 0.012333333333333337, "TestEighCases": 0.0, "TestEigvals": 0.02166666666666667, "TestEigvalsh": 0.011000000000000003, "TestEigvalshCases": 0.0, "TestInv": 0.021000000000000005, "TestLstsq": 0.07766666666666666, "TestMatrixRank": 0.12166666666666669, "TestMisc": 0.07233333333333335, "TestMisc2": 0.001, "TestMultiDot": 0.02133333333333334, "TestNormDouble": 0.28600000000000003, "TestNormInt64": 0.325, "TestNormSingle": 0.2813333333333334, "TestNorm_NonSystematic": 0.002, "TestPinv": 0.03933333333333333, "TestPinvHermitian": 0.013333333333333334, "TestQR": 1.6973333333333327, "TestSVD": 0.018333333333333337, "TestSVDHermitian": 0.035333333333333335, "TestSolve": 0.15533333333333335, "TestTensorinv": 0.010333333333333335, "TestTensorsolve": 0.007666666666666668}, "torch_np/test_basic": {"TestArrayToSequence": 0.006333333333333334, "TestCopyTo": 0.0030000000000000005, "TestCtorNested": 0.0013333333333333333, "TestDefaultDtype": 0.004, "TestDivmod": 0.007, "TestExport": 0.0, "TestMisc": 0.001, "TestNormalizations": 0.0030000000000000005, "TestOneArr": 0.23400000000000018, "TestOneArrAndAxesTuple": 0.009000000000000001, "TestOneArrAndAxis": 0.1320000000000001, "TestOneArrAndShape": 0.0, "TestOneArrToScalar": 0.009000000000000001, "TestPythonArgsToArray": 0.010000000000000002, "TestSequenceOfArrays": 0.016000000000000007, "TestSequenceOfArraysToSingle": 0.007, "TestShapeLikeToArray": 0.004, "TestSmokeNotImpl": 0.001}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.19233333333333338}, "torch_np/test_dtype": {"TestConvertDType": 0.1413333333333334}, "torch_np/test_function_base": {"TestAppend": 0.122}, "torch_np/test_ndarray_methods": {"TestAmax": 0.005999999999999999, "TestAmin": 0.0036666666666666666, "TestArgmax": 0.45700000000000035, "TestArgmaxArgminCommon": 0.6470000000000005, "TestArgmin": 0.4773333333333336, "TestContains": 0.001, "TestIndexing": 0.15233333333333332, "TestIter": 0.0030000000000000005, "TestNoExtraMethods": 0.006000000000000001, "TestNonzero": 0.05566666666666666, "TestRavel": 0.0036666666666666666, "TestReshape": 0.002, "TestTranspose": 0.004333333333333334}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.02166666666666667, "TestNEP50Table": 0.0006666666666666666}, "torch_np/test_random": {"TestChoice": 0.006000000000000001, "TestNumpyGlobal": 0.0023333333333333335, "TestScalarReturn": 0.20233333333333337, "TestShuffle": 0.008666666666666668}, "torch_np/test_reductions": {"TestAll": 0.005666666666666667, "TestAny": 0.005333333333333333, "TestFlatnonzero": 0.15666666666666668, "TestGenericCumSumProd": 0.010333333333333335, "TestGenericReductions": 1.2716666666666523, "TestMean": 0.009000000000000001, "TestSum": 0.09000000000000001}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.1536666666666667, "TestIsScalar": 0.02000000000000001}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.33600000000000024, "TestNdarrayDunderVsUfunc": 0.08900000000000004, "TestUfuncDtypeKwd": 0.0023333333333333335, "TestUnaryUfuncs": 0.17}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.18800000000000006}}}, "macos-py3-arm64-mps": {"mps": {"test_metal": {"TestMetalRewritePass": 1.1053333333333333}, "test_modules": {"TestModuleCPU": 665.3843333333233, "TestModuleMPS": 474.1086666666783}, "test_mps": {"MPSLeakyReluTest": 0.3606666666666667, "MPSReluTest": 0.22533333333333336, "MatmulTest": 0.2693333333333333, "TestAdvancedIndexing": 14.111333333333329, "TestAvgPool": 0.081, "TestCommonMPS": 16.227000000000004, "TestComplex": 3.1136666666666666, "TestConsistencyCPU": 1911.8689999999942, "TestConvolutionMPS": 7.674333333333333, "TestErrorInputsMPS": 15.494666666666653, "TestFallbackWarning": 5.93, "TestGatherScatter": 0.37800000000000006, "TestLinalgMPSMPS": 56.24433333333334, "TestLogical": 1.329, "TestMPS": 112.69933333333336, "TestMemoryLeak": 0.9123333333333333, "TestNLLLoss": 1.6603333333333337, "TestNNMPS": 9.259, "TestNoRegression": 0.15333333333333332, "TestPad": 1.3033333333333335, "TestPixelShuffle": 6.572666666666667, "TestRNNMPS": 5.153333333333333, "TestSmoothL1Loss": 0.20066666666666666, "TestTopK": 2.092, "TestViewOpsMPS": 2.316333333333334}}}, "parallelnative-linux-jammy-py3.8-gcc11": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 2.3979999999999997}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.56}, "distributions/test_constraints": {"test_constraints": 0.14700000000000008}, "distributions/test_distributions": {"TestAgainstScipy": 1.714, "TestConstraints": 0.21000000000000002, "TestDistributionShapes": 0.1835000000000001, "TestDistributions": 51.66, "TestFunctors": 0.0165, "TestJit": 29.098499999999998, "TestKL": 4.5755, "TestLazyLogitsInitialization": 0.018000000000000002, "TestNumericalStability": 0.10900000000000001, "TestRsample": 1.04, "TestValidation": 0.529}, "dynamo/test_activation_checkpointing": {"ActivationCheckpointingViaTagsTests": 0.901}, "dynamo/test_after_aot": {"TestAfterAot": 7.525499999999999}, "dynamo/test_allow_inline_skip": {"AllowInlineSkipTests": 0.6599999999999999}, "dynamo/test_aot_autograd": {"AotAutogradFallbackTests": 20.646500000000003}, "dynamo/test_aot_autograd_cache": {"AOTAutogradCachePicklerTests": 1.6714999999999998, "AOTAutogradCacheTests": 13.747}, "dynamo/test_autograd_function": {"AutogradFunctionTests": 4.3614999999999995}, "dynamo/test_backends": {"MPSNotSupportedTest": 0.0015, "NormalizeIRTests": 0.053, "TestCustomBackendAPI": 2.4675, "TestExplainWithBackend": 14.679499999999999, "TestOptimizations": 3.1104999999999996}, "dynamo/test_backward_higher_order_ops": {"BackwardHigherOrderOpTests": 17.7255}, "dynamo/test_base_output": {"TestBaseOutput": 0.0055}, "dynamo/test_bytecode_hook": {"BytecodeHookTests": 6.179}, "dynamo/test_bytecode_utils": {"BytecodeHookTests": 7.952, "BytecodeTests": 0.733}, "dynamo/test_compile": {"InPlaceCompilationTests": 10.014500000000002, "PublicTorchCompilerTests": 0.0035}, "dynamo/test_comptime": {"ComptimeTests": 1.1590000000000003}, "dynamo/test_config": {"ConfigTests": 0.968}, "dynamo/test_cpp_guard_manager": {"CppGuardManagerEnd2EndTests": 0.221, "CppGuardManagerFuncTorchHigherOrderOpTests": 10.604, "CppGuardManagerFunctionTests": 22.789000000000016, "CppGuardManagerHigherOrderOpTests": 7.347999999999993, "CppGuardManagerMiscTests": 38.98900000000005, "CppGuardManagerReproTests": 34.94500000000001}, "dynamo/test_ctx_manager": {"CtxManagerTests": 1.9175}, "dynamo/test_debug_utils": {"TestDebugUtils": 0.406}, "dynamo/test_decorators": {"DecoratorTests": 9.445999999999998}, "dynamo/test_deviceguard": {"TestCUDADeviceGuard": 0.0, "TestDeviceGuard": 0.022}, "dynamo/test_dynamic_shapes": {"DynamicShapesAotAutogradFallbackTests": 50.2595, "DynamicShapesCtxManagerTests": 6.840999999999999, "DynamicShapesExportTests": 42.7835, "DynamicShapesFuncTorchHigherOrderOpTests": 140.0655, "DynamicShapesFunctionTests": 94.79900000000002, "DynamicShapesHigherOrderOpTests": 23.523, "DynamicShapesMiscTests": 118.13000000000001, "DynamicShapesNNModuleTests": 9.307500000000001, "DynamicShapesReproTests": 142.61849999999995, "DynamicShapesSubGraphTests": 13.2685, "DynamicShapesTestSDPA": 0.526}, "dynamo/test_exc": {"ExcTests": 3.066}, "dynamo/test_exceptions": {"ExceptionTests": 0.8665}, "dynamo/test_export": {"ExportTests": 23.446000000000005}, "dynamo/test_export_mutations": {"MutationExportTests": 0.8680000000000001}, "dynamo/test_frame_init": {"FrameInitTests": 0.385}, "dynamo/test_functions": {"DefaultsTests": 1.0145000000000002, "FunctionTests": 41.45600000000005}, "dynamo/test_fx_passes_pre_grad": {"FxPassesPreGradTests": 2.059}, "dynamo/test_global": {"TestGlobals": 0.8585}, "dynamo/test_guard_manager": {"GuardManagerTests": 0.40700000000000003}, "dynamo/test_higher_order_ops": {"ActivationCheckpointingTests": 0.11050000000000001, "FuncTorchHigherOrderOpTests": 11.202499999999999, "HigherOrderOpTests": 11.528499999999998, "HigherOrderOpVmapGuardTests": 5.622}, "dynamo/test_hooks": {"HooksTests": 35.749}, "dynamo/test_inline_inbuilt_nn_modules": {"InlineInbuiltNNModulesAotAutogradFallbackTests": 10.873000000000001, "InlineInbuiltNNModulesExportTests": 33.343999999999966, "InlineInbuiltNNModulesFuncTorchHigherOrderOpTests": 10.655500000000002, "InlineInbuiltNNModulesFunctionTests": 31.322499999999998, "InlineInbuiltNNModulesHigherOrderOpTests": 10.375499999999997, "InlineInbuiltNNModulesMiscTests": 75.73050000000008, "InlineInbuiltNNModulesNNModuleTests": 6.355999999999998}, "dynamo/test_input_attr_tracking": {"TestInputAttrTracking": 11.179}, "dynamo/test_interop": {"InteropTests": 0.942}, "dynamo/test_logging": {"LoggingTests": 24.188}, "dynamo/test_minifier": {"MinifierTests": 2.1559999999999997}, "dynamo/test_misc": {"MiscTests": 84.68650000000014, "TestTracer": 0.0795}, "dynamo/test_model_output": {"TestHFPretrained": 0.0015, "TestModelOutput": 0.0045000000000000005}, "dynamo/test_modules": {"NNModuleTests": 4.239999999999997, "OptimizedModuleTest": 22.583499999999997}, "dynamo/test_nops": {"NopTests": 0.5165}, "dynamo/test_optimizers": {"End2EndTests": 1.0390000000000001, "OptimizerTests": 2.4629999999999996}, "dynamo/test_pre_dispatch": {"PreDispatchTests": 0.7875000000000001}, "dynamo/test_profiler": {"DynamoProfilerTests": 2.0694999999999997}, "dynamo/test_python_autograd": {"TestPythonAutograd": 1.0010000000000003}, "dynamo/test_recompile_ux": {"RecompileUxTests": 1.2685000000000004}, "dynamo/test_recompiles": {"RecompileTests": 1.3365000000000002}, "dynamo/test_reorder_logs": {"ReorderLogsTests": 0.8275000000000001}, "dynamo/test_replay_record": {"ReplayRecordTests": 0.8423333333333335}, "dynamo/test_repros": {"ReproTests": 60.699999999999996}, "dynamo/test_resume": {"ResumeFunctionTests": 0.6975}, "dynamo/test_sdpa": {"TestSDPA": 0.7595000000000001}, "dynamo/test_skip_non_tensor": {"SkipNonTensorTests": 0.8600000000000001}, "dynamo/test_sources": {"SourceTests": 0.789}, "dynamo/test_structured_trace": {"StructuredTraceTest": 21.451}, "dynamo/test_subclasses": {"SubclassTests": 4.511499999999998, "TestNestedTensor": 15.5535}, "dynamo/test_subgraphs": {"SubGraphTests": 3.4844999999999993}, "dynamo/test_trace_rules": {"TestModuleSurviveSkipFiles": 0.19, "TraceRuleTests": 1.738}, "dynamo/test_triton_kernels": {"KernelTests": 0.021000000000000008, "MutationTests": 0.0015, "NoOptimizationKernelTests": 0.016500000000000004, "no_opt_test_class": 0.02150000000000001}, "dynamo/test_unspec": {"UnspecTests": 18.755}, "dynamo/test_verify_correctness": {"TestVerifyCorrectness": 0.9065}, "dynamo/test_view": {"ViewTests": 0.9809999999999999}, "export/test_converter": {"TestConverter": 7.186}, "export/test_db": {"ExampleTests": 4.522}, "export/test_experimental": {"TestExperiment": 1.572}, "export/test_export": {"TestDynamismExpression": 0.6615, "TestExport": 42.995, "TestExportCustomClass": 0.0945, "TestOneOffModelExportResult": 1.633}, "export/test_export_nonstrict": {"NonStrictExportTestDynamismExpression": 0.5545, "NonStrictExportTestExport": 36.15549999999998}, "export/test_export_predispatch": {"PreDispatchExportTestDynamismExpression": 0.411, "PreDispatchExportTestExport": 27.16899999999999}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.3775}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 0.713}, "export/test_hop": {"TestHOPCPU": 3.9325, "TestHOPGeneric": 0.0045000000000000005}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.132, "TestLiftUnlift": 0.0165}, "export/test_pass_infra": {"TestPassInfra": 1.3135000000000003}, "export/test_passes": {"TestPasses": 19.036}, "export/test_retraceability": {"RetraceExportTestDynamismExpression": 1.214, "RetraceExportTestExport": 65.6465}, "export/test_safeguard": {"TestSafeguard": 0.7909999999999999}, "export/test_schema": {"TestSchema": 0.42099999999999993}, "export/test_serdes": {"SerDesExportPreDispatchTestDynamismExpression": 0.238, "SerDesExportPreDispatchTestExport": 20.800000000000004, "SerDesExportTestDynamismExpression": 0.7765, "SerDesExportTestExport": 42.27449999999998}, "export/test_serialize": {"TestDeserialize": 11.617000000000003, "TestOpVersioning": 0.004, "TestSaveLoad": 0.439, "TestSchemaVersioning": 0.0635, "TestSerialize": 1.5885000000000002, "TestSerializeCustomClass": 0.1285}, "export/test_sparse": {"TestSparseProp": 85.11349999999989}, "export/test_tools": {"TestExportTools": 0.8420000000000001}, "export/test_torchbind": {"TestCompileTorchbind": 1.5000000000000004, "TestExportTorchbind": 2.512499999999999, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.357}, "export/test_unflatten": {"TestUnflatten": 4.812000000000001}, "export/test_upgrade": {"TestUpgrade": 0.45400000000000007}, "export/test_verifier": {"TestVerifier": 1.4235000000000002}, "functorch/test_aotdispatch": {"TestAOTAutograd": 19.8775, "TestAOTAutogradWithDynamo": 23.132999999999996, "TestAOTDispatch": 0.9375, "TestAOTExport": 3.7819999999999996, "TestAOTModuleSimplified": 0.9490000000000001, "TestEagerFusionModuleInfoCPU": 1157.9440000000004, "TestEagerFusionOpInfoCPU": 2400.8854999999976, "TestPartitioning": 1.6644999999999999, "TestPythonKeyCPU": 2.831}, "functorch/test_control_flow": {"TestControlFlow": 1.195, "TestControlFlowTraced": 160.12549999999993}, "functorch/test_dims": {"TestMin": 21.279999999999998, "TestMinFunctorchOnly": 19.626499999999997}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.12700000000000006, "TestAutogradFunctionVmapAPICPU": 0.030000000000000002, "TestCompileTransformsCPU": 13.137, "TestComposabilityCPU": 2.283999999999999, "TestExamplesCorrectnessCPU": 7.2065, "TestFunctionalizeCPU": 0.15100000000000002, "TestGradTransformCPU": 0.6460000000000001, "TestHelpersCPU": 0.0165, "TestHessianCPU": 0.05449999999999999, "TestHigherOrderOperatorInteractionCPU": 0.039, "TestJacCPU": 0.7185000000000004, "TestJvpCPU": 0.07750000000000003, "TestLinearizeCPU": 0.33899999999999997, "TestMakeFunctional": 0.13400000000000006, "TestSliceArgnums": 0.023000000000000007, "TestVmapJvpInplaceViewCPU": 0.0205, "TestVmapOfGradCPU": 0.384}, "functorch/test_logging": {"TestAOTLogging": 0.4445}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.769, "RandomOpTestCase": 0.11399999999999999, "ReduceTestCase": 0.10949999999999999, "TestMemoryEfficientOpAuthoring": 0.0005}, "functorch/test_minifier": {"TestMinifier": 0.6699999999999999}, "functorch/test_ops": {"TestOperatorsCPU": 4457.550999999965}, "functorch/test_parsing": {"TestAnonymousAxis": 0.3825, "TestParsedExpression": 0.0085, "TestParsingUtils": 0.006, "TestValidateRearrangeExpressions": 0.006}, "functorch/test_rearrange": {"TestRearrange": 0.44600000000000006}, "functorch/test_vmap": {"TestRandomnessCPU": 1.6135000000000002, "TestTransformFailureCPU": 0.1315, "TestVmapAPI": 0.3875000000000002, "TestVmapBatchedGradientCPU": 0.25250000000000006, "TestVmapDeviceTypeCPU": 0.027000000000000003, "TestVmapNestedTensorCPU": 0.05050000000000002, "TestVmapOperators": 4.054999999999995, "TestVmapOperatorsOpInfoCPU": 715.0344999999967}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 3.279999999999838}, "higher_order_ops/test_with_effects": {"TestWithEffects": 8.6575}, "inductor/test_benchmark_fusion": {"BenchmarkFusionCpuTest": 11.8925}, "inductor/test_binary_folding": {"FreezingCpuTests": 50.4905}, "inductor/test_codecache": {"TestFxGraphCache": 56.35799999999999, "TestFxGraphCacheHashing": 1.2825000000000002, "TestUtils": 4.815, "test_codecache": 0.0}, "inductor/test_codegen_triton": {"TestCodegenTriton": 0.3785}, "inductor/test_compile_worker": {"TestCompileWorker": 10.011}, "inductor/test_compiled_autograd": {"EagerAutogradTests": 288.3900000000004, "TestAutogradWithCompiledAutograd": 418.1535000000004, "TestCompiledAutograd": 255.75700000000003, "TestCustomOpWithCompiledAutograd": 3.1654999999999927}, "inductor/test_compiled_optimizers": {"CompiledOptimizerParityTestsCPU": 743.6305, "CompiledOptimizerTests": 334.7645000000002}, "inductor/test_config": {"TestInductorConfig": 8.2145}, "inductor/test_control_flow": {"CondTests": 0.0095, "WhileLoopTests": 0.0045000000000000005}, "inductor/test_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 548.2979999999999, "TestCppWrapper": 581.1300000000002}, "inductor/test_cpu_cpp_wrapper": {"DynamicShapesCppWrapperCpuTests": 1689.2150000000001, "TestCppWrapper": 1687.4319999999998}, "inductor/test_cpu_repro": {"CPUReproTests": 910.7455}, "inductor/test_cpu_select_algorithm": {"TestSelectAlgorithmCPU": 1416.8360000000002, "TestSelectAlgorithmDynamicShapesCPU": 1411.5774999999996}, "inductor/test_custom_lowering": {"TestCustomLowering": 0.0045000000000000005}, "inductor/test_custom_post_grad_passes": {"TestPostGradCustomPrePostPass": 15.178999999999998}, "inductor/test_debug_trace": {"TestDebugTrace": 4.4265}, "inductor/test_decompose_mem_bound_mm": {"TestDecomposeMemMM": 0.0035}, "inductor/test_dependencies": {"TestDependencies": 0.001}, "inductor/test_distributed_patterns": {"DistributedPatternTests": 48.47950000000001}, "inductor/test_efficient_conv_bn_eval": {"EfficientConvBNEvalCpuTests": 0.0015}, "inductor/test_extension_backend": {"ExtensionBackendTests": 25.955}, "inductor/test_flex_attention": {"TestFlexAttention": 0.020500000000000008, "TestTemplatedSDPA": 0.009000000000000001}, "inductor/test_foreach": {"ForeachTests": 23.28999999999999}, "inductor/test_fused_attention": {"SDPAPatternRewriterCpuDynamicTests": 109.85149999999999, "SDPAPatternRewriterCpuTests": 105.3355}, "inductor/test_fx_fusion": {"TestFxFusion": 0.3985}, "inductor/test_graph_transform_observer": {"TestGraphTransformObserver": 0.0215}, "inductor/test_group_batch_fusion": {"TestFindIndependentSubsetGreedy": 0.27049999999999996, "TestGroupBatchFusion": 0.0005, "TestPostGradBatchLinearFusion": 0.0}, "inductor/test_indexing": {"ExprPrinterTests": 0.0665, "TestIndexingSimplification": 0.9315}, "inductor/test_inductor_freezing": {"FreezingCpuTests": 74.8305}, "inductor/test_memory_planning": {"TestMemoryPlanning": 0.0003333333333333333}, "inductor/test_minifier": {"MinifierTests": 34.592}, "inductor/test_minifier_isolate": {"MinifierIsolateTests": 67.4925}, "inductor/test_mkldnn_pattern_matcher": {"TestDynamicPatternMatcher": 229.73800000000003, "TestPatternMatcher": 800.7015}, "inductor/test_mmdecomp": {"TestDecompCPU": 57.042000000000044}, "inductor/test_profiler": {"DynamoProfilerTests": 0.004666666666666667}, "inductor/test_standalone_compile": {"TestStandaloneInductor": 24.5865}, "inductor/test_templated_attention": {"TestTemplatedSDPA": 0.005}, "inductor/test_torchbind": {"TestTorchbind": 13.5075}, "inductor/test_torchinductor": {"CpuTests": 1902.3505000000002, "SweepInputsCpuTest": 159.3445, "TestFull": 14.514499999999998}, "inductor/test_torchinductor_codegen_dynamic_shapes": {"DynamicShapesCodegenCpuTests": 2055.1429999999987}, "inductor/test_torchinductor_dynamic_shapes": {"DynamicShapesCpuTests": 2139.3759999999993, "TestInductorDynamicCPU": 0.04550000000000001}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCPU": 7616.550499999987}, "inductor/test_triton_extension_backend": {"TritonExtensionBackendTests": 0.8714999999999999}, "inductor/test_triton_kernels": {"KernelTests": 0.08500000000000006, "MutationTests": 0.011500000000000002, "NoOptimizationKernelTests": 0.018333333333333344, "no_opt_test_class": 0.013666666666666674}, "inductor/test_utils": {"TestUtils": 0.381}, "lazy/test_debug_util": {"DebugUtilTest": 0.4235}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.45299999999999996}, "lazy/test_generator": {"LazyGeneratorTest": 0.4465}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.793}, "lazy/test_step_closures": {"ClosuresTest": 3.38}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.34, "TestLazyOpInfoCPU": 9.235499999999947, "TestLazyTensor": 0.0985}, "nn/test_convolution": {"TestConvolutionNN": 27.995500000000007, "TestConvolutionNNDeviceTypeCPU": 13.810000000000008}, "nn/test_dropout": {"TestDropoutNN": 0.139, "TestDropoutNNDeviceTypeCPU": 0.398}, "nn/test_embedding": {"TestEmbeddingNN": 0.08000000000000004, "TestEmbeddingNNDeviceTypeCPU": 7.37049999999999}, "nn/test_init": {"TestNNInit": 5.771499999999999}, "nn/test_lazy_modules": {"TestLazyModules": 0.7505000000000004}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.804, "TestLoadStateDictSwap": 0.0645}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.031, "TestModuleHookNN": 0.11800000000000001, "TestModuleHooks": 0.12600000000000003, "TestStateDictHooks": 0.040500000000000015}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 6.836499999999999, "TestMultiheadAttentionNNDeviceTypeCPU": 0.028500000000000004}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.6130000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.12, "TestNNParametrizationDeviceCPU": 0.025500000000000002}, "nn/test_pooling": {"TestAvgPool": 0.4415, "TestPoolingNN": 0.44250000000000006, "TestPoolingNNDeviceTypeCPU": 49.62649999999999}, "nn/test_pruning": {"TestPruningNN": 0.14200000000000007}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.147}, "profiler/test_memory_profiler": {"TestDataFlow": 1.5639999999999996, "TestIdentifyGradients": 0.2965, "TestMemoryProfiler": 0.39749999999999996, "TestMemoryProfilerE2E": 3.6560000000000006}, "profiler/test_profiler": {"TestExecutionTrace": 8.068, "TestExperimentalUtils": 9.1855, "TestProfiler": 26.243999999999996, "TestProfilerCUDA": 0.0015, "TestProfilerITT": 0.006, "TestRecordFunction": 0.038000000000000006, "TestTorchTidyProfiler": 5.8309999999999995}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.5035000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.41950000000000004}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.0074999999999985}, "test_ao_sparsity": {"TestActivationSparsifier": 0.1175, "TestBaseDataScheduler": 0.044, "TestBaseDataSparsifier": 0.08600000000000001, "TestBaseSparsifier": 0.032, "TestBaseStructuredSparsifier": 1.6334999999999997, "TestComposability": 2.1215, "TestCubicScheduler": 0.006, "TestFPGMPruner": 0.0275, "TestFakeSparsity": 0.08900000000000001, "TestFxComposability": 1.794, "TestNearlyDiagonalSparsifier": 0.8694999999999999, "TestNormDataSparsifiers": 1.0795, "TestQuantizationUtils": 0.025, "TestQuantizedSparseKernels": 0.4005, "TestQuantizedSparseLayers": 0.4635, "TestSaliencyPruner": 0.0315, "TestScheduler": 0.018000000000000002, "TestSparsityUtilFunctions": 0.0455, "TestWeightNormSparsifier": 0.39}, "test_autocast": {"TestAutocastCPU": 1.645, "TestAutocastGPU": 0.001, "TestTorchAutocast": 0.0075}, "test_autograd": {"TestAllowMutationOnSaved": 0.036000000000000004, "TestAutograd": 36.280999999999935, "TestAutogradComplex": 0.0075, "TestAutogradDeviceTypeCPU": 0.34400000000000014, "TestAutogradForwardMode": 0.12350000000000005, "TestAutogradForwardModeBatchedGrad": 0.023, "TestAutogradFunctional": 13.0475, "TestAutogradInferenceMode": 0.04350000000000002, "TestAutogradLogging": 0.0165, "TestAutogradMultipleDispatchCPU": 0.019500000000000003, "TestMultithreadAutograd": 0.26050000000000006, "TestNestedCheckpoint": 0.5025000000000002, "TestSelectiveActivationCheckpoint": 0.02}, "test_autograd_fallback": {"TestAutogradFallback": 0.4965000000000001}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 129.43950000000606}, "test_bundled_inputs": {"TestBundledInputs": 1.5110000000000001}, "test_comparison_utils": {"TestComparisonUtils": 0.3935}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_complex": {"TestComplexTensorCPU": 0.08850000000000001}, "test_content_store": {"TestContentStoreCPU": 8.065}, "test_cpp_api_parity": {"TestCppApiParity": 4.6624999999999845}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.03550000000000001, "TestMAIATensor": 0.0105, "TestORTTensor": 0.013, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.03550000000000001, "TestMAIATensor": 0.0115, "TestORTTensor": 0.013, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.0045000000000000005, "TestTorchLibrary": 0.0}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 60.434}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 1.124}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 11.646999999999998}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 1.0955}, "test_custom_backend": {"TestCustomBackend": 0.10999999999999999}, "test_custom_ops": {"MiniOpTest": 0.9280000000000002, "MiniOpTestOther": 0.11050000000000003, "TestCustomOp": 3.752999999999993, "TestCustomOpAPI": 0.19300000000000006, "TestCustomOpTestingCPU": 2.1775, "TestCustomOperators": 0.42200000000000004, "TestGenerateOpcheckTests": 4.0305}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.012, "TestConvAfterFork": 0.0345, "TestCustomPinFn": 0.0025, "TestDataLoader": 108.459, "TestDataLoaderDeviceTypeCPU": 17.111, "TestDataLoaderPersistentWorkers": 135.82600000000002, "TestDatasetRandomSplit": 0.0385, "TestDictDataLoader": 0.037500000000000006, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.0055, "TestSetAffinity": 0.047, "TestStackDataset": 0.038500000000000006, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.026000000000000002}, "test_datapipe": {"TestCaptureDataFrame": 0.0, "TestCircularSerialization": 0.012, "TestDataChunk": 0.01, "TestDataFramesPipes": 0.0035, "TestFunctionalIterDataPipe": 6.6869999999999985, "TestFunctionalMapDataPipe": 0.041999999999999996, "TestGraph": 0.018500000000000003, "TestIterDataPipeCountSampleYielded": 0.012, "TestIterDataPipeGraphFastForward": 0.05500000000000001, "TestIterDataPipeSingletonConstraint": 0.028000000000000004, "TestIterableDataPipeBasic": 0.036000000000000004, "TestSerialization": 7.465, "TestSharding": 0.198, "TestStreamWrapper": 0.378, "TestTyping": 0.006}, "test_decomp": {"DecompOneOffTestsCPU": 1.1179999999999999, "HasDecompTest": 0.2495, "TestDecompCPU": 5959.942999999997}, "test_deploy": {"TestFreezer": 0.382}, "test_dispatch": {"TestDispatch": 40.227, "TestPythonDispatcher": 0.0485}, "test_dlpack": {"TestTorchDlPackCPU": 0.23600000000000015}, "test_dynamic_shapes": {"TestDimConstraints": 2.6505, "TestFloorDiv": 0.013500000000000002, "TestGuardsExpressions": 0.032, "TestPySymInt": 1.7049999999999996, "TestSymNumberMagicMethods": 2.1079999999999934}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 3.1264999999999965, "TestExpandedWeightHelperFunctionCPU": 0.027000000000000003, "TestExpandedWeightModuleCPU": 8.8965}, "test_fake_tensor": {"FakeTensorConstHandling": 0.07500000000000002, "FakeTensorConverterTest": 0.0315, "FakeTensorDispatchCache": 0.093, "FakeTensorOpInfoTestCPU": 0.10900000000000001, "FakeTensorOperatorInvariants": 0.40800000000000003, "FakeTensorPropTest": 0.0955, "FakeTensorSerialization": 0.0075, "FakeTensorTest": 1.0265000000000002, "PropagateRealTensorsFakeTensorConstHandling": 0.11850000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.030000000000000006, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.09949999999999998, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.227, "PropagateRealTensorsFakeTensorPropTest": 0.096, "PropagateRealTensorsFakeTensorTest": 0.32300000000000006}, "test_flop_counter": {"TestFlopCounter": 0.7805}, "test_foreach": {"TestForeachCPU": 72.3555000000004}, "test_function_schema": {"TestFunctionSchema": 0.779}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 62.4165}, "test_functional_optim": {"TestFunctionalOptimParity": 0.5475000000000001}, "test_functionalization": {"TestCrossRefFunctionalization": 3.1754999999999987, "TestFunctionalization": 3.804499999999999}, "test_functionalization_of_rng_ops": {"NegativeTestCPU": 0.025500000000000002}, "test_futures": {"TestFuture": 1.3555000000000001}, "test_fx": {"AnnotationsTest": 0.018500000000000006, "TestCSEPass": 0.3445000000000001, "TestCommonPass": 0.087, "TestConstFold": 0.19900000000000007, "TestConstParamShapeInControlFlow": 0.05449999999999999, "TestDCE": 0.0385, "TestFX": 5.080499999999995, "TestFXAPIBackwardCompatibility": 0.0375, "TestFunctionalTracing": 0.45850000000000035, "TestMatcher": 0.49850000000000005, "TestOperatorSignaturesCPU": 2.921999999999958, "TestPassManager": 0.030500000000000003, "TestSourceMatcher": 1.579, "TestSubgraphRewriter": 0.37950000000000006, "TestVisionTracing": 422.26549999999986, "TypeCheckerTest": 2.611999999999997}, "test_fx_experimental": {"TestFXExperimental": 25.042, "TestNormalizeOperatorsCPU": 57.124999999999986, "TestTranslationValidation": 0.1565}, "test_fx_passes": {"TestFXGraphPasses": 0.9175000000000003, "TestFXMatcherUtils": 0.11400000000000003}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.6230000000000002}, "test_import_stats": {"TestImportTime": 4.297}, "test_indexing": {"NumpyTestsCPU": 0.05550000000000003, "TestIndexingCPU": 2.750499999999998}, "test_itt": {"TestItt": 0.375}, "test_jit": {"TestAliasAnalysis": 0.376, "TestAsync": 0.37300000000000005, "TestAtenPow": 0.009000000000000001, "TestAutodiffJit": 0.069, "TestAutodiffSubgraphSlicing": 0.3045000000000001, "TestAwait": 0.1945, "TestBackends": 0.768, "TestBackendsWithCompiler": 0.2035, "TestBatchMM": 0.092, "TestBuiltins": 0.0635, "TestClassType": 1.0405000000000002, "TestComplex": 0.9295000000000002, "TestCustomOperators": 0.04450000000000001, "TestDCE": 0.0215, "TestDataParallel": 0.001, "TestDataclasses": 5.228999999999999, "TestDeviceAnalysis": 4.521, "TestDict": 0.44650000000000023, "TestDtypeAnalysis": 0.17149999999999999, "TestDtypeCustomRulesCPU": 2.3669999999999978, "TestEnum": 0.15550000000000003, "TestFreezing": 1.1465000000000005, "TestFrontend": 0.063, "TestFrozenOptimizations": 13.943500000000004, "TestFunctionalBlocks": 0.0075, "TestFunctionalToInplaceActivation": 4.434, "TestGenerator": 0.07550000000000001, "TestGetDefaultAttr": 0.018000000000000002, "TestGraphRewritePasses": 0.0425, "TestHash": 0.08399999999999999, "TestHooks": 0.7545000000000002, "TestIgnorableArgs": 0.0105, "TestIgnoreContextManager": 0.047, "TestInplaceToFunctionalActivation": 3.9974999999999996, "TestIsinstance": 0.2240000000000001, "TestJit": 6.0324999999999935, "TestJitGeneratedModule": 12.10100000000002, "TestJitProfiler": 0.0015, "TestJitUtils": 0.018000000000000006, "TestList": 1.3590000000000004, "TestLogging": 0.054000000000000006, "TestMKLDNNReinplacing": 0.006, "TestMisc": 0.19350000000000006, "TestMixTracingScripting": 1.3090000000000002, "TestModels": 1.9659999999999993, "TestModuleAPIs": 0.1395, "TestModuleContainers": 1.2840000000000003, "TestModuleInterface": 0.4325, "TestModules": 0.015, "TestNamedTuple": 0.07250000000000002, "TestNnapiBackend": 9.579999999999998, "TestOpDecompositions": 0.018500000000000003, "TestOptimizeForMobilePreserveDebugInfo": 0.17149999999999999, "TestParametrization": 0.0945, "TestPeephole": 0.4800000000000002, "TestProducerVersion": 0.0015, "TestProfiler": 0.6565, "TestPythonBindings": 0.0325, "TestPythonBuiltinOP": 0.4190000000000001, "TestPythonIr": 0.0245, "TestRecursiveScript": 0.6735000000000002, "TestRemoveMutation": 0.133, "TestSaveLoad": 0.43700000000000006, "TestSaveLoadFlatbuffer": 0.24950000000000006, "TestSaveLoadForOpVersion": 2.657, "TestScript": 19.011499999999998, "TestScriptDict": 0.03200000000000001, "TestScriptList": 0.8685, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.16850000000000004, "TestScriptProfile": 0.3855, "TestSlice": 0.16350000000000003, "TestSparse": 0.047, "TestStringFormatting": 0.12500000000000006, "TestSymbolicShapeAnalysis": 2.5734999999999983, "TestTensorBuiltins": 0.0805, "TestTensorCreationOps": 0.056999999999999995, "TestTensorMethods": 0.012, "TestTorchbind": 0.14650000000000005, "TestTracer": 3.1524999999999963, "TestTypeSharing": 0.5450000000000002, "TestTypesAndAnnotation": 0.12750000000000003, "TestTyping": 0.42700000000000016, "TestUnion": 0.44950000000000023, "TestUnsupportedOps": 0.0305, "TestUpgraders": 0.089, "TestWarn": 0.05299999999999999, "TestWith": 0.3305}, "test_jit_autocast": {"TestAutocast": 0.1305, "TestJitTraceAutocast": 34.137}, "test_jit_disabled": {"TestJitDisabled": 0.591}, "test_jit_fuser_te": {"TestFuserCommon": 0.17250000000000001, "TestLoopnestRandomizationCPU": 0.059, "TestNNCOpInfoCPU": 52.73250000000128, "TestTEFuserDynamic": 126.37900000000008, "TestTEFuserStatic": 52.446999999999996}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.0835, "TestFusionPatternCPU": 5.307499999999999, "TestModel": 2.7395, "TestOpCPU": 33.11600000000001}, "test_legacy_vmap": {"TestVmapAPI": 1.3499999999999985, "TestVmapAPILegacy": 1.4285, "TestVmapBatchedGradientCPU": 0.06500000000000003, "TestVmapBatchedGradientLegacyCPU": 0.11850000000000005, "TestVmapOperators": 0.9320000000000002, "TestVmapOperatorsLegacy": 1.1565000000000003}, "test_license": {"TestLicense": 0.3625}, "test_linalg": {"TestLinalgCPU": 198.7309999999993}, "test_logging": {"LoggingTest": 2.9}, "test_masked": {"TestMaskedCPU": 19.9845}, "test_maskedtensor": {"TestBasicsCPU": 0.14750000000000002, "TestBinary": 0.43100000000000027, "TestOperatorsCPU": 5.99499999999998, "TestReductions": 0.10650000000000001, "TestUnary": 0.4440000000000003}, "test_meta": {"TestMetaCPU": 1996.7559999998398, "TestMetaConverter": 0.1935}, "test_mkl_verbose": {"TestMKLVerbose": 5.086}, "test_mkldnn": {"TestMkldnnCPU": 205.51099999999997}, "test_mkldnn_fusion": {"TestMkldnnFusion": 108.6935}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.3309999999999995}, "test_mobile_optimizer": {"TestOptimizer": 3.5350000000000006}, "test_model_dump": {"TestModelDump": 1.2545}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.379}, "test_module_init": {"TestModuleInitCPU": 2.122999999999992}, "test_module_tracker": {"TestModuleTracker": 0.406}, "test_modules": {"TestModuleCPU": 757.9724999999926}, "test_monitor": {"TestMonitor": 0.406, "TestMonitorTensorboard": 0.259}, "test_multiprocessing": {"TestMultiprocessing": 66.598}, "test_multiprocessing_spawn": {"ErrorTest": 0.003, "ForkTest": 0.5725, "SpawnTest": 34.533}, "test_namedtensor": {"TestNamedTensor": 0.4545000000000001}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.501}, "test_native_functions": {"TestNativeFunctions": 0.5495000000000001}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.30450000000000016}, "test_nestedtensor": {"TestNestedTensor": 0.15850000000000009, "TestNestedTensorAutogradCPU": 1.2040000000000006, "TestNestedTensorDeviceTypeCPU": 0.8785000000000005, "TestNestedTensorSubclassCPU": 23.680500000000006}, "test_nn": {"TestAddRelu": 0.006, "TestConstantPadNd": 0.0045000000000000005, "TestFunctionalPickle": 0.0015, "TestFusionEval": 0.47050000000000003, "TestFusionUtils": 0.006, "TestNN": 55.993499999999926, "TestNNDeviceTypeCPU": 165.9355000000009, "TestUtils": 0.0045000000000000005}, "test_numba_integration": {"TestNumbaIntegration": 0.007}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.2165000000000001}, "test_openmp": {"TestOpenMP_ParallelFor": 6.78}, "test_ops": {"TestCommonCPU": 1436.650499999985, "TestCompositeComplianceCPU": 792.4374999999956, "TestFakeTensorCPU": 344.12000000000177, "TestMathBitsCPU": 49.50749999999992, "TestRefsOpsInfoCPU": 1.357500000000001, "TestSelfKwarg": 0.025, "TestTagsCPU": 11.140499999999978}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 896.7930000000104}, "test_ops_gradients": {"TestBwdGradientsCPU": 1117.5425000000205}, "test_ops_jit": {"TestJitCPU": 1082.8974999999996}, "test_optim": {"TestDifferentiableOptimizer": 0.25200000000000006, "TestLRScheduler": 1.3380000000000005, "TestOptim": 49.272, "TestOptimRenewedCPU": 56.233000000000025, "TestSWAUtils": 0.30600000000000005}, "test_out_dtype_op": {"TestOutDtypeOp": 0.501}, "test_overrides": {"TestBroadcastAllOverride": 0.003, "TestDisabledTorchFunction": 0.003, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.0045000000000000005, "TestGradCheckOverride": 0.025, "TestGradNewOnesOverride": 0.003, "TestIndexing": 0.0075, "TestIterator": 0.0015, "TestNamedTuple": 0.003, "TestPickle": 0.003, "TestRNN": 0.034, "TestResolveName": 0.133, "TestTorchFunctionMode": 0.04800000000000002, "TestTorchFunctionOverride": 2.6114999999998822, "TestTorchFunctionWarning": 0.0175, "TestWrapTorchFunction": 0.0015}, "test_package": {"DirectoryReaderTest": 0.05, "ModelTest": 0.0015, "TestAnalyze": 0.3745, "TestDependencyAPI": 0.06750000000000003, "TestDependencyHooks": 0.015, "TestDiGraph": 0.019500000000000003, "TestGlobGroup": 0.030500000000000006, "TestImporter": 0.0175, "TestLoadBCPackages": 0.108, "TestMangling": 0.028000000000000004, "TestMisc": 0.06500000000000002, "TestPackageFX": 0.09899999999999998, "TestPackageScript": 2.413999999999999, "TestRepackage": 0.012, "TestResources": 0.013500000000000002, "TestSaveLoad": 0.0445}, "test_per_overload_api": {"TestPerOverloadAPI": 0.43650000000000005}, "test_prims": {"TestDecompCPU": 0.1655, "TestPrimsBasic": 0.018000000000000002, "TestPrimsCPU": 0.10600000000000001, "TestRefsCPU": 0.015000000000000003}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.133, "TestGenericProxyTensorFake": 3.4079999999999995, "TestGenericProxyTensorReal": 4.3889999999999985, "TestGenericProxyTensorSymbolic": 22.652, "TestProxyTensorOpInfoCPU": 822.4280000000012, "TestRealProxyTensor": 0.02, "TestSymbolicTracing": 4.734}, "test_pruning_op": {"PruningOpTest": 0.6120000000000001}, "test_public_bindings": {"TestPublicBindings": 8.9485}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.0325, "TestPythonDispatch": 0.41500000000000015, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.2675, "TestWrapperSubclassAliasingCPU": 0.20850000000000007}, "test_pytree": {"TestCxxPytree": 0.024500000000000008, "TestGenericPytree": 0.5345000000000001, "TestPythonPytree": 0.08250000000000005}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.0165, "TestAOMigrationNNQuantized": 0.07250000000000001, "TestAOMigrationQuantization": 0.0235, "TestAOMigrationQuantizationFx": 0.026000000000000002, "TestBackendConfig": 0.063, "TestBiasCorrectionEager": 1.3925, "TestBits": 0.004, "TestBitsCPU": 0.07450000000000001, "TestComparatorOps": 1.564, "TestDeprecatedJitQuantized": 5.604, "TestDistributed": 0.0375, "TestDuplicateDQPass": 3.446, "TestDynamicQuantizedModule": 41.834500000000006, "TestDynamicQuantizedOps": 22.9565, "TestEqualizeEager": 0.1595, "TestEqualizeFx": 7.3695, "TestFXGraphMatcher": 1.597, "TestFXGraphMatcherModels": 14.367999999999999, "TestFXNumericSuiteCoreAPIs": 34.358000000000004, "TestFXNumericSuiteCoreAPIsModels": 41.433, "TestFXNumericSuiteNShadows": 49.1645, "TestFakeQuantize": 0.3095, "TestFakeQuantizeOps": 2.3289999999999997, "TestFloat8DtypeCPU": 0.10750000000000001, "TestFloat8DtypeCPUOnlyCPU": 0.765, "TestFuseEager": 2.8644999999999996, "TestFuseFx": 2.2845, "TestFusedObsFakeQuant": 0.1015, "TestFusedObsFakeQuantModule": 0.3895, "TestFusionPasses": 0.024, "TestFxDetectInputWeightEqualization": 0.21450000000000002, "TestFxDetectOutliers": 0.33, "TestFxModelReportClass": 0.6034999999999999, "TestFxModelReportDetectDynamicStatic": 0.10149999999999999, "TestFxModelReportDetector": 0.2555, "TestFxModelReportObserver": 0.26249999999999996, "TestFxModelReportVisualizer": 0.2405, "TestGenerateNumericDebugHandle": 0.8730000000000001, "TestGraphUtils": 2.153, "TestHistogramObserver": 41.626000000000005, "TestMetaDataPorting": 8.543, "TestModelNumericsEager": 2.0065, "TestNumericSuiteEager": 9.129999999999999, "TestObserver": 4.428, "TestPT2ERepresentation": 33.5775, "TestPadding": 25.9155, "TestQNNPackOps": 4.983499999999999, "TestQuantizationDocs": 0.0075, "TestQuantizeDynamicJitOps": 2.3914999999999997, "TestQuantizeDynamicJitPasses": 6.399, "TestQuantizeEagerOps": 1.8190000000000002, "TestQuantizeEagerPTQDynamic": 9.09, "TestQuantizeEagerPTQStatic": 28.714000000000002, "TestQuantizeEagerQAT": 10.928499999999998, "TestQuantizeEagerQATNumerics": 2.5885, "TestQuantizeFx": 54.94499999999999, "TestQuantizeFxModels": 7.3035000000000005, "TestQuantizeFxOps": 128.477, "TestQuantizeJit": 25.1505, "TestQuantizeJitOps": 293.8305, "TestQuantizeJitPasses": 6.2355, "TestQuantizePT2E": 59.102999999999994, "TestQuantizePT2EQAT": 263.31399999999996, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 395.384, "TestQuantizePT2EQAT_ConvBn2d": 400.29949999999997, "TestQuantizePT2EX86Inductor": 100.36149999999999, "TestQuantizedConv": 51.337999999999994, "TestQuantizedEmbeddingOps": 0.929, "TestQuantizedFunctionalOps": 2.336, "TestQuantizedLinear": 19.4795, "TestQuantizedOps": 110.6, "TestQuantizedTensor": 2.2334999999999994, "TestRecordHistogramObserver": 0.054000000000000006, "TestReferenceQuantizedModule": 0.065, "TestSerialization": 2.076, "TestStaticQuantizedModule": 61.096000000000004, "TestSubgraphRewriter": 1.1105, "TestUtils": 0.0235, "TestXNNPACKQuantizer": 49.123999999999995, "TestXNNPACKQuantizerModels": 4.179}, "test_reductions": {"TestReductionsCPU": 310.15400000000534}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 5.8145000000000024}, "test_schema_check": {"TestSchemaCheck": 0.1935000000000001, "TestSchemaCheckModeOpInfoCPU": 216.59199999999936}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.3875000000000004}, "test_serialization": {"TestBothSerializationCPU": 0.18, "TestOldSerialization": 34.44149999999999, "TestSerialization": 13.263000000000005, "TestSubclassSerialization": 0.03250000000000001}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.381}, "test_shape_ops": {"TestShapeOpsCPU": 1.3335000000000001}, "test_show_pickle": {"TestShowPickle": 0.393}, "test_sort_and_select": {"TestSortAndSelectCPU": 3.005499999999995}, "test_sparse": {"TestSparseAnyCPU": 646.8005000000005, "TestSparseCPU": 31.775499999999997, "TestSparseLegacyAndDeprecation": 0.068, "TestSparseMaskedReductionsCPU": 1.1960000000000006, "TestSparseMeta": 4.907000000000001, "TestSparseOneOff": 0.004, "TestSparseUnaryUfuncsCPU": 8.041499999999932}, "test_sparse_csr": {"TestSparseCSRCPU": 91.78750000000062, "TestSparseCSRSampler": 0.679, "TestSparseCompressedCPU": 101.8539999999993, "TestSparseCompressedTritonKernelsCPU": 0.0045000000000000005}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_spectral_ops": {"TestFFTCPU": 9.687999999999974, "TestFFTDocExamplesCPU": 0.08700000000000005}, "test_stateless": {"TestPythonOptimizeMode": 4.186999999999999, "TestStatelessDeprecation": 1.984, "TestStatelessFunctionalAPI": 0.2835000000000001}, "test_subclass": {"TestSubclass": 0.5965000000000003}, "test_sympy_utils": {"TestNumbers": 0.036000000000000004, "TestSingletonInt": 0.0075, "TestSympyInterp": 11.921, "TestSympySolve": 0.2375, "TestValueRanges": 8.181499999999996}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.7980000000000005, "TestBufferProtocolCPU": 0.5065000000000004, "TestLikeTensorCreationCPU": 0.013500000000000002, "TestRandomTensorCreationCPU": 3.8744999999999994, "TestTensorCreationCPU": 28.601500000000087}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0315, "TestTensorBoardFigure": 1.8255, "TestTensorBoardNumpy": 0.006500000000000001, "TestTensorBoardPyTorchNumpy": 0.43550000000000005, "TestTensorBoardPytorchGraph": 51.2805, "TestTensorBoardSummary": 0.06400000000000002, "TestTensorBoardSummaryWriter": 0.012, "TestTensorBoardUtils": 0.20800000000000002, "TestTensorBoardWriter": 0.134, "TestTensorProtoSummary": 0.015500000000000002}, "test_tensorexpr": {"TestTensorExprFuser": 68.04399999999997}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.012, "TestTensorExprPyBind": 1.2020000000000004}, "test_testing": {"TestAssertClose": 0.18800000000000008, "TestAssertCloseContainer": 0.009000000000000001, "TestAssertCloseErrorMessage": 0.07050000000000002, "TestAssertCloseQuantized": 0.015, "TestAssertCloseSparseBSC": 0.021, "TestAssertCloseSparseBSR": 0.021, "TestAssertCloseSparseCOO": 0.024, "TestAssertCloseSparseCSC": 0.02, "TestAssertCloseSparseCSR": 0.022, "TestFrameworkUtils": 16.061, "TestImports": 15.879499999999998, "TestMakeTensorCPU": 1.498000000000001, "TestOpInfoSampleFunctionsCPU": 5.533500000000043, "TestOpInfos": 0.0105, "TestTestParametrization": 0.042000000000000016, "TestTestParametrizationDeviceTypeCPU": 4.708999999999997, "TestTestingCPU": 0.30700000000000005}, "test_torch": {"TestBasicVitalSigns": 0.0465, "TestTorch": 4.846499999999993, "TestTorchDeviceTypeCPU": 13.995500000000092, "TestVitalSignsCudaCPU": 0.0015}, "test_transformers": {"TestAttnBiasCPU": 32.1475, "TestAttnMasksCPU": 33.078, "TestSDPACPU": 448.15849999999875, "TestSDPAFailureModesCPU": 0.021000000000000005, "TestTransformersCPU": 11.681000000000001}, "test_type_hints": {"TestTypeHints": 0.3825}, "test_type_info": {"TestDTypeInfo": 0.3695}, "test_type_promotion": {"TestTypePromotionCPU": 4.5419999999999785}, "test_typing": {"TestTyping": 99.74499999999999}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 482.38949999986335}, "test_utils": {"TestAssert": 0.0815, "TestBottleneck": 11.8875, "TestCheckpoint": 0.12750000000000003, "TestCollectEnv": 1.52, "TestCppExtensionUtils": 0.1185, "TestDataLoaderUtils": 0.1975, "TestDeviceUtilsCPU": 35.85500000000111, "TestExtensionUtils": 0.006500000000000001, "TestHipify": 0.0015, "TestHipifyTrie": 0.0105, "TestONNXUtils": 0.006500000000000001, "TestRenderUtils": 0.018000000000000002, "TestStandaloneCPPJIT": 3.225, "TestTraceback": 0.0165}, "test_view_ops": {"TestOldViewOpsCPU": 16.63400000000002, "TestViewOpsCPU": 1.0785000000000007, "TestViewOpsLAZY": 1.3270000000000004}, "test_vulkan": {"TestVulkanRewritePass": 0.0015}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.025500000000000002, "WeakKeyDictionaryTestCase": 0.0245, "WeakTest": 5.865499999999999}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 4.9425, "TestXNNPACKRewritePass": 1.7810000000000001, "TestXNNPACKSerDes": 5.3065}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.003}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.47950000000000004, "TestClassGetItem": 0.0005, "TestDtypeAttributeDeletion": 0.001, "TestFromDTypeAttribute": 0.003, "TestMisc": 0.0075, "TestPickling": 0.17300000000000001, "TestPromotion": 0.004}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 18.755000000000003, "TestEinsumPath": 0.0015, "TestMisc": 0.006}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.001, "TestFinfo": 0.003, "TestHalf": 0.006, "TestIinfo": 0.40700000000000003, "TestMisc": 0.005, "TestPythonFloat": 0.0015, "TestRepr": 0.003, "TestSingle": 0.001}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.004, "TestBooleanIndexing": 0.0105, "TestBroadcastedAssignments": 0.024, "TestFancyIndexingCast": 0.0045000000000000005, "TestFloatNonIntegerArgument": 0.013000000000000001, "TestIndexing": 0.5855000000000001, "TestMultiIndexingAutomated": 0.01, "TestMultipleEllipsisError": 0.004, "TestNonIntegerArrayLike": 0.0015}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.0245, "TestArgmax": 1.279500000000001, "TestArgmaxArgminCommon": 0.07900000000000004, "TestArgmin": 1.3210000000000008, "TestArrayAttributeDeletion": 0.008, "TestArrayConstruction": 0.047000000000000014, "TestArrayCreationCopyArgument": 0.004, "TestArrayInterface": 0.024, "TestAssignment": 0.012, "TestAttributes": 0.028500000000000004, "TestBinop": 0.021, "TestBool": 27.504000000000005, "TestCequenceMethods": 0.003, "TestChoose": 0.021000000000000005, "TestClip": 0.0075, "TestCompress": 0.0045000000000000005, "TestConversion": 0.038, "TestCreation": 0.003, "TestDelMisc": 0.0015, "TestDot": 0.08400000000000003, "TestDtypedescr": 0.0015, "TestFancyIndexing": 0.036000000000000004, "TestFlag": 0.019500000000000003, "TestFormat": 0.006, "TestFromBuffer": 0.015000000000000003, "TestHash": 0.3145, "TestHashing": 0.003, "TestIO": 0.0015, "TestInner": 0.2415, "TestLexsort": 0.022000000000000002, "TestMatmul": 0.48450000000000015, "TestMatmulOperator": 0.334, "TestMethods": 1.6570000000000007, "TestMinMax": 0.006500000000000001, "TestMinScalarType": 0.006500000000000001, "TestNewaxis": 0.0045000000000000005, "TestPEP3118Dtype": 0.0, "TestPutmask": 0.0145, "TestRepeat": 0.015, "TestResize": 0.052500000000000005, "TestRichcompareScalar": 0.0015, "TestScalarIndexing": 0.024, "TestSizeOf": 0.009000000000000001, "TestSortFloatMisc": 0.18050000000000008, "TestStats": 0.266, "TestSubscripting": 0.0015, "TestTake": 0.04200000000000001, "TestVdot": 0.04350000000000001, "TestViewDtype": 0.007, "TestWarnings": 0.002, "TestWhere": 0.40750000000000003, "TestWritebackIfCopy": 0.033}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.0285, "TestArgwhere": 0.033, "TestArrayComparisons": 0.028, "TestBaseRepr": 0.014, "TestBinaryRepr": 0.023, "TestBoolArray": 2.5239999999999996, "TestBoolCmp": 0.2005, "TestBoolScalar": 0.0115, "TestBroadcast": 0.0085, "TestClip": 0.2615000000000002, "TestConvolve": 0.020499999999999997, "TestCorrelate": 0.033, "TestCreationFuncs": 1.2075, "TestCross": 0.0595, "TestDtypePositional": 0.0015, "TestFloatExceptions": 0.0135, "TestFromiter": 0.0015, "TestIndex": 0.01, "TestIndices": 0.047, "TestIsclose": 0.10950000000000001, "TestIsscalar": 0.003, "TestLikeFuncs": 0.001, "TestMoveaxis": 0.011, "TestNonarrayArgs": 0.15000000000000008, "TestNonzeroAndCountNonzero": 0.3015000000000001, "TestOuterMisc": 0.006, "TestRequire": 0.007, "TestResize": 0.389, "TestRoll": 0.036000000000000004, "TestRollaxis": 0.006, "TestSeterr": 0.01, "TestStdVar": 0.035, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0015, "TestTensordot": 0.019000000000000003, "TestTypes": 0.020499999999999997}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0015, "TestCommonType": 0.3935, "TestDocStrings": 0.0, "TestIsSubDType": 0.009000000000000001, "TestScalarTypeNames": 0.031500000000000014}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.10000000000000007, "TestFromInt": 0.0095, "TestFromString": 0.375}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0025, "TestBitCount": 0.0, "TestClassGetItem": 0.004, "TestClassGetitemMisc": 0.4215, "TestIsInteger": 0.0015}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0015}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.12000000000000002, "TestBaseMath": 10.7855, "TestBitShifts": 0.11099999999999999, "TestComplexDivision": 0.0685, "TestConversion": 0.06150000000000001, "TestHash": 0.002, "TestModulus": 1.1789999999999998, "TestMultiply": 0.0, "TestNegative": 0.0225, "TestPower": 0.16100000000000003, "TestRepr": 0.0015, "TestScalarOpsMisc": 0.07200000000000004, "TestScalarSubclassingMisc": 0.06600000000000004, "TestSubtract": 0.0225, "TestTypes": 17.207}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.39, "TestAtleast2d": 0.0205, "TestAtleast3d": 0.018000000000000002, "TestBlock": 0.033500000000000016, "TestConcatenate": 0.20550000000000013, "TestHstack": 0.024, "TestStackMisc": 0.014500000000000006, "TestVstack": 0.0245}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.012, "TestFFTShift": 7.2780000000000005, "TestIRFFTN": 0.052000000000000005, "TestRFFTFreq": 0.012}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.5955000000000004, "TestFFTShift": 0.388, "TestFFTThreadSafe": 1.1265}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.3935}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.003, "TestUnique": 0.5840000000000001}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.009000000000000001, "TestAmax": 0.0075, "TestAmin": 0.0075, "TestAngle": 0.012, "TestAny": 0.009000000000000001, "TestAverage": 0.035, "TestBincount": 0.06199999999999999, "TestCheckFinite": 0.003, "TestCopy": 0.0105, "TestCorrCoef": 0.13650000000000004, "TestCov": 0.08450000000000002, "TestCumprod": 0.036000000000000004, "TestCumsum": 0.048, "TestDelete": 0.024, "TestDiff": 0.088, "TestDigitize": 0.022000000000000006, "TestExtins": 0.0075, "TestFilterwindows": 0.7590000000000006, "TestFlip": 0.04250000000000001, "TestGradient": 0.171, "TestInsert": 0.012, "TestInterp": 0.053500000000000034, "TestKaiser": 0.014, "TestMedian": 0.13500000000000004, "TestMeshgrid": 0.07350000000000002, "TestMsort": 0.0, "TestPercentile": 0.09300000000000003, "TestPiecewise": 0.0165, "TestProd": 0.036000000000000004, "TestPtp": 0.011, "TestQuantile": 0.027000000000000003, "TestRot90": 0.49, "TestSelect": 0.0115, "TestSinc": 0.0105, "TestSortComplex": 0.014, "TestTrapz": 0.0085, "TestTrimZeros": 0.014500000000000002, "TestUnique": 0.006, "Test_I0": 0.0175}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.5530000000000002, "TestHistogramOptimBinNums": 0.039500000000000014, "TestHistogramdd": 0.1965}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.002, "TestConcatenator": 0.011, "TestDiagIndices": 0.007, "TestDiagIndicesFrom": 0.011, "TestFillDiagonal": 0.037, "TestGrid": 0.015, "TestIndexExpression": 0.015500000000000002, "TestIx_": 0.011, "TestNdIndex": 0.002, "TestNdenumerate": 0.002, "TestRavelUnravelIndex": 0.42600000000000005}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.018000000000000006, "TestApplyOverAxes": 0.003, "TestArraySplit": 0.22950000000000004, "TestColumnStack": 0.014499999999999999, "TestDsplit": 0.012, "TestDstack": 0.023000000000000003, "TestExpandDims": 0.0115, "TestHsplit": 0.015500000000000002, "TestKron": 0.016, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.012, "TestSplit": 0.0105, "TestSqueeze": 0.03250000000000001, "TestTakeAlongAxis": 0.4455, "TestTile": 0.096, "TestVsplit": 0.0105}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.037500000000000006, "TestEye": 0.48500000000000004, "TestFliplr": 0.006500000000000001, "TestFlipud": 0.006, "TestHistogram2d": 0.04050000000000001, "TestTri": 0.114, "TestTrilIndicesFrom": 0.003, "TestTriuIndices": 0.005, "TestTriuIndicesFrom": 0.003, "TestVander": 0.021}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.0015, "TestCommonType": 0.3585, "TestImag": 0.015, "TestIscomplex": 0.0075, "TestIscomplexobj": 0.0045000000000000005, "TestIsfinite": 0.02, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.019500000000000003, "TestIsneginf": 0.003, "TestIsposinf": 0.003, "TestIsreal": 0.0105, "TestIsrealobj": 0.0015, "TestIsscalar": 0.002, "TestMintypecode": 0.006, "TestNanToNum": 0.018000000000000002, "TestReal": 0.0165, "TestRealIfClose": 0.0045000000000000005}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.1715, "TestCond": 0.25850000000000006, "TestDet": 0.18050000000000002, "TestEig": 0.047000000000000014, "TestEigh": 0.03350000000000001, "TestEighCases": 0.0, "TestEigvals": 0.07050000000000001, "TestEigvalsh": 0.027000000000000003, "TestEigvalshCases": 0.0, "TestInv": 0.06350000000000001, "TestLstsq": 0.26449999999999996, "TestMatrixRank": 0.473, "TestMisc": 0.023, "TestMisc2": 0.0045000000000000005, "TestMultiDot": 0.063, "TestNormDouble": 0.9295000000000001, "TestNormInt64": 0.9245000000000001, "TestNormSingle": 0.933, "TestNorm_NonSystematic": 0.0045000000000000005, "TestPinv": 0.1295, "TestPinvHermitian": 0.041, "TestQR": 0.4820000000000001, "TestSVD": 0.05700000000000001, "TestSVDHermitian": 0.11650000000000002, "TestSolve": 0.496, "TestTensorinv": 0.0245, "TestTensorsolve": 0.006500000000000001}, "torch_np/test_basic": {"TestArrayToSequence": 0.015, "TestCopyTo": 0.009000000000000001, "TestCtorNested": 0.0045000000000000005, "TestDefaultDtype": 0.009000000000000001, "TestDivmod": 0.018500000000000003, "TestExport": 0.0, "TestMisc": 0.003, "TestNormalizations": 0.006, "TestOneArr": 0.40000000000000024, "TestOneArrAndAxesTuple": 0.013500000000000002, "TestOneArrAndAxis": 0.20350000000000013, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.013500000000000002, "TestPythonArgsToArray": 0.020500000000000004, "TestSequenceOfArrays": 0.029000000000000005, "TestSequenceOfArraysToSingle": 0.0185, "TestShapeLikeToArray": 0.006, "TestSmokeNotImpl": 0.003}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5040000000000001}, "torch_np/test_dtype": {"TestConvertDType": 0.5130000000000001}, "torch_np/test_function_base": {"TestAppend": 0.3975}, "torch_np/test_ndarray_methods": {"TestAmax": 0.009000000000000001, "TestAmin": 0.009000000000000001, "TestArgmax": 1.1960000000000006, "TestArgmaxArgminCommon": 0.07250000000000004, "TestArgmin": 1.2950000000000008, "TestContains": 0.003, "TestIndexing": 0.3805, "TestIter": 0.006, "TestNoExtraMethods": 0.009000000000000001, "TestNonzero": 0.1655, "TestRavel": 0.009000000000000001, "TestReshape": 0.006, "TestTranspose": 0.0105}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.048000000000000015, "TestNEP50Table": 0.002}, "torch_np/test_random": {"TestChoice": 0.038, "TestNumpyGlobal": 0.0045000000000000005, "TestScalarReturn": 0.4025, "TestShuffle": 0.016500000000000004}, "torch_np/test_reductions": {"TestAll": 0.015, "TestAny": 0.015, "TestFlatnonzero": 0.3825, "TestGenericCumSumProd": 0.027000000000000003, "TestGenericReductions": 2.6684999999999324, "TestMean": 0.024, "TestSum": 0.257}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.41850000000000004, "TestIsScalar": 0.032000000000000015}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.8160000000000005, "TestNdarrayDunderVsUfunc": 0.2795000000000001, "TestUfuncDtypeKwd": 0.0075, "TestUnaryUfuncs": 0.42700000000000005}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5580000000000002}}}, "rocm5.7-py3.8-inductor": {"inductor": {"distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 5.5055, "TestMultiProc": 40.244, "TestSingleProc": 12.272499999999999}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 2.5465, "TestCollectivesMultiProc": 79.28049999999999}, "inductor/test_torchinductor": {"CudaTests": 484.742, "GPUTests": 507.43599999999964, "NanCheckerTest": 0.4185, "RNNTest": 0.6065, "SweepInputsCudaTest": 19.73833333333334, "SweepInputsGPUTest": 18.594, "TritonCodeGenTests": 16.298}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 1212.5229999999901}, "test_modules": {"TestModuleCUDA": 587.7499999999693}, "test_ops": {"TestCommonCUDA": 802.1899999995458, "TestCompositeComplianceCUDA": 524.7210000000052, "TestFakeTensorCUDA": 440.72349999999767, "TestMathBitsCUDA": 39.24250000000009, "TestSelfKwarg": 4.577500000000001, "TestTagsCUDA": 1.2814999999999837}, "test_ops_gradients": {"TestBwdGradientsCUDA": 851.9289999999404}, "test_torch": {"TestBasicVitalSigns": 0.41650000000000004, "TestDevicePrecisionCUDA": 15.600000000000001, "TestTorch": 130.79350000000014, "TestTorchDeviceTypeCUDA": 472.35799999999665, "TestVitalSignsCudaCUDA": 0.107}}}, "rocm6.0-py3.8-inductor": {"inductor": {"distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 8.043000000000001, "TestMultiProc": 60.83199999999999, "TestSingleProc": 23.695999999999998}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 5.742, "TestCollectivesMultiProc": 93.197}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 546.7909999999998, "AOTInductorTestABICompatibleCpuWithStackAllocation": 374.99199999999996, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 165.623, "AOTInductorTestABICompatibleCuda": 886.8079999999995, "AOTInductorTestNonABICompatibleCpu": 1136.3159999999987, "AOTInductorTestNonABICompatibleCuda": 1455.5619999999985}, "inductor/test_torchinductor": {"GPUTests": 1074.8179999999995, "NanCheckerTest": 1.633, "RNNTest": 0.587, "SweepInputsGPUTest": 71.34900000000002, "TritonCodeGenTests": 35.709999999999994}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 3775.0340000000156}, "test_modules": {"TestModuleCUDA": 1048.3729999999416}, "test_ops": {"TestCommonCUDA": 1272.8009999994788, "TestCompositeComplianceCUDA": 536.5219999999983, "TestFakeTensorCUDA": 582.8369999999943, "TestMathBitsCUDA": 80.3650000000003, "TestSelfKwarg": 1.552, "TestTagsCUDA": 2.011}, "test_ops_gradients": {"TestBwdGradientsCUDA": 891.1819999999655}, "test_torch": {"TestBasicVitalSigns": 0.633, "TestDevicePrecisionCUDA": 31.947000000000003, "TestTorch": 175.31300000000013, "TestTorchDeviceTypeCUDA": 1606.9459999999983, "TestVitalSignsCudaCUDA": 0.212}}}, "rocm6.1-py3.8-inductor": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": {"TestClipGradNormWorldSize4": 25.955}, "distributed/_composable/fsdp/test_fully_shard_comm": {"TestFullyShardBackwardPrefetch": 23.849, "TestFullyShardCollectiveOps": 57.561, "TestFullyShardCommunication": 38.8225, "TestFullyShardPrefetch": 70.0575, "TestFullyShardUnshardMultiProcess": 18.475, "TestFullyShardUnshardMultiThread": 0.033}, "distributed/_composable/fsdp/test_fully_shard_frozen": {"TestFullyShardFrozen": 70.587}, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": {"TestFullyShardMixedPrecisionTraining": 47.1465}, "distributed/_composable/fsdp/test_fully_shard_training": {"TestFullyShard1DTrainingCompose": 0.01, "TestFullyShard1DTrainingCore": 372.177, "TestFullyShard2DTraining": 0.02, "TestFullyShardGradientAccumulation": 54.164, "TestFullyShardHSDPTraining": 0.01}, "distributed/_tensor/test_dtensor_compile": {"TestDTensorCompile": 29.6155, "TestDTensorCompileE2E": 83.7125}, "distributed/fsdp/test_fsdp_tp_integration": {"TestTPFSDPIntegration": 56.487500000000004}, "distributed/tensor/parallel/test_fsdp_2d_parallel": {"TestNew2dParallelStateDict": 96.82650000000001, "TestNew2dParallelTraining": 68.831}, "distributed/test_c10d_functional_native": {"CompileTest": 118.4645, "TestWithNCCL": 56.5235}, "distributed/test_dynamo_distributed": {"TestFakeDistributedSingleProc": 9.058, "TestMultiProc": 132.14100000000002, "TestSingleProc": 34.287499999999994}, "distributed/test_inductor_collectives": {"TestCollectivesInductor": 3.8825000000000003, "TestCollectivesMultiProc": 186.52949999999998}, "inductor/test_aot_inductor": {"AOTInductorTestABICompatibleCpu": 660.0114999999994, "AOTInductorTestABICompatibleCpuWithStackAllocation": 468.5369999999998, "AOTInductorTestABICompatibleCpuWithStackAllocationAndMinimalArrayRefInterface": 209.82450000000009, "AOTInductorTestABICompatibleCuda": 1784.052, "AOTInductorTestNonABICompatibleCpu": 1538.4824999999987, "AOTInductorTestNonABICompatibleCuda": 2552.3765000000003}, "inductor/test_torchinductor": {"CpuTests": 1791.1754999999985, "GPUTests": 2348.785, "NanCheckerTest": 3.224, "RNNTest": 5.3725000000000005, "SweepInputsCpuTest": 107.507, "SweepInputsGPUTest": 71.26050000000001, "TestFull": 12.0655, "TritonCodeGenTests": 73.44550000000001}, "inductor/test_torchinductor_opinfo": {"TestInductorOpInfoCUDA": 34215.78650000017}, "test_modules": {"TestModuleCUDA": 2491.499000000026}, "test_ops": {"TestCommonCUDA": 1545.4849999994472, "TestCompositeComplianceCUDA": 1032.2609999999918, "TestFakeTensorCUDA": 656.6029999999953, "TestMathBitsCUDA": 93.93500000000043, "TestSelfKwarg": 0.8015, "TestTagsCUDA": 2.0419999999999963}, "test_ops_gradients": {"TestBwdGradientsCUDA": 1971.667999999885}, "test_torch": {"TestBasicVitalSigns": 0.136, "TestDevicePrecisionCUDA": 38.35350000000001, "TestTorch": 176.68100000000004, "TestTorchDeviceTypeCUDA": 2159.8870000000006, "TestVitalSignsCudaCUDA": 1.2679999999999998}}}, "win-vs2019-cpu-py3": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 0.002}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.644}, "distributions/test_constraints": {"test_constraints": 0.08950000000000007}, "distributions/test_distributions": {"TestAgainstScipy": 1.523, "TestConstraints": 0.17866666666666667, "TestDistributionShapes": 0.19700000000000015, "TestDistributions": 45.942666666666675, "TestFunctors": 0.017333333333333336, "TestJit": 12.113, "TestKL": 4.136333333333334, "TestLazyLogitsInitialization": 0.016666666666666666, "TestNumericalStability": 0.09566666666666668, "TestRsample": 0.8803333333333333, "TestValidation": 0.4706666666666668}, "export/test_converter": {"TestConverter": 7.006333333333335}, "export/test_db": {"ExampleTests": 0.007666666666666666}, "export/test_export": {"TestDynamismExpression": 0.7076666666666666, "TestExport": 0.0546666666666667, "TestExportCustomClass": 0.11299999999999999, "TestOneOffModelExportResult": 1.4426666666666665}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.36366666666666664}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 1.7043333333333333}, "export/test_hop": {"TestHOPCPU": 0.011666666666666672, "TestHOPGeneric": 0.006000000000000001}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.0026666666666666666, "TestLift": 0.11633333333333333, "TestLiftUnlift": 0.013666666666666667}, "export/test_pass_infra": {"TestPassInfra": 0.7643333333333332}, "export/test_passes": {"TestPasses": 15.373333333333333}, "export/test_safeguard": {"TestSafeguard": 1.4323333333333335}, "export/test_schema": {"TestSchema": 0.37399999999999994}, "export/test_serialize": {"TestDeserialize": 0.017666666666666674, "TestOpVersioning": 0.009000000000000001, "TestSaveLoad": 0.40099999999999997, "TestSchemaVersioning": 0.03833333333333333, "TestSerialize": 1.5763333333333334, "TestSerializeCustomClass": 0.166}, "export/test_sparse": {"TestSparseProp": 84.42266666666669}, "export/test_tools": {"TestExportTools": 0.6670000000000001}, "export/test_torchbind": {"TestCompileTorchbind": 1.4006666666666667, "TestExportTorchbind": 2.2196666666666665, "TestRegisterFakeClass": 0.004}, "export/test_tree_utils": {"TestTreeUtils": 0.3383333333333333}, "export/test_unflatten": {"TestUnflatten": 4.229333333333333}, "export/test_upgrade": {"TestUpgrade": 1.106333333333333}, "export/test_verifier": {"TestVerifier": 0.9596666666666667}, "functorch/test_aotdispatch": {"TestAOTAutograd": 14.952333333333334, "TestAOTAutogradWithDynamo": 16.59033333333333, "TestAOTDispatch": 0.6073333333333334, "TestAOTExport": 1.1603333333333334, "TestAOTModuleSimplified": 0.835, "TestEagerFusionModuleInfoCPU": 1081.3799999999999, "TestEagerFusionOpInfoCPU": 2725.386666666666, "TestPartitioning": 1.3943333333333332, "TestPythonKeyCPU": 0.5479999999999999}, "functorch/test_control_flow": {"TestControlFlow": 0.004666666666666666, "TestControlFlowTraced": 0.1466666666666667}, "functorch/test_dims": {"TestMin": 16.723333333333336, "TestMinFunctorchOnly": 16.244333333333334}, "functorch/test_eager_transforms": {"TestAutogradFunctionCPU": 0.1573333333333334, "TestAutogradFunctionVmapAPICPU": 0.038, "TestCompileTransformsCPU": 2.800333333333333, "TestComposabilityCPU": 2.3603333333333345, "TestExamplesCorrectnessCPU": 16.85366666666667, "TestFunctionalizeCPU": 0.20400000000000004, "TestGradTransformCPU": 0.7273333333333336, "TestHelpersCPU": 0.020666666666666667, "TestHessianCPU": 0.04733333333333333, "TestHigherOrderOperatorInteractionCPU": 0.04833333333333333, "TestJacCPU": 0.8143333333333337, "TestJvpCPU": 0.07666666666666667, "TestLinearizeCPU": 0.34733333333333327, "TestMakeFunctional": 0.13733333333333334, "TestSliceArgnums": 0.02666666666666667, "TestVmapJvpInplaceViewCPU": 0.02, "TestVmapOfGradCPU": 0.387}, "functorch/test_logging": {"TestAOTLogging": 0.43733333333333335}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.5706666666666668, "RandomOpTestCase": 0.09266666666666667, "ReduceTestCase": 0.11333333333333333, "TestMemoryEfficientOpAuthoring": 0.0026666666666666666}, "functorch/test_minifier": {"TestMinifier": 0.6010000000000001}, "functorch/test_ops": {"TestOperatorsCPU": 4050.8613333333547}, "functorch/test_parsing": {"TestAnonymousAxis": 0.35800000000000004, "TestParsedExpression": 0.008666666666666666, "TestParsingUtils": 0.011000000000000001, "TestValidateRearrangeExpressions": 0.009666666666666667}, "functorch/test_rearrange": {"TestRearrange": 0.45533333333333337}, "functorch/test_vmap": {"TestRandomnessCPU": 1.8379999999999974, "TestTransformFailureCPU": 0.14300000000000002, "TestVmapAPI": 0.38033333333333347, "TestVmapBatchedGradientCPU": 0.19233333333333344, "TestVmapDeviceTypeCPU": 0.02666666666666667, "TestVmapNestedTensorCPU": 0.06333333333333335, "TestVmapOperators": 3.4596666666666622, "TestVmapOperatorsOpInfoCPU": 575.1963333333316}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 4.421999999999834}, "higher_order_ops/test_with_effects": {"TestWithEffects": 0.8163333333333335}, "inductor/test_fx_fusion": {"TestFxFusion": 0.38566666666666677}, "lazy/test_debug_util": {"DebugUtilTest": 0.001}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.4703333333333333}, "lazy/test_generator": {"LazyGeneratorTest": 0.46166666666666667}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.0026666666666666666}, "lazy/test_step_closures": {"ClosuresTest": 2.408666666666667}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.3356666666666667, "TestLazyOpInfoCPU": 9.76799999999998, "TestLazyTensor": 0.07266666666666667}, "nn/test_convolution": {"TestConvolutionNN": 19.314999999999998, "TestConvolutionNNDeviceTypeCPU": 9.35399999999997}, "nn/test_dropout": {"TestDropoutNN": 0.081, "TestDropoutNNDeviceTypeCPU": 0.31066666666666665}, "nn/test_embedding": {"TestEmbeddingNN": 0.07900000000000003, "TestEmbeddingNNDeviceTypeCPU": 7.742999999999998}, "nn/test_init": {"TestNNInit": 179.18633333333332}, "nn/test_lazy_modules": {"TestLazyModules": 0.4613333333333336}, "nn/test_load_state_dict": {"TestLoadStateDict": 0.8333333333333334, "TestLoadStateDictSwap": 0.07766666666666668}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.03466666666666667, "TestModuleHookNN": 0.10000000000000002, "TestModuleHooks": 0.135, "TestStateDictHooks": 0.045000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 7.078666666666666, "TestMultiheadAttentionNNDeviceTypeCPU": 0.048999999999999995}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.6446666666666667}, "nn/test_parametrization": {"TestNNParametrization": 1.0549999999999997, "TestNNParametrizationDeviceCPU": 0.019}, "nn/test_pooling": {"TestAvgPool": 0.278, "TestPoolingNN": 0.4566666666666666, "TestPoolingNNDeviceTypeCPU": 43.073}, "nn/test_pruning": {"TestPruningNN": 0.1443333333333334}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.8443333333333332}, "profiler/test_memory_profiler": {"TestDataFlow": 1.3443333333333332, "TestIdentifyGradients": 0.239, "TestMemoryProfiler": 0.36166666666666664, "TestMemoryProfilerE2E": 4.926333333333333}, "profiler/test_profiler": {"TestExecutionTrace": 0.09066666666666667, "TestExperimentalUtils": 7.911333333333334, "TestProfiler": 14.290999999999997, "TestProfilerCUDA": 0.0016666666666666668, "TestProfilerITT": 0.006000000000000001, "TestRecordFunction": 0.07066666666666667, "TestTorchTidyProfiler": 4.747999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.49633333333333346}, "profiler/test_record_function": {"TestRecordFunction": 0.3980000000000001}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 4.206333333333332}, "test_ao_sparsity": {"TestActivationSparsifier": 0.09266666666666667, "TestBaseDataScheduler": 0.04766666666666667, "TestBaseDataSparsifier": 0.10433333333333333, "TestBaseSparsifier": 0.04833333333333333, "TestBaseStructuredSparsifier": 2.1796666666666664, "TestComposability": 2.6399999999999997, "TestCubicScheduler": 0.007, "TestFPGMPruner": 0.03733333333333333, "TestFakeSparsity": 0.13066666666666668, "TestFxComposability": 2.2776666666666667, "TestNearlyDiagonalSparsifier": 1.0683333333333334, "TestNormDataSparsifiers": 1.2053333333333331, "TestQuantizationUtils": 0.03233333333333333, "TestQuantizedSparseKernels": 0.36333333333333334, "TestQuantizedSparseLayers": 0.3419999999999999, "TestSaliencyPruner": 0.042666666666666665, "TestScheduler": 0.023000000000000003, "TestSparsityUtilFunctions": 0.063, "TestWeightNormSparsifier": 0.395}, "test_autocast": {"TestAutocastCPU": 1.4756666666666665, "TestAutocastGPU": 0.0013333333333333333, "TestTorchAutocast": 0.009666666666666669}, "test_autograd": {"TestAllowMutationOnSaved": 0.04633333333333332, "TestAutograd": 38.96233333333333, "TestAutogradComplex": 0.007333333333333333, "TestAutogradDeviceTypeCPU": 0.3960000000000002, "TestAutogradForwardMode": 0.13166666666666674, "TestAutogradForwardModeBatchedGrad": 0.02466666666666667, "TestAutogradFunctional": 12.164666666666664, "TestAutogradInferenceMode": 0.05933333333333335, "TestAutogradLogging": 0.02466666666666667, "TestAutogradMultipleDispatchCPU": 0.03333333333333333, "TestMultithreadAutograd": 0.2396666666666667, "TestNestedCheckpoint": 0.5296666666666666, "TestSelectiveActivationCheckpoint": 0.04633333333333334}, "test_autograd_fallback": {"TestAutogradFallback": 0.4666666666666668}, "test_binary_ufuncs": {"TestBinaryUfuncsCPU": 156.85000000000426}, "test_bundled_inputs": {"TestBundledInputs": 1.4639999999999997}, "test_comparison_utils": {"TestComparisonUtils": 0.38566666666666666}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.001}, "test_complex": {"TestComplexTensorCPU": 0.08}, "test_content_store": {"TestContentStoreCPU": 0.001}, "test_cpp_api_parity": {"TestCppApiParity": 5.859666666666683}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.033, "TestMAIATensor": 0.013666666666666669, "TestORTTensor": 0.6385000000000001, "TestPybindTypeCasters": 0.0030000000000000005, "TestRNGExtension": 0.004, "TestTorchLibrary": 0.001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.033, "TestMAIATensor": 0.014000000000000004, "TestORTTensor": 0.6425000000000001, "TestPybindTypeCasters": 0.0030000000000000005, "TestRNGExtension": 0.004, "TestTorchLibrary": 0.001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 230.43633333333335}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.005}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 16.373}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.001}, "test_custom_backend": {"TestCustomBackend": 0.10133333333333333}, "test_custom_ops": {"MiniOpTest": 0.9573333333333336, "MiniOpTestOther": 0.09266666666666669, "TestCustomOp": 19.152333333333363, "TestCustomOpAPI": 0.2113333333333334, "TestCustomOpTestingCPU": 0.02400000000000001, "TestCustomOperators": 0.20099999999999998, "TestGenerateOpcheckTests": 4.657333333333334}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 39.324999999999996, "TestConcatDataset": 0.019333333333333334, "TestConvAfterFork": 0.001, "TestCustomPinFn": 0.002, "TestDataLoader": 230.87033333333332, "TestDataLoaderDeviceTypeCPU": 0.001, "TestDataLoaderPersistentWorkers": 235.59066666666664, "TestDatasetRandomSplit": 0.04700000000000001, "TestDictDataLoader": 3.7756666666666665, "TestIndividualWorkerQueue": 0.0013333333333333333, "TestNamedTupleDataLoader": 0.004666666666666667, "TestSetAffinity": 0.001, "TestStackDataset": 0.03966666666666666, "TestStringDataLoader": 0.001, "TestTensorDataset": 0.028333333333333332}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.008333333333333333, "TestDataChunk": 0.009000000000000001, "TestDataFramesPipes": 0.006000000000000001, "TestFunctionalIterDataPipe": 4.627666666666666, "TestFunctionalMapDataPipe": 0.04766666666666667, "TestGraph": 0.024333333333333335, "TestIterDataPipeCountSampleYielded": 0.017, "TestIterDataPipeGraphFastForward": 0.050333333333333334, "TestIterDataPipeSingletonConstraint": 0.03, "TestIterableDataPipeBasic": 0.059, "TestSerialization": 0.002, "TestSharding": 7.7523333333333335, "TestStreamWrapper": 0.38733333333333336, "TestTyping": 0.010000000000000002}, "test_decomp": {"DecompOneOffTestsCPU": 1.079, "HasDecompTest": 0.2106666666666667, "TestDecompCPU": 7347.642666666667}, "test_deploy": {"TestFreezer": 0.36766666666666675}, "test_dispatch": {"TestDispatch": 53.249666666666656, "TestPythonDispatcher": 0.021}, "test_dlpack": {"TestTorchDlPackCPU": 0.34366666666666695}, "test_dynamic_shapes": {"TestDimConstraints": 2.5913333333333335, "TestFloorDiv": 0.02, "TestGuardsExpressions": 0.031, "TestPySymInt": 1.5109999999999992, "TestSymNumberMagicMethods": 2.3249999999999966}, "test_expanded_weights": {"TestExpandedWeightFunctionalCPU": 3.104999999999998, "TestExpandedWeightHelperFunctionCPU": 0.03166666666666667, "TestExpandedWeightModuleCPU": 7.6063333333333345}, "test_fake_tensor": {"FakeTensorConstHandling": 0.08900000000000002, "FakeTensorConverterTest": 0.036333333333333336, "FakeTensorDispatchCache": 0.10333333333333333, "FakeTensorOpInfoTestCPU": 0.18733333333333338, "FakeTensorOperatorInvariants": 0.5233333333333334, "FakeTensorPropTest": 0.09166666666666667, "FakeTensorSerialization": 0.009000000000000001, "FakeTensorTest": 0.8476666666666667, "PropagateRealTensorsFakeTensorConstHandling": 0.125, "PropagateRealTensorsFakeTensorConverterTest": 0.03566666666666667, "PropagateRealTensorsFakeTensorOpInfoTestCPU": 0.14400000000000002, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.25366666666666665, "PropagateRealTensorsFakeTensorPropTest": 0.06333333333333334, "PropagateRealTensorsFakeTensorTest": 0.309}, "test_flop_counter": {"TestFlopCounter": 0.16500000000000004}, "test_foreach": {"TestForeachCPU": 115.9670000000009}, "test_function_schema": {"TestFunctionSchema": 0.8620000000000001}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 0.002}, "test_functional_optim": {"TestFunctionalOptimParity": 0.458}, "test_functionalization": {"TestCrossRefFunctionalization": 2.537999999999999, "TestFunctionalization": 2.962333333333333}, "test_futures": {"TestFuture": 1.0306666666666666}, "test_fx": {"AnnotationsTest": 0.018666666666666668, "TestCSEPass": 0.36100000000000004, "TestCommonPass": 0.07933333333333333, "TestConstFold": 0.18866666666666668, "TestConstParamShapeInControlFlow": 0.04533333333333334, "TestDCE": 0.03333333333333333, "TestFX": 7.120666666666655, "TestFXAPIBackwardCompatibility": 0.02866666666666667, "TestFunctionalTracing": 0.44966666666666705, "TestMatcher": 0.081, "TestOperatorSignaturesCPU": 5.646666666666625, "TestPassManager": 0.027333333333333334, "TestSourceMatcher": 1.5456666666666667, "TestSubgraphRewriter": 0.28733333333333344, "TypeCheckerTest": 0.3133333333333334}, "test_fx_experimental": {"TestFXExperimental": 2.015666666666666, "TestNormalizeOperatorsCPU": 51.521333333333324, "TestTranslationValidation": 0.18233333333333332}, "test_fx_passes": {"TestFXGraphPasses": 0.7703333333333336, "TestFXMatcherUtils": 0.09833333333333337}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.5676666666666668}, "test_import_stats": {"TestImportTime": 4.796333333333333}, "test_indexing": {"NumpyTestsCPU": 0.07866666666666669, "TestIndexingCPU": 1.7226666666666637}, "test_itt": {"TestItt": 0.323}, "test_jit": {"TestAliasAnalysis": 0.4103333333333334, "TestAsync": 0.4076666666666668, "TestAtenPow": 0.013, "TestAutodiffJit": 0.10533333333333333, "TestAutodiffSubgraphSlicing": 0.33900000000000013, "TestAwait": 0.22833333333333336, "TestBackends": 0.0036666666666666666, "TestBackendsWithCompiler": 0.002, "TestBatchMM": 0.09333333333333334, "TestBuiltins": 0.07566666666666667, "TestClassType": 2.7999999999999994, "TestComplex": 0.9340000000000002, "TestCustomOperators": 0.056000000000000015, "TestDCE": 0.023333333333333334, "TestDataParallel": 0.005, "TestDataclasses": 5.371333333333333, "TestDeviceAnalysis": 0.14366666666666666, "TestDict": 0.4410000000000002, "TestDtypeAnalysis": 0.17900000000000002, "TestDtypeCustomRulesCPU": 4.076999999999998, "TestEnum": 0.21400000000000005, "TestFreezing": 2.5353333333333334, "TestFrontend": 0.4343333333333333, "TestFrozenOptimizations": 10.362333333333332, "TestFunctionalBlocks": 0.008333333333333333, "TestFunctionalToInplaceActivation": 0.11466666666666665, "TestGenerator": 0.09133333333333334, "TestGetDefaultAttr": 0.027333333333333334, "TestGraphRewritePasses": 0.065, "TestHash": 0.09499999999999999, "TestHooks": 0.7873333333333337, "TestIgnorableArgs": 0.014333333333333332, "TestIgnoreContextManager": 0.0030000000000000005, "TestInplaceToFunctionalActivation": 0.057666666666666665, "TestIsinstance": 0.2203333333333334, "TestJit": 7.097666666666665, "TestJitGeneratedModule": 14.180000000000035, "TestJitProfiler": 0.0013333333333333333, "TestJitUtils": 0.023000000000000007, "TestList": 1.2746666666666673, "TestLogging": 0.06366666666666666, "TestMKLDNNReinplacing": 0.218, "TestMisc": 0.18033333333333337, "TestMixTracingScripting": 1.4036666666666668, "TestModels": 1.8103333333333325, "TestModuleAPIs": 0.15233333333333332, "TestModuleContainers": 1.3416666666666668, "TestModuleInterface": 0.6126666666666668, "TestModules": 0.02033333333333333, "TestNamedTuple": 0.08033333333333335, "TestNnapiBackend": 0.030000000000000016, "TestOpDecompositions": 0.024000000000000004, "TestOptimizeForMobilePreserveDebugInfo": 0.2356666666666667, "TestParametrization": 0.13233333333333333, "TestPeephole": 0.4696666666666669, "TestProducerVersion": 0.002, "TestProfiler": 0.16200000000000003, "TestPythonBindings": 0.05000000000000001, "TestPythonBuiltinOP": 0.3860000000000001, "TestPythonIr": 0.032, "TestRecursiveScript": 0.7600000000000002, "TestRemoveMutation": 0.14333333333333334, "TestSaveLoad": 0.5953333333333335, "TestSaveLoadFlatbuffer": 0.5640000000000001, "TestSaveLoadForOpVersion": 1.8383333333333336, "TestScript": 40.09933333333337, "TestScriptDict": 0.033, "TestScriptList": 0.8210000000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.16866666666666671, "TestScriptProfile": 0.43166666666666664, "TestSlice": 0.20166666666666674, "TestSparse": 0.02866666666666667, "TestStringFormatting": 0.14800000000000002, "TestSymbolicShapeAnalysis": 1.6393333333333324, "TestTensorBuiltins": 0.085, "TestTensorCreationOps": 0.04866666666666667, "TestTensorMethods": 0.016, "TestTorchbind": 0.16633333333333336, "TestTracer": 3.1233333333333313, "TestTypeSharing": 0.5103333333333335, "TestTypesAndAnnotation": 0.13633333333333333, "TestTyping": 0.4206666666666669, "TestUnion": 0.48033333333333356, "TestUnsupportedOps": 0.039, "TestUpgraders": 0.07700000000000001, "TestWarn": 0.05666666666666667, "TestWith": 0.38433333333333336}, "test_jit_autocast": {"TestAutocast": 0.1536666666666667, "TestJitTraceAutocast": 11.449333333333334}, "test_jit_disabled": {"TestJitDisabled": 0.5946666666666666}, "test_jit_fuser_te": {"TestFuserCommon": 0.08833333333333333, "TestLoopnestRandomizationCPU": 0.001, "TestNNCOpInfoCPU": 38.71966666666578, "TestTEFuserDynamic": 166.17033333333347, "TestTEFuserStatic": 166.52133333333342}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.001, "TestEnableDisableLlgaFuser": 0.001, "TestFusionPatternCPU": 0.00966666666666667, "TestModel": 0.02733333333333335, "TestOpCPU": 0.010333333333333335}, "test_legacy_vmap": {"TestVmapAPI": 2.6749999999999994, "TestVmapAPILegacy": 1.4566666666666659, "TestVmapBatchedGradientCPU": 0.11600000000000003, "TestVmapBatchedGradientLegacyCPU": 0.12800000000000006, "TestVmapOperators": 1.2613333333333332, "TestVmapOperatorsLegacy": 1.4309999999999998}, "test_license": {"TestLicense": 0.002}, "test_linalg": {"TestLinalgCPU": 252.38499999999712}, "test_logging": {"LoggingTest": 2.9443333333333332}, "test_masked": {"TestMaskedCPU": 18.286333333333307}, "test_maskedtensor": {"TestBasicsCPU": 0.15733333333333335, "TestBinary": 0.6323333333333337, "TestOperatorsCPU": 9.43133333333329, "TestReductions": 0.10300000000000002, "TestUnary": 0.5673333333333338}, "test_meta": {"TestMetaCPU": 1896.5146666665732, "TestMetaConverter": 0.09633333333333334}, "test_mkl_verbose": {"TestMKLVerbose": 5.367}, "test_mkldnn": {"TestMkldnnCPU": 49.422333333333334}, "test_mkldnn_fusion": {"TestMkldnnFusion": 202.9023333333333}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 4.858666666666667}, "test_mobile_optimizer": {"TestOptimizer": 0.9803333333333333}, "test_model_dump": {"TestModelDump": 0.46966666666666673}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.001}, "test_module_init": {"TestModuleInitCPU": 2.7769999999999913}, "test_module_tracker": {"TestModuleTracker": 0.38033333333333336}, "test_modules": {"TestModuleCPU": 664.7283333333345}, "test_monitor": {"TestMonitor": 0.35200000000000004, "TestMonitorTensorboard": 0.6946666666666667}, "test_multiprocessing": {"TestMultiprocessing": 676.9986666666665}, "test_multiprocessing_spawn": {"ErrorTest": 0.0030000000000000005, "ForkTest": 0.0030000000000000005, "SpawnTest": 33.97533333333334}, "test_namedtensor": {"TestNamedTensor": 0.5013333333333336}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 2.2103333333333333}, "test_native_functions": {"TestNativeFunctions": 0.5120000000000001}, "test_native_mha": {"TestMHADeviceTypeCPU": 0.3663333333333334}, "test_nestedtensor": {"TestNestedTensor": 0.23533333333333348, "TestNestedTensorAutogradCPU": 0.9523333333333337, "TestNestedTensorDeviceTypeCPU": 1.0350000000000001, "TestNestedTensorSubclassCPU": 1.9486666666666645}, "test_nn": {"TestAddRelu": 0.006333333333333334, "TestConstantPadNd": 0.006000000000000001, "TestFunctionalPickle": 0.002, "TestFusionEval": 0.37266666666666665, "TestFusionUtils": 0.006000000000000001, "TestNN": 52.078, "TestNNDeviceTypeCPU": 151.17566666666653, "TestUtils": 0.004}, "test_numba_integration": {"TestNumbaIntegration": 0.008}, "test_numpy_interop": {"TestNumPyInteropCPU": 0.2686666666666668}, "test_openmp": {"TestOpenMP_ParallelFor": 4.908666666666667}, "test_ops": {"TestCommonCPU": 1512.6483333332617, "TestCompositeComplianceCPU": 923.3713333333299, "TestFakeTensorCPU": 379.4246666666647, "TestMathBitsCPU": 62.770666666666635, "TestRefsOpsInfoCPU": 2.2639999999999953, "TestSelfKwarg": 0.007, "TestTagsCPU": 18.1643333333333}, "test_ops_fwd_gradients": {"TestFwdGradientsCPU": 802.0413333333187}, "test_ops_gradients": {"TestBwdGradientsCPU": 1471.626333333348}, "test_ops_jit": {"TestJitCPU": 1281.017999999998}, "test_optim": {"TestDifferentiableOptimizer": 0.21999999999999997, "TestLRScheduler": 1.2813333333333319, "TestOptim": 66.47550000000001, "TestOptimRenewedCPU": 50.3680000000001, "TestSWAUtils": 0.19466666666666665}, "test_out_dtype_op": {"TestOutDtypeOp": 0.32866666666666666}, "test_overrides": {"TestBroadcastAllOverride": 0.0030000000000000005, "TestDisabledTorchFunction": 0.0026666666666666666, "TestDisabledUserWarnings": 0.0026666666666666666, "TestEinsumOverride": 0.004333333333333334, "TestGradCheckOverride": 0.021333333333333333, "TestGradNewOnesOverride": 0.0026666666666666666, "TestIndexing": 0.011666666666666667, "TestIterator": 0.002, "TestNamedTuple": 0.0030000000000000005, "TestPickle": 0.0030000000000000005, "TestRNN": 0.004, "TestResolveName": 0.10433333333333333, "TestTorchFunctionMode": 0.0556666666666667, "TestTorchFunctionOverride": 3.289999999999875, "TestTorchFunctionWarning": 0.013666666666666667, "TestWrapTorchFunction": 0.002}, "test_package": {"DirectoryReaderTest": 0.008, "ModelTest": 0.0030000000000000005, "TestAnalyze": 0.3383333333333334, "TestDependencyAPI": 0.07666666666666669, "TestDependencyHooks": 0.015, "TestDiGraph": 0.030333333333333334, "TestGlobGroup": 0.04000000000000001, "TestImporter": 0.018, "TestLoadBCPackages": 0.07266666666666667, "TestMangling": 0.028666666666666663, "TestMisc": 0.05866666666666668, "TestPackageFX": 0.079, "TestPackageScript": 0.4006666666666668, "TestRepackage": 0.012666666666666666, "TestResources": 0.018, "TestSaveLoad": 0.05133333333333334}, "test_per_overload_api": {"TestPerOverloadAPI": 0.37566666666666665}, "test_prims": {"TestDecompCPU": 0.19266666666666668, "TestPrimsBasic": 0.017666666666666667, "TestPrimsCPU": 0.10533333333333335, "TestRefsCPU": 0.018666666666666668}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.11233333333333334, "TestGenericProxyTensorFake": 0.6463333333333336, "TestGenericProxyTensorReal": 0.5430000000000001, "TestGenericProxyTensorSymbolic": 0.8653333333333336, "TestProxyTensorOpInfoCPU": 848.6283333333237, "TestRealProxyTensor": 0.021666666666666667, "TestSymbolicTracing": 2.3773333333333326}, "test_pruning_op": {"PruningOpTest": 0.584}, "test_public_bindings": {"TestPublicBindings": 0.4076666666666666}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.006000000000000001, "TestPythonDispatch": 5.185, "TestPythonDispatcher": 0.009000000000000001, "TestPythonRegistration": 0.232, "TestWrapperSubclassAliasingCPU": 0.21433333333333338}, "test_pytree": {"TestCxxPytree": 0.015000000000000006, "TestGenericPytree": 0.48900000000000016, "TestPythonPytree": 0.08966666666666671}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.025000000000000005, "TestAOMigrationNNQuantized": 0.052, "TestAOMigrationQuantization": 0.03233333333333333, "TestAOMigrationQuantizationFx": 0.03766666666666666, "TestBackendConfig": 0.08166666666666668, "TestBiasCorrectionEager": 1.0926666666666667, "TestBits": 0.005666666666666667, "TestBitsCPU": 0.07400000000000001, "TestComparatorOps": 1.538, "TestDeprecatedJitQuantized": 5.175666666666666, "TestDistributed": 0.037666666666666675, "TestDuplicateDQPass": 0.004333333333333334, "TestDynamicQuantizedModule": 17.107666666666667, "TestDynamicQuantizedOps": 6.718000000000001, "TestEqualizeEager": 0.11633333333333333, "TestEqualizeFx": 5.5520000000000005, "TestFXGraphMatcher": 2.1803333333333335, "TestFXGraphMatcherModels": 0.002, "TestFXNumericSuiteCoreAPIs": 38.58666666666667, "TestFXNumericSuiteCoreAPIsModels": 28.242, "TestFXNumericSuiteNShadows": 0.024333333333333346, "TestFakeQuantize": 0.3216666666666667, "TestFakeQuantizeOps": 2.59, "TestFloat8DtypeCPU": 0.15200000000000005, "TestFloat8DtypeCPUOnlyCPU": 0.012333333333333335, "TestFuseEager": 2.721, "TestFuseFx": 2.9120000000000004, "TestFusedObsFakeQuant": 0.11033333333333334, "TestFusedObsFakeQuantModule": 0.237, "TestFusionPasses": 0.03133333333333333, "TestFxDetectInputWeightEqualization": 0.228, "TestFxDetectOutliers": 0.6766666666666666, "TestFxModelReportClass": 0.6960000000000001, "TestFxModelReportDetectDynamicStatic": 0.08600000000000001, "TestFxModelReportDetector": 0.09466666666666668, "TestFxModelReportObserver": 0.2803333333333333, "TestFxModelReportVisualizer": 0.3433333333333333, "TestGenerateNumericDebugHandle": 0.002, "TestGraphUtils": 0.0033333333333333335, "TestHistogramObserver": 55.044999999999995, "TestMetaDataPorting": 0.007333333333333333, "TestModelNumericsEager": 0.7096666666666667, "TestNumericSuiteEager": 5.596999999999999, "TestObserver": 5.236666666666667, "TestPT2ERepresentation": 0.008333333333333333, "TestPadding": 12.488, "TestQNNPackOps": 0.012000000000000002, "TestQuantizationDocs": 0.412, "TestQuantizeDynamicJitOps": 2.3976666666666664, "TestQuantizeDynamicJitPasses": 4.522666666666667, "TestQuantizeEagerOps": 1.9796666666666665, "TestQuantizeEagerPTQDynamic": 10.761666666666665, "TestQuantizeEagerPTQStatic": 20.64833333333333, "TestQuantizeEagerQAT": 6.126333333333332, "TestQuantizeEagerQATNumerics": 2.230333333333333, "TestQuantizeFx": 38.713666666666676, "TestQuantizeFxModels": 3.808666666666666, "TestQuantizeFxOps": 138.121, "TestQuantizeJit": 17.68433333333333, "TestQuantizeJitOps": 206.47966666666665, "TestQuantizeJitPasses": 9.107, "TestQuantizePT2E": 0.041666666666666685, "TestQuantizePT2EQAT": 0.014000000000000004, "TestQuantizePT2EQATModels": 0.002, "TestQuantizePT2EQAT_ConvBn1d": 0.01766666666666667, "TestQuantizePT2EQAT_ConvBn2d": 0.017000000000000005, "TestQuantizePT2EX86Inductor": 0.03833333333333335, "TestQuantizedConv": 22.105333333333334, "TestQuantizedEmbeddingOps": 0.9713333333333333, "TestQuantizedFunctionalOps": 0.7530000000000001, "TestQuantizedLinear": 16.73966666666667, "TestQuantizedOps": 144.732, "TestQuantizedTensor": 2.4499999999999997, "TestRecordHistogramObserver": 0.043333333333333335, "TestReferenceQuantizedModule": 0.06266666666666666, "TestSerialization": 1.4346666666666668, "TestStaticQuantizedModule": 76.68333333333334, "TestSubgraphRewriter": 1.289, "TestUtils": 0.035, "TestXNNPACKQuantizer": 0.025000000000000012, "TestXNNPACKQuantizerModels": 0.001}, "test_reductions": {"TestReductionsCPU": 279.7903333333151}, "test_scatter_gather_ops": {"TestScatterGatherCPU": 6.9529999999999985}, "test_schema_check": {"TestSchemaCheck": 0.18366666666666676, "TestSchemaCheckModeOpInfoCPU": 226.96866666666372}, "test_segment_reductions": {"TestSegmentReductionsCPU": 1.1850000000000003}, "test_serialization": {"TestBothSerializationCPU": 0.001, "TestOldSerialization": 124.65800000000006, "TestSerialization": 9.503333333333329, "TestSubclassSerialization": 0.03366666666666667}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.3706666666666667}, "test_shape_ops": {"TestShapeOpsCPU": 1.2313333333333325}, "test_show_pickle": {"TestShowPickle": 0.001}, "test_sort_and_select": {"TestSortAndSelectCPU": 2.8219999999999956}, "test_sparse": {"TestSparseAnyCPU": 685.981333333333, "TestSparseCPU": 29.34566666666667, "TestSparseLegacyAndDeprecation": 0.033, "TestSparseMaskedReductionsCPU": 1.765666666666667, "TestSparseMeta": 5.016333333333333, "TestSparseOneOff": 0.002, "TestSparseUnaryUfuncsCPU": 16.325999999999965}, "test_sparse_csr": {"TestSparseCSRCPU": 86.7060000000011, "TestSparseCSRSampler": 0.5603333333333333, "TestSparseCompressedCPU": 112.9593333333334, "TestSparseCompressedTritonKernelsCPU": 0.010000000000000002}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0030000000000000005}, "test_spectral_ops": {"TestFFTCPU": 22.259333333333334, "TestFFTDocExamplesCPU": 0.11900000000000004}, "test_stateless": {"TestPythonOptimizeMode": 7.338666666666666, "TestStatelessDeprecation": 2.034333333333333, "TestStatelessFunctionalAPI": 0.2766666666666668}, "test_subclass": {"TestSubclass": 0.6216666666666669}, "test_sympy_utils": {"TestNumbers": 0.059666666666666666, "TestSingletonInt": 0.006666666666666667, "TestSympyInterp": 10.706000000000001, "TestSympySolve": 0.3500000000000001, "TestValueRanges": 7.7906666666666675}, "test_tensor_creation_ops": {"TestAsArrayCPU": 0.757333333333334, "TestBufferProtocolCPU": 0.5263333333333337, "TestLikeTensorCreationCPU": 0.016333333333333335, "TestRandomTensorCreationCPU": 3.1069999999999998, "TestTensorCreationCPU": 27.656999999999986}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.024333333333333335, "TestTensorBoardFigure": 0.002, "TestTensorBoardNumpy": 0.0033333333333333335, "TestTensorBoardPyTorchNumpy": 0.35800000000000004, "TestTensorBoardPytorchGraph": 0.37599999999999995, "TestTensorBoardSummary": 0.06233333333333335, "TestTensorBoardSummaryWriter": 0.014666666666666668, "TestTensorBoardUtils": 0.227, "TestTensorBoardWriter": 0.33266666666666667, "TestTensorProtoSummary": 0.019666666666666666}, "test_tensorexpr": {"TestTensorExprFuser": 29.93466666666667}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.015, "TestTensorExprPyBind": 0.38933333333333336}, "test_testing": {"TestAssertClose": 0.2656666666666668, "TestAssertCloseContainer": 0.013333333333333334, "TestAssertCloseErrorMessage": 0.08300000000000002, "TestAssertCloseQuantized": 0.02066666666666667, "TestAssertCloseSparseBSC": 0.02766666666666667, "TestAssertCloseSparseBSR": 0.02766666666666667, "TestAssertCloseSparseCOO": 0.033, "TestAssertCloseSparseCSC": 0.029666666666666664, "TestAssertCloseSparseCSR": 0.030333333333333334, "TestFrameworkUtils": 0.001, "TestImports": 7.2470000000000026, "TestMakeTensorCPU": 2.349999999999986, "TestOpInfoSampleFunctionsCPU": 14.190333333333337, "TestOpInfos": 0.006666666666666667, "TestTestParametrization": 0.0696666666666667, "TestTestParametrizationDeviceTypeCPU": 5.089999999999999, "TestTestingCPU": 0.4080000000000001}, "test_torch": {"TestBasicVitalSigns": 0.01833333333333333, "TestTorch": 4.879999999999988, "TestTorchDeviceTypeCPU": 15.087333333333385, "TestVitalSignsCudaCPU": 0.0023333333333333335}, "test_transformers": {"TestAttnBiasCPU": 7.2150000000000025, "TestAttnMasksCPU": 32.75566666666668, "TestSDPACPU": 384.7086666666658, "TestSDPAFailureModesCPU": 0.05833333333333337, "TestTransformersCPU": 9.273333333333333}, "test_type_hints": {"TestTypeHints": 0.001}, "test_type_info": {"TestDTypeInfo": 0.34600000000000003}, "test_type_promotion": {"TestTypePromotionCPU": 4.309333333333316}, "test_typing": {"TestTyping": 0.0030000000000000005}, "test_unary_ufuncs": {"TestUnaryUfuncsCPU": 553.5973333331557}, "test_utils": {"TestAssert": 0.07466666666666667, "TestBottleneck": 19.086000000000002, "TestCheckpoint": 0.09200000000000003, "TestCollectEnv": 4.041333333333333, "TestCppExtensionUtils": 0.004666666666666667, "TestDataLoaderUtils": 18.132666666666665, "TestDeviceUtilsCPU": 59.51266666666728, "TestExtensionUtils": 0.006000000000000001, "TestHipify": 0.0023333333333333335, "TestHipifyTrie": 0.008, "TestONNXUtils": 0.006000000000000001, "TestRenderUtils": 0.015, "TestStandaloneCPPJIT": 13.542333333333334, "TestTraceback": 0.014333333333333332}, "test_view_ops": {"TestOldViewOpsCPU": 14.817333333333332, "TestViewOpsCPU": 0.9740000000000005, "TestViewOpsLAZY": 0.871666666666667}, "test_vulkan": {"TestVulkanRewritePass": 0.001}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.022000000000000002, "WeakKeyDictionaryTestCase": 0.037333333333333336, "WeakTest": 4.215}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 34.99566666666667, "TestXNNPACKOps": 3.314666666666666, "TestXNNPACKRewritePass": 1.6053333333333333, "TestXNNPACKSerDes": 4.25}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.03200000000000002}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.4103333333333334, "TestClassGetItem": 0.007666666666666669, "TestDtypeAttributeDeletion": 0.0013333333333333333, "TestFromDTypeAttribute": 0.0033333333333333335, "TestMisc": 0.005666666666666667, "TestPickling": 0.1386666666666667, "TestPromotion": 0.017666666666666674}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 16.144666666666666, "TestEinsumPath": 0.0036666666666666666, "TestMisc": 0.007333333333333333}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0003333333333333333, "TestFinfo": 0.002, "TestHalf": 0.001, "TestIinfo": 0.39733333333333337, "TestMisc": 0.006000000000000001, "TestPythonFloat": 0.001, "TestRepr": 0.005333333333333333, "TestSingle": 0.001}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.004, "TestBooleanIndexing": 0.011333333333333334, "TestBroadcastedAssignments": 0.03133333333333333, "TestFancyIndexingCast": 0.005666666666666667, "TestFloatNonIntegerArgument": 0.017333333333333336, "TestIndexing": 0.6296666666666669, "TestMultiIndexingAutomated": 0.013666666666666667, "TestMultipleEllipsisError": 0.0036666666666666666, "TestNonIntegerArrayLike": 0.001}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.037000000000000005, "TestArgmax": 1.417666666666667, "TestArgmaxArgminCommon": 0.2163333333333335, "TestArgmin": 1.4203333333333337, "TestArrayAttributeDeletion": 0.013666666666666666, "TestArrayConstruction": 0.052666666666666674, "TestArrayCreationCopyArgument": 0.02300000000000001, "TestArrayInterface": 0.03, "TestAssignment": 0.014333333333333337, "TestAttributes": 0.02166666666666667, "TestBinop": 0.021333333333333333, "TestBool": 27.01433333333333, "TestCequenceMethods": 0.0033333333333333335, "TestChoose": 0.02566666666666667, "TestClip": 0.010333333333333333, "TestCompress": 0.010666666666666666, "TestConversion": 0.04900000000000001, "TestCreation": 0.016333333333333342, "TestDelMisc": 0.0036666666666666666, "TestDot": 0.11300000000000004, "TestDtypedescr": 0.0023333333333333335, "TestFancyIndexing": 0.036, "TestFlag": 0.016000000000000004, "TestFormat": 0.011000000000000001, "TestFromBuffer": 0.025333333333333336, "TestHash": 0.27699999999999997, "TestHashing": 0.007333333333333333, "TestIO": 0.03400000000000002, "TestInner": 0.2356666666666667, "TestLexsort": 0.039, "TestMatmul": 0.5600000000000002, "TestMatmulOperator": 0.3333333333333333, "TestMethods": 1.7266666666666666, "TestMinMax": 0.009000000000000001, "TestMinScalarType": 0.012666666666666668, "TestNewaxis": 0.006333333333333333, "TestPEP3118Dtype": 0.007666666666666668, "TestPutmask": 0.023666666666666666, "TestRepeat": 0.017333333333333336, "TestResize": 0.058, "TestRichcompareScalar": 0.001, "TestScalarIndexing": 0.021333333333333333, "TestSizeOf": 0.018000000000000002, "TestSortFloatMisc": 0.20500000000000007, "TestStats": 0.3223333333333333, "TestSubscripting": 0.0033333333333333335, "TestTake": 0.04933333333333334, "TestVdot": 0.052666666666666674, "TestViewDtype": 0.012000000000000002, "TestWarnings": 0.0036666666666666666, "TestWhere": 0.524, "TestWritebackIfCopy": 0.04733333333333334}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.02466666666666667, "TestArgwhere": 0.04066666666666666, "TestArrayComparisons": 0.019, "TestBaseRepr": 0.011333333333333334, "TestBinaryRepr": 0.016, "TestBoolArray": 2.789, "TestBoolCmp": 0.20666666666666667, "TestBoolScalar": 0.015, "TestBroadcast": 0.011333333333333334, "TestClip": 0.2640000000000002, "TestConvolve": 0.026333333333333334, "TestCorrelate": 0.043666666666666666, "TestCreationFuncs": 1.184, "TestCross": 0.05633333333333334, "TestDtypePositional": 0.0036666666666666666, "TestFloatExceptions": 0.017, "TestFromiter": 0.002, "TestIndex": 0.009, "TestIndices": 0.055333333333333325, "TestIsclose": 0.08666666666666668, "TestIsscalar": 0.0030000000000000005, "TestLikeFuncs": 0.005333333333333335, "TestMoveaxis": 0.016, "TestNonarrayArgs": 0.17500000000000007, "TestNonzeroAndCountNonzero": 0.276, "TestOuterMisc": 0.006333333333333333, "TestRequire": 0.010333333333333333, "TestResize": 0.37966666666666665, "TestRoll": 0.04033333333333333, "TestRollaxis": 0.006666666666666667, "TestSeterr": 0.011666666666666667, "TestStdVar": 0.031, "TestStdVarComplex": 0.013, "TestStringFunction": 0.0036666666666666666, "TestTensordot": 0.02, "TestTypes": 0.022000000000000002}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.0026666666666666666, "TestCommonType": 0.4143333333333333, "TestDocStrings": 0.001, "TestIsSubDType": 0.016333333333333335, "TestScalarTypeNames": 0.059333333333333356}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.18333333333333346, "TestFromInt": 0.010666666666666666, "TestFromString": 0.38833333333333336}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.006666666666666667, "TestBitCount": 0.0030000000000000005, "TestClassGetItem": 0.005333333333333333, "TestClassGetitemMisc": 0.0030000000000000005, "TestIsInteger": 0.0030000000000000005}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0026666666666666666}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.12466666666666666, "TestBaseMath": 10.059, "TestBitShifts": 0.11166666666666669, "TestComplexDivision": 0.066, "TestConversion": 0.059, "TestHash": 0.006333333333333334, "TestModulus": 1.0730000000000002, "TestMultiply": 0.0013333333333333333, "TestNegative": 0.027, "TestPower": 0.134, "TestRepr": 0.0023333333333333335, "TestScalarOpsMisc": 0.09466666666666672, "TestScalarSubclassingMisc": 0.07866666666666672, "TestSubtract": 0.023333333333333334, "TestTypes": 16.282333333333334}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.37433333333333335, "TestAtleast2d": 0.019000000000000003, "TestAtleast3d": 0.02, "TestBlock": 0.043333333333333356, "TestConcatenate": 0.19033333333333347, "TestHstack": 0.027, "TestStackMisc": 0.021666666666666678, "TestVstack": 0.03000000000000001}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.013666666666666666, "TestFFTShift": 6.550999999999999, "TestIRFFTN": 0.006000000000000001, "TestRFFTFreq": 0.012999999999999998}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 3.4466666666666668, "TestFFTShift": 0.35766666666666663, "TestFFTThreadSafe": 0.7513333333333335}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.38133333333333336}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.027000000000000014, "TestUnique": 0.5763333333333334}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.01, "TestAmax": 0.008666666666666668, "TestAmin": 0.008666666666666666, "TestAngle": 0.008, "TestAny": 0.010666666666666666, "TestAverage": 0.03133333333333333, "TestBincount": 0.051666666666666666, "TestCheckFinite": 0.004, "TestCopy": 0.01, "TestCorrCoef": 0.043666666666666666, "TestCov": 0.07300000000000001, "TestCumprod": 0.04666666666666666, "TestCumsum": 0.05633333333333334, "TestDelete": 0.02, "TestDiff": 0.10999999999999999, "TestDigitize": 0.026, "TestExtins": 0.008333333333333333, "TestFilterwindows": 0.6576666666666672, "TestFlip": 0.04866666666666667, "TestGradient": 0.15100000000000002, "TestInsert": 0.018000000000000002, "TestInterp": 0.07800000000000004, "TestKaiser": 0.011333333333333334, "TestMedian": 0.12300000000000001, "TestMeshgrid": 0.059666666666666666, "TestMsort": 0.001, "TestPercentile": 0.20233333333333348, "TestPiecewise": 0.016666666666666666, "TestProd": 0.03333333333333333, "TestPtp": 0.012333333333333333, "TestQuantile": 0.08466666666666668, "TestRot90": 0.38166666666666665, "TestSelect": 0.014, "TestSinc": 0.009333333333333334, "TestSortComplex": 0.018666666666666665, "TestTrapz": 0.007666666666666666, "TestTrimZeros": 0.017, "TestUnique": 0.005666666666666667, "Test_I0": 0.015}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.46833333333333343, "TestHistogramOptimBinNums": 0.04600000000000001, "TestHistogramdd": 0.17533333333333334}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.0023333333333333335, "TestConcatenator": 0.015333333333333332, "TestDiagIndices": 0.006000000000000001, "TestDiagIndicesFrom": 0.010333333333333333, "TestFillDiagonal": 0.03366666666666667, "TestGrid": 0.020666666666666667, "TestIndexExpression": 0.013333333333333334, "TestIx_": 0.011666666666666667, "TestNdIndex": 0.0023333333333333335, "TestNdenumerate": 0.0023333333333333335, "TestRavelUnravelIndex": 0.4120000000000001}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.021000000000000005, "TestApplyOverAxes": 0.0033333333333333335, "TestArraySplit": 0.17966666666666672, "TestColumnStack": 0.017666666666666667, "TestDsplit": 0.015, "TestDstack": 0.028, "TestExpandDims": 0.01, "TestHsplit": 0.018333333333333333, "TestKron": 0.02333333333333334, "TestMayShareMemory": 0.0030000000000000005, "TestPutAlongAxis": 0.011000000000000001, "TestSplit": 0.009666666666666665, "TestSqueeze": 0.043333333333333335, "TestTakeAlongAxis": 0.3826666666666667, "TestTile": 0.08700000000000001, "TestVsplit": 0.013666666666666667}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.033, "TestEye": 0.3823333333333334, "TestFliplr": 0.006000000000000001, "TestFlipud": 0.006000000000000001, "TestHistogram2d": 0.04533333333333334, "TestTri": 0.12633333333333333, "TestTrilIndicesFrom": 0.004, "TestTriuIndices": 0.005333333333333333, "TestTriuIndicesFrom": 0.004, "TestVander": 0.026999999999999996}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.002, "TestCommonType": 0.36599999999999994, "TestImag": 0.015, "TestIscomplex": 0.007666666666666666, "TestIscomplexobj": 0.008666666666666668, "TestIsfinite": 0.024999999999999998, "TestIsinf": 0.020666666666666667, "TestIsnan": 0.024333333333333335, "TestIsneginf": 0.0030000000000000005, "TestIsposinf": 0.0033333333333333335, "TestIsreal": 0.012333333333333335, "TestIsrealobj": 0.0030000000000000005, "TestIsscalar": 0.0030000000000000005, "TestMintypecode": 0.008666666666666666, "TestNanToNum": 0.019333333333333338, "TestReal": 0.016999999999999998, "TestRealIfClose": 0.005}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.21166666666666667, "TestCond": 0.25733333333333336, "TestDet": 0.19033333333333335, "TestEig": 0.053333333333333344, "TestEigh": 0.038, "TestEighCases": 0.001, "TestEigvals": 0.06666666666666668, "TestEigvalsh": 0.027999999999999997, "TestEigvalshCases": 0.0013333333333333333, "TestInv": 0.061333333333333344, "TestLstsq": 0.222, "TestMatrixRank": 0.3966666666666667, "TestMisc": 0.012666666666666668, "TestMisc2": 0.006000000000000001, "TestMultiDot": 0.07266666666666667, "TestNormDouble": 0.9403333333333334, "TestNormInt64": 0.7763333333333332, "TestNormSingle": 0.848, "TestNorm_NonSystematic": 0.005, "TestPinv": 0.15500000000000003, "TestPinvHermitian": 0.04466666666666667, "TestQR": 5.6226666666666665, "TestSVD": 0.06000000000000002, "TestSVDHermitian": 0.10533333333333335, "TestSolve": 0.4056666666666667, "TestTensorinv": 0.038, "TestTensorsolve": 0.02566666666666667}, "torch_np/test_basic": {"TestArrayToSequence": 0.012333333333333335, "TestCopyTo": 0.011666666666666667, "TestCtorNested": 0.006000000000000001, "TestDefaultDtype": 0.016333333333333335, "TestDivmod": 0.02666666666666667, "TestExport": 0.001, "TestMisc": 0.004, "TestNormalizations": 0.011333333333333334, "TestOneArr": 0.5830000000000004, "TestOneArrAndAxesTuple": 0.02466666666666667, "TestOneArrAndAxis": 0.35966666666666697, "TestOneArrAndShape": 0.015000000000000006, "TestOneArrToScalar": 0.021333333333333333, "TestPythonArgsToArray": 0.026, "TestSequenceOfArrays": 0.034666666666666686, "TestSequenceOfArraysToSingle": 0.016666666666666666, "TestShapeLikeToArray": 0.009000000000000001, "TestSmokeNotImpl": 0.0036666666666666666}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.5373333333333334}, "torch_np/test_dtype": {"TestConvertDType": 0.4646666666666668}, "torch_np/test_function_base": {"TestAppend": 0.3953333333333333}, "torch_np/test_ndarray_methods": {"TestAmax": 0.008, "TestAmin": 0.008, "TestArgmax": 1.227, "TestArgmaxArgminCommon": 1.7323333333333295, "TestArgmin": 1.329333333333333, "TestContains": 0.0030000000000000005, "TestIndexing": 0.3673333333333333, "TestIter": 0.006666666666666667, "TestNoExtraMethods": 0.013333333333333334, "TestNonzero": 0.16333333333333333, "TestRavel": 0.009333333333333334, "TestReshape": 0.006666666666666667, "TestTranspose": 0.011666666666666667}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.45966666666666706, "TestNEP50Table": 0.005666666666666667}, "torch_np/test_random": {"TestChoice": 0.014333333333333335, "TestNumpyGlobal": 0.005, "TestScalarReturn": 0.41500000000000004, "TestShuffle": 0.02066666666666667}, "torch_np/test_reductions": {"TestAll": 0.013666666666666667, "TestAny": 0.014, "TestFlatnonzero": 0.28933333333333333, "TestGenericCumSumProd": 0.030333333333333327, "TestGenericReductions": 3.1983333333333044, "TestMean": 0.028666666666666663, "TestSum": 0.23633333333333337}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.4083333333333334, "TestIsScalar": 0.052000000000000025}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 0.936333333333334, "TestNdarrayDunderVsUfunc": 0.2263333333333335, "TestUfuncDtypeKwd": 0.007, "TestUnaryUfuncs": 0.4053333333333334}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.5420000000000001}}}, "win-vs2019-cuda11.8-py3": {"default": {"backends/xeon/test_launch": {"TestTorchrun": 0.0025}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 5.072499999999999}, "distributions/test_distributions": {"TestAgainstScipy": 2.231, "TestConstraints": 0.25949999999999995, "TestDistributionShapes": 0.25050000000000017, "TestDistributions": 84.188, "TestFunctors": 0.026000000000000002, "TestJit": 18.581, "TestKL": 6.122000000000001, "TestLazyLogitsInitialization": 0.024, "TestNumericalStability": 0.12550000000000003, "TestRsample": 1.3, "TestValidation": 0.665}, "export/test_converter": {"TestConverter": 10.495}, "export/test_db": {"ExampleTests": 0.0095}, "export/test_export": {"TestDynamismExpression": 3.1310000000000002, "TestExport": 0.06800000000000005, "TestExportCustomClass": 0.17, "TestOneOffModelExportResult": 1.8555000000000001}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 2.4185}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 3.3289999999999997}, "export/test_hop": {"TestHOPCUDA": 0.0055, "TestHOPGeneric": 2.0604999999999998}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 2.222, "TestLiftUnlift": 0.021}, "export/test_pass_infra": {"TestPassInfra": 3.6715}, "export/test_passes": {"TestPasses": 23.055}, "export/test_safeguard": {"TestSafeguard": 0.969}, "export/test_schema": {"TestSchema": 2.5974999999999997}, "export/test_serialize": {"TestDeserialize": 0.0095, "TestOpVersioning": 0.007, "TestSaveLoad": 0.6224999999999998, "TestSchemaVersioning": 0.05499999999999999, "TestSerialize": 4.2835, "TestSerializeCustomClass": 0.1825}, "export/test_sparse": {"TestSparseProp": 113.36900000000006}, "export/test_tools": {"TestExportTools": 3.2655}, "export/test_torchbind": {"TestCompileTorchbind": 1.7930000000000001, "TestExportTorchbind": 5.318, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 2.4505}, "export/test_unflatten": {"TestUnflatten": 7.006499999999999}, "export/test_upgrade": {"TestUpgrade": 1.1219999999999999}, "export/test_verifier": {"TestVerifier": 3.494499999999999}, "functorch/test_aotdispatch": {"TestAOTAutograd": 25.452000000000005, "TestAOTAutogradWithDynamo": 23.390000000000004, "TestAOTDispatch": 0.987, "TestAOTExport": 1.5220000000000002, "TestAOTModuleSimplified": 1.4765, "TestPartitioning": 1.7249999999999999}, "functorch/test_control_flow": {"TestControlFlow": 0.0125, "TestControlFlowTraced": 0.06900000000000005}, "functorch/test_dims": {"TestMin": 22.228, "TestMinFunctorchOnly": 19.376499999999997}, "functorch/test_eager_transforms": {"TestAutogradFunctionCUDA": 0.1720000000000001, "TestAutogradFunctionVmapAPICUDA": 0.038, "TestCompileTransformsCUDA": 3.7575, "TestComposabilityCUDA": 0.3260000000000001, "TestExamplesCorrectnessCUDA": 4.387, "TestFunctionalizeCUDA": 0.21300000000000002, "TestGradTransformCUDA": 2.9164999999999948, "TestHelpersCUDA": 0.0235, "TestHessianCUDA": 0.11599999999999999, "TestHigherOrderOperatorInteractionCUDA": 0.05, "TestJacCUDA": 1.4605000000000006, "TestJvpCUDA": 0.10900000000000003, "TestLinearizeCUDA": 0.8835000000000002, "TestMakeFunctional": 0.17400000000000004, "TestSliceArgnums": 2.0109999999999997, "TestVmapJvpInplaceViewCUDA": 0.035500000000000004, "TestVmapOfGradCUDA": 1.1475}, "functorch/test_logging": {"TestAOTLogging": 2.566}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 0.877, "RandomOpTestCase": 0.156, "ReduceTestCase": 0.16599999999999998, "TestMemoryEfficientOpAuthoring": 11.797500000000001}, "functorch/test_minifier": {"TestMinifier": 2.745}, "functorch/test_ops": {"TestOperatorsCUDA": 7228.1579999999885}, "functorch/test_parsing": {"TestAnonymousAxis": 2.579, "TestParsedExpression": 0.011, "TestParsingUtils": 0.0125, "TestValidateRearrangeExpressions": 0.012}, "functorch/test_rearrange": {"TestRearrange": 2.5194999999999994}, "functorch/test_vmap": {"TestRandomnessCUDA": 2.2169999999999996, "TestTransformFailureCUDA": 0.44200000000000006, "TestVmapAPI": 6.122999999999992, "TestVmapBatchedGradientCUDA": 0.3640000000000001, "TestVmapDeviceTypeCUDA": 0.03900000000000001, "TestVmapNestedTensorCUDA": 0.084, "TestVmapOperators": 4.576999999999998, "TestVmapOperatorsOpInfoCUDA": 649.6969999999994}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 7.956999999999571}, "higher_order_ops/test_with_effects": {"TestWithEffects": 3.308}, "inductor/test_fx_fusion": {"TestFxFusion": 1.6769999999999996}, "lazy/test_debug_util": {"DebugUtilTest": 0.0015}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 2.5815}, "lazy/test_generator": {"LazyGeneratorTest": 2.885}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.0025}, "lazy/test_step_closures": {"ClosuresTest": 5.808}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.5025000000000001, "TestLazyTensor": 0.1205}, "nn/test_convolution": {"TestConvolutionNN": 52.530499999999996, "TestConvolutionNNDeviceTypeCUDA": 90.81550000000094}, "nn/test_dropout": {"TestDropoutNN": 2.0945, "TestDropoutNNDeviceTypeCUDA": 0.894}, "nn/test_embedding": {"TestEmbeddingNN": 2.0724999999999985, "TestEmbeddingNNDeviceTypeCUDA": 37.20749999999999}, "nn/test_init": {"TestNNInit": 267.6310000000001}, "nn/test_lazy_modules": {"TestLazyModules": 2.5629999999999953}, "nn/test_load_state_dict": {"TestLoadStateDict": 3.117999999999997, "TestLoadStateDictSwap": 0.091}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.043000000000000003, "TestModuleHookNN": 0.14250000000000002, "TestModuleHooks": 2.1209999999999987, "TestStateDictHooks": 0.053000000000000005}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 11.549000000000001, "TestMultiheadAttentionNNDeviceTypeCUDA": 1.631999999999999}, "nn/test_packed_sequence": {"PackedSequenceTest": 2.7404999999999995}, "nn/test_parametrization": {"TestNNParametrization": 3.4469999999999974, "TestNNParametrizationDeviceCUDA": 1.6149999999999998}, "nn/test_pooling": {"TestAvgPool": 2.41, "TestPoolingNN": 1.1775, "TestPoolingNNDeviceTypeCUDA": 7.456499999999995}, "nn/test_pruning": {"TestPruningNN": 2.2274999999999974}, "profiler/test_execution_trace": {"TestExecutionTrace": 2.2304999999999997}, "profiler/test_memory_profiler": {"TestDataFlow": 1.7285000000000001, "TestIdentifyGradients": 0.3305, "TestMemoryProfiler": 2.4315, "TestMemoryProfilerE2E": 6.529}, "profiler/test_profiler": {"TestExecutionTrace": 0.085, "TestExperimentalUtils": 15.399999999999999, "TestProfiler": 23.1635, "TestProfilerCUDA": 0.0035, "TestProfilerITT": 2.035, "TestRecordFunction": 0.05900000000000001, "TestTorchTidyProfiler": 4.7429999999999986}, "profiler/test_profiler_tree": {"TestProfilerTree": 2.5509999999999993}, "profiler/test_record_function": {"TestRecordFunction": 2.9815}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 8.4835}, "test_ao_sparsity": {"TestActivationSparsifier": 0.11349999999999999, "TestBaseDataScheduler": 0.057499999999999996, "TestBaseDataSparsifier": 0.15000000000000002, "TestBaseSparsifier": 0.044, "TestBaseStructuredSparsifier": 8.25, "TestComposability": 3.2125000000000004, "TestCubicScheduler": 0.0085, "TestFPGMPruner": 0.0985, "TestFakeSparsity": 0.15250000000000002, "TestFxComposability": 2.795, "TestNearlyDiagonalSparsifier": 1.3085, "TestNormDataSparsifiers": 1.3900000000000001, "TestQuantizationUtils": 0.038000000000000006, "TestQuantizedSparseKernels": 2.463, "TestQuantizedSparseLayers": 0.4385, "TestSaliencyPruner": 0.05700000000000001, "TestScheduler": 0.0245, "TestSparsityUtilFunctions": 0.0635, "TestWeightNormSparsifier": 0.48450000000000004}, "test_autocast": {"TestAutocastCPU": 7.153499999999999, "TestAutocastGPU": 3.676, "TestTorchAutocast": 0.009000000000000001}, "test_autograd": {"TestAllowMutationOnSaved": 0.0505, "TestAutograd": 54.74850000000016, "TestAutogradComplex": 0.011, "TestAutogradDeviceTypeCUDA": 4.571499999999999, "TestAutogradForwardMode": 0.15450000000000008, "TestAutogradForwardModeBatchedGrad": 0.026000000000000002, "TestAutogradFunctional": 16.549999999999994, "TestAutogradInferenceMode": 0.06250000000000003, "TestAutogradLogging": 0.0385, "TestAutogradMultipleDispatchCUDA": 0.036000000000000004, "TestMultithreadAutograd": 0.42300000000000004, "TestNestedCheckpoint": 0.6740000000000002, "TestSelectiveActivationCheckpoint": 0.051000000000000004}, "test_autograd_fallback": {"TestAutogradFallback": 0.6995000000000002}, "test_binary_ufuncs": {"TestBinaryUfuncsCUDA": 372.447500000005}, "test_bundled_inputs": {"TestBundledInputs": 3.964999999999999}, "test_comparison_utils": {"TestComparisonUtils": 2.4735}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_complex": {"TestComplexTensorCUDA": 2.7885}, "test_content_store": {"TestContentStoreCUDA": 0.0025}, "test_cpp_api_parity": {"TestCppApiParity": 27.272499999999997}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 2.1509999999999994, "TestMAIATensor": 0.015, "TestORTTensor": 0.6880000000000001, "TestPybindTypeCasters": 0.004, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.10500000000000001}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 2.108999999999999, "TestMAIATensor": 0.013000000000000001, "TestORTTensor": 0.703, "TestPybindTypeCasters": 0.003, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.10400000000000001}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 412.876}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0075}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 25.605000000000004}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0015}, "test_cuda": {"TestBlockStateAbsorption": 9.2865, "TestCuda": 180.27200000000008, "TestCudaMallocAsync": 8.200000000000001, "TestCudaOptimsCUDA": 3.8179999999999996}, "test_cuda_expandable_segments": {"TestBlockStateAbsorption": 9.281, "TestCuda": 288.76349999999974, "TestCudaMallocAsync": 8.153500000000001, "TestCudaOptimsCUDA": 3.5854999999999997}, "test_cuda_multigpu": {"TestCudaComm": 0.052500000000000026, "TestCudaMultiGPU": 2.8899999999999952}, "test_cuda_nvml_based_avail": {"TestExtendedCUDAIsAvail": 0.009000000000000001, "TestVisibleDeviceParses": 0.11000000000000001}, "test_cuda_primary_ctx": {"TestCudaPrimaryCtx": 0.0045000000000000005}, "test_cuda_sanitizer": {"TestArgumentHandler": 2.5229999999999997, "TestEventHandler": 0.08750000000000002, "TestMessages": 0.006500000000000001}, "test_cuda_trace": {"TestCudaTrace": 13.261499999999998}, "test_custom_backend": {"TestCustomBackend": 0.1705}, "test_custom_ops": {"MiniOpTest": 3.4875000000000016, "MiniOpTestOther": 0.09700000000000003, "TestCustomOp": 53.40950000000005, "TestCustomOpAPI": 0.18350000000000005, "TestCustomOpTestingCUDA": 0.008, "TestCustomOperators": 0.39150000000000007, "TestGenerateOpcheckTests": 6.009}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.019500000000000003, "TestConvAfterFork": 0.0005, "TestCustomPinFn": 24.048000000000002, "TestDataLoader": 560.2434999999999, "TestDataLoaderDeviceTypeCUDA": 19.0225, "TestDataLoaderPersistentWorkers": 563.8834999999999, "TestDatasetRandomSplit": 5.9825, "TestDictDataLoader": 7.932499999999999, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.006, "TestSetAffinity": 0.0015, "TestStackDataset": 0.053000000000000005, "TestStringDataLoader": 9.4015, "TestTensorDataset": 0.0405}, "test_datapipe": {"TestCaptureDataFrame": 0.001, "TestCircularSerialization": 0.01, "TestDataChunk": 0.0105, "TestDataFramesPipes": 0.009000000000000001, "TestFunctionalIterDataPipe": 4.874999999999999, "TestFunctionalMapDataPipe": 0.064, "TestGraph": 0.022, "TestIterDataPipeCountSampleYielded": 0.0165, "TestIterDataPipeGraphFastForward": 0.06249999999999999, "TestIterDataPipeSingletonConstraint": 0.036500000000000005, "TestIterableDataPipeBasic": 0.10450000000000001, "TestSerialization": 0.003, "TestSharding": 16.3585, "TestStreamWrapper": 2.4775, "TestTyping": 0.015000000000000003}, "test_decomp": {"DecompOneOffTestsCUDA": 0.0665, "HasDecompTest": 0.34450000000000003, "TestDecompCUDA": 14994.44100000001}, "test_deploy": {"TestFreezer": 3.4154999999999998}, "test_dispatch": {"TestDispatch": 94.499, "TestPythonDispatcher": 0.033}, "test_dlpack": {"TestTorchDlPackCUDA": 3.115499999999993}, "test_dynamic_shapes": {"TestDimConstraints": 3.41, "TestFloorDiv": 0.017, "TestGuardsExpressions": 0.025, "TestPySymInt": 4.192, "TestSymNumberMagicMethods": 2.4964999999999993}, "test_expanded_weights": {"TestExpandedWeightFunctionalCUDA": 8.865999999999996, "TestExpandedWeightHelperFunctionCUDA": 3.7219999999999995, "TestExpandedWeightModuleCUDA": 16.403000000000002}, "test_fake_tensor": {"FakeTensorConstHandling": 0.10650000000000001, "FakeTensorConverterTest": 0.045, "FakeTensorDispatchCache": 0.16000000000000003, "FakeTensorOpInfoTestCUDA": 1.0325000000000002, "FakeTensorOperatorInvariants": 3.7964999999999995, "FakeTensorPropTest": 0.14650000000000002, "FakeTensorSerialization": 0.012, "FakeTensorTest": 27.24000000000001, "PropagateRealTensorsFakeTensorConstHandling": 0.14650000000000002, "PropagateRealTensorsFakeTensorConverterTest": 0.041999999999999996, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.376, "PropagateRealTensorsFakeTensorPropTest": 0.0875, "PropagateRealTensorsFakeTensorTest": 18.153999999999996}, "test_flop_counter": {"TestFlopCounter": 2.1819999999999986}, "test_foreach": {"TestForeachCUDA": 567.0159999999992}, "test_function_schema": {"TestFunctionSchema": 3.072999999999998}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 0.003}, "test_functional_optim": {"TestFunctionalOptimParity": 2.792}, "test_functionalization": {"TestCrossRefFunctionalization": 3.654, "TestFunctionalization": 6.005999999999999}, "test_futures": {"TestFuture": 3.4639999999999995}, "test_fx": {"AnnotationsTest": 0.029000000000000005, "TestCSEPass": 0.527, "TestCommonPass": 0.22100000000000003, "TestConstFold": 0.23950000000000005, "TestConstParamShapeInControlFlow": 0.057499999999999996, "TestDCE": 0.045000000000000005, "TestFX": 10.676999999999982, "TestFXAPIBackwardCompatibility": 0.04699999999999999, "TestFunctionalTracing": 0.5635000000000004, "TestMatcher": 0.11499999999999999, "TestOperatorSignaturesCUDA": 4.246999999999979, "TestPassManager": 0.04, "TestSourceMatcher": 2.9795000000000003, "TestSubgraphRewriter": 2.2949999999999977, "TypeCheckerTest": 0.42150000000000004}, "test_fx_experimental": {"TestFXExperimental": 5.130499999999997, "TestNormalizeOperatorsCUDA": 6.632999999999965, "TestTranslationValidation": 0.25150000000000006}, "test_fx_passes": {"TestFXGraphPasses": 3.4709999999999974, "TestFXMatcherUtils": 0.13850000000000004}, "test_fx_reinplace_pass": {"TestReinplacePass": 2.8589999999999995}, "test_import_stats": {"TestImportTime": 9.109}, "test_indexing": {"NumpyTestsCUDA": 0.08150000000000002, "TestIndexingCUDA": 5.8869999999999925}, "test_itt": {"TestItt": 2.442}, "test_jit": {"TestAliasAnalysis": 0.669, "TestAsync": 0.6865000000000001, "TestAtenPow": 0.013499999999999998, "TestAutodiffJit": 0.1325, "TestAutodiffSubgraphSlicing": 0.5395000000000002, "TestAwait": 0.39350000000000007, "TestBackends": 0.0045000000000000005, "TestBackendsWithCompiler": 0.003, "TestBatchMM": 0.1485, "TestBuiltins": 0.0945, "TestCUDA": 0.8455000000000001, "TestClassType": 3.5054999999999996, "TestComplex": 1.3405000000000002, "TestCustomOperators": 0.06650000000000002, "TestDCE": 0.037, "TestDataParallel": 0.0075, "TestDataclasses": 7.398000000000001, "TestDeviceAnalysis": 0.309, "TestDict": 0.7655000000000003, "TestDtypeAnalysis": 0.258, "TestEnum": 0.31800000000000006, "TestFreezing": 3.6660000000000004, "TestFrontend": 0.5555, "TestFrozenOptimizations": 17.034499999999998, "TestFunctionalBlocks": 0.0115, "TestFunctionalToInplaceActivation": 0.15749999999999997, "TestGenerator": 0.10749999999999998, "TestGetDefaultAttr": 0.026000000000000002, "TestGraphRewritePasses": 0.0775, "TestHash": 0.1275, "TestHooks": 1.1425000000000003, "TestIgnorableArgs": 0.024, "TestIgnoreContextManager": 0.0045000000000000005, "TestInplaceToFunctionalActivation": 0.10200000000000001, "TestIsinstance": 0.3120000000000001, "TestJit": 9.983499999999992, "TestJitGeneratedModule": 21.61400000000011, "TestJitProfiler": 0.0015, "TestJitUtils": 0.03150000000000001, "TestList": 2.1305000000000005, "TestLogging": 0.094, "TestMKLDNNReinplacing": 0.3835, "TestMisc": 0.5960000000000001, "TestMixTracingScripting": 2.1574999999999998, "TestModels": 10.294999999999998, "TestModuleAPIs": 0.21300000000000002, "TestModuleContainers": 2.0515, "TestModuleInterface": 1.0005000000000002, "TestModules": 0.028499999999999998, "TestNamedTuple": 0.12250000000000001, "TestNnapiBackend": 0.045000000000000026, "TestOpDecompositions": 0.026500000000000003, "TestOptimizeForMobilePreserveDebugInfo": 0.30450000000000005, "TestParametrization": 0.153, "TestPeephole": 0.8345000000000005, "TestProducerVersion": 0.003, "TestProfiler": 0.24450000000000005, "TestPythonBindings": 0.051500000000000004, "TestPythonBuiltinOP": 0.5780000000000001, "TestPythonIr": 0.03900000000000001, "TestRecursiveScript": 1.2745000000000004, "TestRemoveMutation": 0.18900000000000006, "TestSaveLoad": 1.0940000000000003, "TestSaveLoadFlatbuffer": 0.7405, "TestSaveLoadForOpVersion": 3.1435, "TestScript": 62.462, "TestScriptDict": 0.054000000000000006, "TestScriptList": 1.1855, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.26450000000000007, "TestScriptProfile": 0.589, "TestSlice": 0.2635000000000001, "TestSparse": 0.0445, "TestStringFormatting": 0.17900000000000005, "TestSymbolicShapeAnalysis": 2.078499999999999, "TestTensorBuiltins": 0.135, "TestTensorCreationOps": 0.07100000000000001, "TestTensorMethods": 0.0235, "TestTorchbind": 0.2050000000000001, "TestTracer": 11.385499999999992, "TestTypeSharing": 0.8, "TestTypesAndAnnotation": 0.197, "TestTyping": 0.5965000000000003, "TestUnion": 0.7615000000000003, "TestUnsupportedOps": 0.0405, "TestUpgraders": 0.11000000000000001, "TestWarn": 0.077, "TestWith": 0.575}, "test_jit_autocast": {"TestAutocast": 5.437999999999997, "TestJitTraceAutocast": 58.352500000000006}, "test_jit_disabled": {"TestJitDisabled": 0.8674999999999999}, "test_jit_fuser_legacy": {"TestFuser": 0.008}, "test_jit_fuser_te": {"TestFuserCommon": 2.078, "TestNNCOpInfoCUDA": 48.8725000000023, "TestTEFuserDynamic": 517.1200000000001, "TestTEFuserStatic": 535.066}, "test_jit_legacy": {"TestAliasAnalysis": 0.589, "TestAsync": 0.56, "TestAtenPow": 0.0135, "TestAutodiffJit": 0.081, "TestAutodiffSubgraphSlicing": 0.4105000000000001, "TestAwait": 0.3350000000000001, "TestBackends": 0.0045000000000000005, "TestBackendsWithCompiler": 0.003, "TestBatchMM": 0.131, "TestBuiltins": 0.091, "TestCUDA": 0.871, "TestClassType": 3.5109999999999997, "TestComplex": 1.2115000000000002, "TestCustomOperators": 0.06550000000000003, "TestDCE": 0.0295, "TestDataParallel": 0.0075, "TestDataclasses": 5.9075, "TestDeviceAnalysis": 0.28750000000000003, "TestDict": 0.6465000000000003, "TestDtypeAnalysis": 0.254, "TestEnum": 0.30800000000000005, "TestFreezing": 3.5104999999999995, "TestFrontend": 0.5695, "TestFrozenOptimizations": 15.743500000000001, "TestFunctionalBlocks": 0.0105, "TestFunctionalToInplaceActivation": 0.187, "TestGenerator": 0.08300000000000002, "TestGetDefaultAttr": 0.0295, "TestGraphRewritePasses": 0.08, "TestHash": 0.10899999999999999, "TestHooks": 1.0460000000000005, "TestIgnorableArgs": 0.0205, "TestIgnoreContextManager": 0.0045000000000000005, "TestInplaceToFunctionalActivation": 0.084, "TestIsinstance": 0.3205000000000001, "TestJit": 9.707499999999992, "TestJitGeneratedModule": 20.391500000000097, "TestJitProfiler": 0.0015, "TestJitUtils": 0.03250000000000001, "TestList": 1.7085000000000004, "TestLogging": 0.0845, "TestMKLDNNReinplacing": 0.36100000000000004, "TestMisc": 0.686, "TestMixTracingScripting": 1.9535, "TestModels": 9.775999999999996, "TestModuleAPIs": 0.238, "TestModuleContainers": 2.0625, "TestModuleInterface": 0.9530000000000001, "TestModules": 0.0205, "TestNamedTuple": 0.11850000000000002, "TestNnapiBackend": 0.045000000000000026, "TestOpDecompositions": 0.03, "TestOptimizeForMobilePreserveDebugInfo": 0.344, "TestParametrization": 0.16549999999999998, "TestPeephole": 0.6810000000000003, "TestProducerVersion": 0.003, "TestProfiler": 0.24650000000000005, "TestPythonBindings": 0.04600000000000001, "TestPythonBuiltinOP": 0.5005000000000002, "TestPythonIr": 0.036000000000000004, "TestRecursiveScript": 1.1000000000000003, "TestRemoveMutation": 0.18400000000000002, "TestSaveLoad": 0.9340000000000002, "TestSaveLoadFlatbuffer": 0.542, "TestSaveLoadForOpVersion": 3.0569999999999995, "TestScript": 68.02500000000006, "TestScriptDict": 0.049, "TestScriptList": 1.225, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.23600000000000004, "TestScriptProfile": 0.6224999999999999, "TestSlice": 0.2290000000000001, "TestSparse": 0.0385, "TestStringFormatting": 0.17000000000000004, "TestSymbolicShapeAnalysis": 2.037999999999999, "TestTensorBuiltins": 0.1285, "TestTensorCreationOps": 0.063, "TestTensorMethods": 0.0175, "TestTorchbind": 0.18700000000000008, "TestTracer": 22.181, "TestTypeSharing": 0.7185000000000001, "TestTypesAndAnnotation": 0.18150000000000005, "TestTyping": 0.5275000000000003, "TestUnion": 0.6160000000000003, "TestUnsupportedOps": 0.042499999999999996, "TestUpgraders": 0.10850000000000001, "TestWarn": 0.07500000000000001, "TestWith": 0.45499999999999996}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0005, "TestEnableDisableLlgaFuser": 0.0015, "TestFusionPatternCUDA": 0.006500000000000001, "TestModel": 0.011000000000000001, "TestOpCUDA": 0.006}, "test_jiterator": {"TestPythonJiteratorCUDA": 41.4999999999999}, "test_legacy_vmap": {"TestVmapAPI": 4.112999999999999, "TestVmapAPILegacy": 3.8225000000000016, "TestVmapBatchedGradientCUDA": 1.3899999999999988, "TestVmapBatchedGradientLegacyCUDA": 2.0479999999999987, "TestVmapOperators": 1.0510000000000002, "TestVmapOperatorsLegacy": 1.7234999999999998}, "test_license": {"TestLicense": 0.003}, "test_linalg": {"TestLinalgCUDA": 509.2569999999996}, "test_logging": {"LoggingTest": 5.751}, "test_masked": {"TestMaskedCUDA": 49.61250000000007}, "test_maskedtensor": {"TestBasicsCUDA": 0.2475, "TestBinary": 0.5610000000000004, "TestOperatorsCUDA": 24.797499999999964, "TestReductions": 0.11100000000000003, "TestUnary": 2.468499999999986}, "test_matmul_cuda": {"TestFP8MatmulCudaCUDA": 0.021000000000000008, "TestMatmulCudaCUDA": 151.33300000000003, "TestMixedDtypesLinearCudaCUDA": 0.003}, "test_meta": {"TestMetaCUDA": 4418.013999999679, "TestMetaConverter": 13.788}, "test_mkl_verbose": {"TestMKLVerbose": 9.1485}, "test_mkldnn_fusion": {"TestMkldnnFusion": 276.42600000000004}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 9.189499999999999}, "test_mobile_optimizer": {"TestOptimizer": 1.4889999999999999}, "test_model_dump": {"TestModelDump": 2.6504999999999996}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.0015}, "test_module_init": {"TestModuleInitCUDA": 4.007999999999968}, "test_module_tracker": {"TestModuleTracker": 2.4535}, "test_modules": {"TestModuleCUDA": 1914.9424999999924}, "test_monitor": {"TestMonitor": 2.4215, "TestMonitorTensorboard": 0.6990000000000001}, "test_multiprocessing": {"TestMultiprocessing": 1052.0105}, "test_multiprocessing_spawn": {"ErrorTest": 0.0045000000000000005, "ForkTest": 0.0045000000000000005, "SpawnTest": 53.01049999999999}, "test_namedtensor": {"TestNamedTensor": 5.250999999999994}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 3.4890000000000003}, "test_native_functions": {"TestNativeFunctions": 2.8054999999999994}, "test_native_mha": {"TestMHADeviceTypeCUDA": 4.2395000000000005}, "test_nestedtensor": {"TestNestedTensor": 2.1929999999999965, "TestNestedTensorAutogradCUDA": 1.8045, "TestNestedTensorDeviceTypeCUDA": 3.5539999999999945, "TestNestedTensorSubclassCUDA": 2.340999999999997}, "test_nn": {"TestAddRelu": 0.009000000000000001, "TestConstantPadNd": 0.0075, "TestFunctionalPickle": 0.003, "TestFusionEval": 0.665, "TestFusionUtils": 0.01, "TestNN": 178.20850000000013, "TestNNDeviceTypeCUDA": 242.99150000001242, "TestUtils": 0.0075}, "test_numba_integration": {"TestNumbaIntegration": 2.854999999999999}, "test_numpy_interop": {"TestNumPyInteropCUDA": 2.395999999999998}, "test_openmp": {"TestOpenMP_ParallelFor": 9.0475}, "test_ops": {"TestCommonCUDA": 7345.41049999992, "TestCompositeComplianceCUDA": 1304.6589999999976, "TestFakeTensorCUDA": 1482.5234999999986, "TestMathBitsCUDA": 257.81400000000036, "TestSelfKwarg": 1.9394999999999998, "TestTagsCUDA": 8.735499999999977}, "test_ops_fwd_gradients": {"TestFwdGradientsCUDA": 1808.378999999981}, "test_ops_gradients": {"TestBwdGradientsCUDA": 2546.0844999999354}, "test_ops_jit": {"TestJitCUDA": 2112.7829999999976}, "test_optim": {"TestDifferentiableOptimizer": 0.29900000000000004, "TestLRScheduler": 3.686499999999987, "TestOptim": 82.69699999999999, "TestOptimRenewedCUDA": 338.8374999999993, "TestSWAUtils": 194.09449999999998}, "test_out_dtype_op": {"TestOutDtypeOp": 2.9579999999999997}, "test_overrides": {"TestBroadcastAllOverride": 0.0055, "TestDisabledTorchFunction": 0.005, "TestDisabledUserWarnings": 0.0045000000000000005, "TestEinsumOverride": 0.0155, "TestGradCheckOverride": 0.0395, "TestGradNewOnesOverride": 0.004, "TestIndexing": 0.015, "TestIterator": 0.004, "TestNamedTuple": 0.0055, "TestPickle": 0.0055, "TestRNN": 0.009000000000000001, "TestResolveName": 0.193, "TestTorchFunctionMode": 0.09550000000000004, "TestTorchFunctionOverride": 4.85349999999982, "TestTorchFunctionWarning": 0.0175, "TestWrapTorchFunction": 0.003}, "test_package": {"DirectoryReaderTest": 0.012, "ModelTest": 0.0045000000000000005, "TestAnalyze": 2.4235, "TestDependencyAPI": 0.08350000000000002, "TestDependencyHooks": 0.017, "TestDiGraph": 0.03600000000000001, "TestGlobGroup": 0.04250000000000002, "TestImporter": 0.0215, "TestLoadBCPackages": 0.11599999999999999, "TestMangling": 0.0385, "TestMisc": 0.07399999999999998, "TestPackageFX": 0.0945, "TestPackageScript": 0.5480000000000002, "TestRepackage": 0.0185, "TestResources": 0.025500000000000002, "TestSaveLoad": 0.0675}, "test_per_overload_api": {"TestPerOverloadAPI": 2.4479999999999995}, "test_prims": {"TestDecompCUDA": 0.43000000000000005, "TestPrimsBasic": 1.9564999999999997, "TestPrimsCUDA": 0.9040000000000001, "TestRefsCUDA": 0.021500000000000002}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.16050000000000003, "TestGenericProxyTensorFake": 0.8235000000000003, "TestGenericProxyTensorReal": 5.845499999999998, "TestGenericProxyTensorSymbolic": 1.3165000000000004, "TestRealProxyTensor": 0.0245, "TestSymbolicTracing": 3.7254999999999985}, "test_pruning_op": {"PruningOpTest": 2.6855}, "test_public_bindings": {"TestPublicBindings": 2.4619999999999997}, "test_python_dispatch": {"TestDispatcherPythonBindings": 1.9175, "TestPythonDispatch": 10.471499999999999, "TestPythonDispatcher": 0.0115, "TestPythonRegistration": 2.3484999999999996, "TestWrapperSubclassAliasingCUDA": 0.34350000000000014}, "test_pytree": {"TestCxxPytree": 0.02250000000000001, "TestGenericPytree": 2.8074999999999966, "TestPythonPytree": 0.10750000000000005}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.033, "TestAOMigrationNNQuantized": 0.05950000000000001, "TestAOMigrationQuantization": 0.0335, "TestAOMigrationQuantizationFx": 0.038500000000000006, "TestBackendConfig": 0.093, "TestBiasCorrectionEager": 1.3115, "TestBits": 0.004, "TestBitsCUDA": 0.0245, "TestComparatorOps": 1.9085, "TestDeprecatedJitQuantized": 2.5934999999999997, "TestDistributed": 0.038, "TestDuplicateDQPass": 0.006500000000000001, "TestDynamicQuantizedModule": 21.432, "TestDynamicQuantizedOps": 7.968, "TestEqualizeEager": 0.14800000000000002, "TestEqualizeFx": 5.778, "TestFXGraphMatcher": 2.0885, "TestFXGraphMatcherModels": 0.003, "TestFXNumericSuiteCoreAPIs": 41.813500000000005, "TestFXNumericSuiteCoreAPIsModels": 31.708000000000006, "TestFXNumericSuiteNShadows": 0.036500000000000005, "TestFakeQuantize": 0.4255, "TestFakeQuantizeOps": 31.4615, "TestFloat8DtypeCUDA": 0.11399999999999999, "TestFuseEager": 3.3205, "TestFuseFx": 3.4079999999999995, "TestFusedObsFakeQuant": 0.4275, "TestFusedObsFakeQuantModule": 0.5665, "TestFusionPasses": 0.0355, "TestFxDetectInputWeightEqualization": 0.39, "TestFxDetectOutliers": 0.42750000000000005, "TestFxModelReportClass": 0.8175000000000001, "TestFxModelReportDetectDynamicStatic": 0.11099999999999999, "TestFxModelReportDetector": 0.10750000000000001, "TestFxModelReportObserver": 0.3335, "TestFxModelReportVisualizer": 0.3935, "TestGenerateNumericDebugHandle": 0.003, "TestGraphUtils": 0.0045000000000000005, "TestHistogramObserver": 60.89149999999999, "TestMetaDataPorting": 0.0105, "TestModelNumericsEager": 0.8525, "TestNumericSuiteEager": 7.0649999999999995, "TestObserver": 5.728999999999999, "TestPT2ERepresentation": 0.012, "TestPadding": 18.3035, "TestQNNPackOps": 0.018000000000000002, "TestQuantizationDocs": 0.44400000000000006, "TestQuantizeDynamicJitOps": 2.7830000000000004, "TestQuantizeDynamicJitPasses": 5.775, "TestQuantizeEagerOps": 2.2755, "TestQuantizeEagerPTQDynamic": 12.664, "TestQuantizeEagerPTQStatic": 25.345499999999998, "TestQuantizeEagerQAT": 6.8485, "TestQuantizeEagerQATNumerics": 3.1315, "TestQuantizeFx": 43.93299999999999, "TestQuantizeFxModels": 11.777, "TestQuantizeFxOps": 155.51650000000004, "TestQuantizeJit": 22.046, "TestQuantizeJitOps": 272.2895, "TestQuantizeJitPasses": 9.779000000000002, "TestQuantizePT2E": 0.14400000000000004, "TestQuantizePT2EQAT": 0.014000000000000005, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 0.025500000000000002, "TestQuantizePT2EQAT_ConvBn2d": 0.025500000000000005, "TestQuantizePT2EX86Inductor": 0.047000000000000014, "TestQuantizedConv": 408.6495, "TestQuantizedEmbeddingOps": 1.2485, "TestQuantizedFunctionalOps": 1.1574999999999998, "TestQuantizedLinear": 175.261, "TestQuantizedOps": 178.397, "TestQuantizedTensor": 4.043, "TestRecordHistogramObserver": 0.065, "TestReferenceQuantizedModule": 0.07250000000000001, "TestSerialization": 1.7134999999999998, "TestStaticQuantizedModule": 63.050500000000014, "TestSubgraphRewriter": 0.6635, "TestUtils": 0.032, "TestXNNPACKQuantizer": 0.037500000000000006, "TestXNNPACKQuantizerModels": 0.0015}, "test_reductions": {"TestReductionsCUDA": 183.1445000000012}, "test_scatter_gather_ops": {"TestScatterGatherCUDA": 44.214999999999996}, "test_schema_check": {"TestSchemaCheck": 4.345499999999998, "TestSchemaCheckModeOpInfoCUDA": 747.8529999999944}, "test_segment_reductions": {"TestSegmentReductionsCUDA": 7.594999999999997}, "test_serialization": {"TestBothSerializationCUDA": 0.001, "TestOldSerialization": 67.77600000000001, "TestSerialization": 14.023499999999993, "TestSubclassSerialization": 0.054000000000000006}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 2.4255}, "test_shape_ops": {"TestShapeOpsCUDA": 4.296999999999993}, "test_show_pickle": {"TestShowPickle": 0.0015}, "test_sort_and_select": {"TestSortAndSelectCUDA": 8.69899999999999}, "test_sparse": {"TestSparseAnyCUDA": 781.7555, "TestSparseCUDA": 61.15050000000004, "TestSparseLegacyAndDeprecation": 2.0175, "TestSparseMaskedReductionsCUDA": 2.9765, "TestSparseMeta": 5.9435, "TestSparseOneOff": 1.9554999999999998, "TestSparseUnaryUfuncsCUDA": 52.25750000000012}, "test_sparse_csr": {"TestSparseCSRCUDA": 295.1540000000018, "TestSparseCSRSampler": 2.997, "TestSparseCompressedCUDA": 213.00799999999896, "TestSparseCompressedTritonKernelsCUDA": 0.015000000000000003}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005, "TestCUSPARSELTCUDA": 0.056000000000000036, "TestSparseSemiStructuredCUDA": 0.1465000000000001, "TestSparseSemiStructuredCUSPARSELTCUDA": 0.04200000000000002, "TestSparseSemiStructuredCUTLASSCUDA": 0.02400000000000001, "TestSparseSemiStructuredTrainingCUDA": 0.030000000000000016}, "test_spectral_ops": {"TestFFTCUDA": 44.67850000000004}, "test_stateless": {"TestPythonOptimizeMode": 8.948, "TestStatelessDeprecation": 3.2045, "TestStatelessFunctionalAPI": 2.3799999999999963}, "test_subclass": {"TestSubclass": 2.7979999999999956}, "test_sympy_utils": {"TestNumbers": 1.3579999999999999, "TestSingletonInt": 0.0095, "TestSympyInterp": 14.546499999999998, "TestSympySolve": 0.31050000000000005, "TestValueRanges": 13.665499999999998}, "test_tensor_creation_ops": {"TestAsArrayCUDA": 0.9425000000000007, "TestLikeTensorCreationCUDA": 0.019000000000000003, "TestRandomTensorCreationCUDA": 0.3355000000000001, "TestTensorCreationCUDA": 140.07899999999944}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.036500000000000005, "TestTensorBoardFigure": 0.003, "TestTensorBoardNumpy": 0.0105, "TestTensorBoardPyTorchNumpy": 2.3804999999999996, "TestTensorBoardPytorchGraph": 0.503, "TestTensorBoardSummary": 0.08350000000000002, "TestTensorBoardSummaryWriter": 0.022000000000000002, "TestTensorBoardUtils": 0.3095, "TestTensorBoardWriter": 0.7010000000000001, "TestTensorProtoSummary": 0.0235}, "test_tensorexpr": {"TestTensorExprFuser": 117.26850000000002}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.017, "TestTensorExprPyBind": 2.501499999999998}, "test_testing": {"TestAssertClose": 0.2370000000000001, "TestAssertCloseContainer": 0.012, "TestAssertCloseErrorMessage": 0.093, "TestAssertCloseMultiDeviceCUDA": 0.015, "TestAssertCloseQuantized": 0.018500000000000003, "TestAssertCloseSparseBSC": 0.0285, "TestAssertCloseSparseBSR": 0.03, "TestAssertCloseSparseCOO": 0.04000000000000001, "TestAssertCloseSparseCSC": 0.0305, "TestAssertCloseSparseCSR": 0.0295, "TestFrameworkUtils": 0.0015, "TestImports": 8.9345, "TestMakeTensorCUDA": 3.2549999999999697, "TestOpInfoSampleFunctionsCUDA": 16.556500000000018, "TestOpInfos": 0.008, "TestTestParametrization": 0.06100000000000003, "TestTestParametrizationDeviceTypeCUDA": 5.644999999999996, "TestTestingCUDA": 6.992999999999995}, "test_torch": {"TestBasicVitalSigns": 2.1645, "TestDevicePrecisionCUDA": 0.11950000000000005, "TestTorch": 16.289500000000007, "TestTorchDeviceTypeCUDA": 380.6965000000008, "TestVitalSignsCudaCUDA": 0.003}, "test_transformers": {"TestAttnBiasCUDA": 0.09400000000000003, "TestAttnMasksCUDA": 0.09800000000000003, "TestSDPACUDA": 4.669999999999839, "TestSDPACudaOnlyCUDA": 540.1755000000356, "TestSDPAFailureModesCUDA": 0.11050000000000006, "TestTransformersCUDA": 11.294999999999995}, "test_type_hints": {"TestTypeHints": 0.0015}, "test_type_info": {"TestDTypeInfo": 2.44}, "test_type_promotion": {"TestTypePromotionCUDA": 21.550500000000117}, "test_typing": {"TestTyping": 0.0045000000000000005}, "test_unary_ufuncs": {"TestUnaryUfuncsCUDA": 1524.8699999998287}, "test_utils": {"TestAssert": 0.123, "TestBottleneck": 38.0275, "TestCheckpoint": 2.0714999999999986, "TestCollectEnv": 5.122, "TestCppExtensionUtils": 0.006, "TestDataLoaderUtils": 35.8495, "TestDeviceUtilsCUDA": 47.78849999999921, "TestExtensionUtils": 0.007, "TestHipify": 0.003, "TestHipifyTrie": 0.012, "TestONNXUtils": 0.008, "TestRenderUtils": 0.0215, "TestStandaloneCPPJIT": 20.805, "TestTraceback": 0.0165}, "test_view_ops": {"TestOldViewOpsCUDA": 24.737999999999992, "TestViewOpsCUDA": 4.33749999999998}, "test_vulkan": {"TestVulkanRewritePass": 0.0015}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.033, "WeakKeyDictionaryTestCase": 0.045500000000000006, "WeakTest": 8.3455}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 7.408, "TestXNNPACKRewritePass": 2.6479999999999997, "TestXNNPACKSerDes": 7.3765}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.017}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 2.547999999999996, "TestClassGetItem": 0.0075, "TestDtypeAttributeDeletion": 0.0, "TestFromDTypeAttribute": 0.0045000000000000005, "TestMisc": 0.0075, "TestPickling": 0.19100000000000006, "TestPromotion": 0.013500000000000003}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 24.133, "TestEinsumPath": 0.008, "TestMisc": 0.0115}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0, "TestFinfo": 0.003, "TestHalf": 0.0015, "TestIinfo": 2.4525, "TestMisc": 0.0075, "TestPythonFloat": 0.0015, "TestRepr": 0.006, "TestSingle": 0.0005}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.004, "TestBooleanIndexing": 0.01, "TestBroadcastedAssignments": 0.0305, "TestFancyIndexingCast": 0.007, "TestFloatNonIntegerArgument": 0.017, "TestIndexing": 2.639999999999996, "TestMultiIndexingAutomated": 0.015500000000000002, "TestMultipleEllipsisError": 0.003, "TestNonIntegerArrayLike": 0.0015}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.07000000000000002, "TestArgmax": 2.0090000000000003, "TestArgmaxArgminCommon": 0.3010000000000002, "TestArgmin": 2.097, "TestArrayAttributeDeletion": 0.019, "TestArrayConstruction": 0.07900000000000003, "TestArrayCreationCopyArgument": 0.032500000000000015, "TestArrayInterface": 0.020000000000000004, "TestAssignment": 0.022000000000000006, "TestAttributes": 0.03250000000000001, "TestBinop": 0.026999999999999996, "TestBool": 42.455999999999996, "TestCequenceMethods": 0.004, "TestChoose": 0.042, "TestClip": 0.012, "TestCompress": 0.011, "TestConversion": 0.0765, "TestCreation": 0.012500000000000002, "TestDelMisc": 0.003, "TestDot": 0.13350000000000006, "TestDtypedescr": 0.004, "TestFancyIndexing": 0.054, "TestFlag": 0.020500000000000004, "TestFormat": 0.0135, "TestFromBuffer": 0.0315, "TestHash": 2.9215, "TestHashing": 0.008, "TestIO": 0.017500000000000005, "TestInner": 0.473, "TestLexsort": 0.04650000000000001, "TestMatmul": 0.8330000000000002, "TestMatmulOperator": 0.47800000000000004, "TestMethods": 2.615, "TestMinMax": 0.009000000000000001, "TestMinScalarType": 0.0165, "TestNewaxis": 0.007, "TestPEP3118Dtype": 0.013500000000000002, "TestPutmask": 0.026000000000000002, "TestRepeat": 0.029, "TestResize": 0.08750000000000001, "TestRichcompareScalar": 0.0015, "TestScalarIndexing": 0.035, "TestSizeOf": 0.011000000000000001, "TestSortFloatMisc": 0.35500000000000004, "TestStats": 0.41150000000000003, "TestSubscripting": 0.003, "TestTake": 0.05950000000000001, "TestVdot": 0.05950000000000001, "TestViewDtype": 0.008, "TestWarnings": 0.0045000000000000005, "TestWhere": 0.6220000000000001, "TestWritebackIfCopy": 0.056499999999999995}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.0325, "TestArgwhere": 0.053000000000000005, "TestArrayComparisons": 0.020000000000000004, "TestBaseRepr": 0.012, "TestBinaryRepr": 0.018000000000000002, "TestBoolArray": 3.3785, "TestBoolCmp": 0.26149999999999995, "TestBoolScalar": 0.021, "TestBroadcast": 0.013500000000000002, "TestClip": 0.3175000000000002, "TestConvolve": 0.033, "TestCorrelate": 0.05500000000000001, "TestCreationFuncs": 1.5904999999999998, "TestCross": 0.0805, "TestDtypePositional": 0.0035, "TestFloatExceptions": 0.018500000000000003, "TestFromiter": 0.0015, "TestIndex": 0.009000000000000001, "TestIndices": 0.07200000000000001, "TestIsclose": 0.137, "TestIsscalar": 0.003, "TestLikeFuncs": 0.005, "TestMoveaxis": 0.0165, "TestNonarrayArgs": 0.18750000000000006, "TestNonzeroAndCountNonzero": 0.373, "TestOuterMisc": 0.01, "TestRequire": 0.012, "TestResize": 2.436, "TestRoll": 0.0515, "TestRollaxis": 0.008, "TestSeterr": 0.012, "TestStdVar": 0.043500000000000004, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.0035, "TestTensordot": 0.03, "TestTypes": 0.026000000000000002}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.003, "TestCommonType": 2.466, "TestDocStrings": 0.0, "TestIsSubDType": 0.018000000000000002, "TestScalarTypeNames": 0.06300000000000003}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.18350000000000014, "TestFromInt": 0.0105, "TestFromString": 2.4355}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.0055, "TestBitCount": 0.002, "TestClassGetItem": 0.007, "TestClassGetitemMisc": 0.0045000000000000005, "TestIsInteger": 0.012500000000000002}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.0025}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.15499999999999997, "TestBaseMath": 14.2145, "TestBitShifts": 0.14150000000000001, "TestComplexDivision": 0.0905, "TestConversion": 0.081, "TestHash": 0.002, "TestModulus": 1.5179999999999998, "TestMultiply": 0.0015, "TestNegative": 0.0325, "TestPower": 0.198, "TestRepr": 0.003, "TestScalarOpsMisc": 0.10200000000000006, "TestScalarSubclassingMisc": 0.11700000000000008, "TestSubtract": 0.027000000000000003, "TestTypes": 25.744999999999997}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 2.5849999999999995, "TestAtleast2d": 0.031, "TestAtleast3d": 0.0305, "TestBlock": 0.06050000000000003, "TestConcatenate": 0.2725000000000002, "TestHstack": 0.043, "TestStackMisc": 0.031500000000000014, "TestVstack": 0.045500000000000006}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.0165, "TestFFTShift": 11.4635, "TestIRFFTN": 0.0075, "TestRFFTFreq": 0.0165}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 4.0954999999999995, "TestFFTShift": 2.4509999999999996, "TestFFTThreadSafe": 0.948}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 2.6224999999999996}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.017, "TestUnique": 2.6534999999999993}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.0105, "TestAmax": 0.0095, "TestAmin": 0.0105, "TestAngle": 0.0125, "TestAny": 0.0105, "TestAverage": 0.04650000000000001, "TestBincount": 0.0755, "TestCheckFinite": 0.006, "TestCopy": 0.013000000000000001, "TestCorrCoef": 0.06050000000000001, "TestCov": 0.09900000000000002, "TestCumprod": 0.049, "TestCumsum": 0.062, "TestDelete": 0.028000000000000004, "TestDiff": 0.1175, "TestDigitize": 0.03300000000000001, "TestExtins": 0.0105, "TestFilterwindows": 0.9740000000000006, "TestFlip": 0.053500000000000006, "TestGradient": 0.24300000000000005, "TestInsert": 0.021000000000000005, "TestInterp": 0.13800000000000007, "TestKaiser": 0.018000000000000002, "TestMedian": 0.17300000000000004, "TestMeshgrid": 0.0915, "TestMsort": 0.0015, "TestPercentile": 0.31650000000000017, "TestPiecewise": 0.024, "TestProd": 0.0475, "TestPtp": 0.014499999999999999, "TestQuantile": 0.11050000000000001, "TestRot90": 2.4979999999999998, "TestSelect": 0.018000000000000002, "TestSinc": 0.0145, "TestSortComplex": 0.021, "TestTrapz": 0.011, "TestTrimZeros": 0.024, "TestUnique": 0.007, "Test_I0": 0.022}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 2.666999999999998, "TestHistogramOptimBinNums": 0.052500000000000026, "TestHistogramdd": 0.20650000000000004}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.003, "TestConcatenator": 0.018000000000000002, "TestDiagIndices": 0.0085, "TestDiagIndicesFrom": 0.013500000000000002, "TestFillDiagonal": 0.043000000000000003, "TestGrid": 0.025500000000000002, "TestIndexExpression": 0.0165, "TestIx_": 0.015, "TestNdIndex": 0.003, "TestNdenumerate": 0.003, "TestRavelUnravelIndex": 2.484}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.030000000000000006, "TestApplyOverAxes": 0.003, "TestArraySplit": 0.25150000000000006, "TestColumnStack": 0.017, "TestDsplit": 0.0195, "TestDstack": 0.030000000000000006, "TestExpandDims": 0.013000000000000001, "TestHsplit": 0.021, "TestKron": 0.029500000000000005, "TestMayShareMemory": 0.003, "TestPutAlongAxis": 0.0165, "TestSplit": 0.0105, "TestSqueeze": 0.053000000000000005, "TestTakeAlongAxis": 2.4445, "TestTile": 0.131, "TestVsplit": 0.0165}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.05, "TestEye": 2.6024999999999996, "TestFliplr": 0.009000000000000001, "TestFlipud": 0.008, "TestHistogram2d": 0.064, "TestTri": 0.182, "TestTrilIndicesFrom": 0.0045000000000000005, "TestTriuIndices": 0.007, "TestTriuIndicesFrom": 0.0035, "TestVander": 0.031}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.003, "TestCommonType": 2.475, "TestImag": 0.02, "TestIscomplex": 0.009000000000000001, "TestIscomplexobj": 0.009000000000000001, "TestIsfinite": 0.027, "TestIsinf": 0.018000000000000002, "TestIsnan": 0.0225, "TestIsneginf": 0.003, "TestIsposinf": 0.004, "TestIsreal": 0.0145, "TestIsrealobj": 0.003, "TestIsscalar": 0.003, "TestMintypecode": 0.0095, "TestNanToNum": 0.027000000000000003, "TestReal": 0.0225, "TestRealIfClose": 0.006500000000000001}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.28700000000000003, "TestCond": 0.3465, "TestDet": 0.23650000000000004, "TestEig": 0.06150000000000001, "TestEigh": 0.042000000000000016, "TestEighCases": 0.0, "TestEigvals": 0.0965, "TestEigvalsh": 0.03750000000000001, "TestEigvalshCases": 0.0, "TestInv": 0.08450000000000002, "TestLstsq": 0.3265, "TestMatrixRank": 0.541, "TestMisc": 0.014000000000000002, "TestMisc2": 0.0075, "TestMultiDot": 0.09500000000000003, "TestNormDouble": 1.2385, "TestNormInt64": 1.23, "TestNormSingle": 1.232, "TestNorm_NonSystematic": 0.006, "TestPinv": 0.17149999999999999, "TestPinvHermitian": 0.05450000000000001, "TestQR": 7.973000000000001, "TestSVD": 0.07700000000000001, "TestSVDHermitian": 0.157, "TestSolve": 0.5635, "TestTensorinv": 0.03900000000000001, "TestTensorsolve": 0.029500000000000002}, "torch_np/test_basic": {"TestArrayToSequence": 0.018000000000000002, "TestCopyTo": 0.0115, "TestCtorNested": 0.006, "TestDefaultDtype": 0.013500000000000002, "TestDivmod": 0.028000000000000004, "TestExport": 0.0, "TestMisc": 1.6520000000000001, "TestNormalizations": 0.009000000000000001, "TestOneArr": 2.6909999999999994, "TestOneArrAndAxesTuple": 0.027000000000000003, "TestOneArrAndAxis": 0.41000000000000025, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.027000000000000003, "TestPythonArgsToArray": 0.033, "TestSequenceOfArrays": 0.04800000000000002, "TestSequenceOfArraysToSingle": 0.021, "TestShapeLikeToArray": 0.012, "TestSmokeNotImpl": 0.003}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 2.4529999999999945}, "torch_np/test_dtype": {"TestConvertDType": 2.5435}, "torch_np/test_function_base": {"TestAppend": 2.449}, "torch_np/test_ndarray_methods": {"TestAmax": 0.012, "TestAmin": 0.012, "TestArgmax": 1.7085000000000004, "TestArgmaxArgminCommon": 2.3004999999999964, "TestArgmin": 1.8790000000000004, "TestContains": 0.003, "TestIndexing": 2.3865, "TestIter": 0.009000000000000001, "TestNoExtraMethods": 0.018000000000000002, "TestNonzero": 0.2165, "TestRavel": 0.0115, "TestReshape": 0.0075, "TestTranspose": 0.015}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.5465000000000003, "TestNEP50Table": 0.006}, "torch_np/test_random": {"TestChoice": 0.018, "TestNumpyGlobal": 0.0075, "TestScalarReturn": 2.5425, "TestShuffle": 0.024}, "torch_np/test_reductions": {"TestAll": 0.018500000000000003, "TestAny": 0.0205, "TestFlatnonzero": 2.4595000000000002, "TestGenericCumSumProd": 0.035, "TestGenericReductions": 3.9339999999999518, "TestMean": 0.036, "TestSum": 0.3380000000000001}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 2.514499999999999, "TestIsScalar": 0.06000000000000003}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 1.0370000000000008, "TestNdarrayDunderVsUfunc": 0.33750000000000024, "TestUfuncDtypeKwd": 0.009000000000000001, "TestUnaryUfuncs": 2.646999999999997}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 2.538999999999995}}, "force_on_cpu": {"backends/xeon/test_launch": {"TestTorchrun": 0.003}, "benchmark_utils/test_benchmark_utils": {"TestBenchmarkUtils": 0.9240000000000002}, "distributions/test_distributions": {"TestAgainstScipy": 2.338, "TestConstraints": 0.2855, "TestDistributionShapes": 0.3390000000000002, "TestDistributions": 67.44049999999999, "TestFunctors": 0.03, "TestJit": 18.587, "TestKL": 6.545499999999999, "TestLazyLogitsInitialization": 0.028499999999999998, "TestNumericalStability": 0.15100000000000005, "TestRsample": 1.573, "TestValidation": 0.679}, "export/test_converter": {"TestConverter": 6.628499999999999}, "export/test_db": {"ExampleTests": 0.019500000000000007}, "export/test_export": {"TestDynamismExpression": 1.0145, "TestExport": 0.033500000000000016, "TestExportCustomClass": 0.17500000000000002, "TestOneOffModelExportResult": 1.8080000000000003}, "export/test_functionalized_assertions": {"TestFuntionalAssertions": 0.47050000000000003}, "export/test_funtionalized_assertions": {"TestFuntionalAssertions": 1.5499999999999998}, "export/test_hop": {"TestHOPGeneric": 0.0085}, "export/test_lift_unlift": {"ConstantAttrMapTest": 0.003, "TestLift": 0.16, "TestLiftUnlift": 0.020499999999999997}, "export/test_pass_infra": {"TestPassInfra": 1.4255}, "export/test_passes": {"TestPasses": 20.280499999999996}, "export/test_safeguard": {"TestSafeguard": 0.9299999999999999}, "export/test_schema": {"TestSchema": 0.552}, "export/test_serialize": {"TestDeserialize": 0.023500000000000007, "TestOpVersioning": 0.008, "TestSaveLoad": 0.5704999999999999, "TestSchemaVersioning": 0.0545, "TestSerialize": 2.1295, "TestSerializeCustomClass": 0.1695}, "export/test_sparse": {"TestSparseProp": 115.015}, "export/test_tools": {"TestExportTools": 1.3215}, "export/test_torchbind": {"TestCompileTorchbind": 1.7770000000000006, "TestExportTorchbind": 3.2069999999999994, "TestRegisterFakeClass": 0.006}, "export/test_tree_utils": {"TestTreeUtils": 0.47750000000000004}, "export/test_unflatten": {"TestUnflatten": 4.955500000000001}, "export/test_upgrade": {"TestUpgrade": 1.0289999999999997}, "export/test_verifier": {"TestVerifier": 1.576}, "functorch/test_aotdispatch": {"TestAOTAutograd": 20.392499999999988, "TestAOTAutogradWithDynamo": 22.143500000000003, "TestAOTDispatch": 0.8444999999999999, "TestAOTExport": 1.4885000000000002, "TestAOTModuleSimplified": 1.4325, "TestPartitioning": 1.6804999999999999}, "functorch/test_control_flow": {"TestControlFlow": 0.0055, "TestControlFlowTraced": 0.04850000000000003}, "functorch/test_dims": {"TestMin": 20.742, "TestMinFunctorchOnly": 19.195}, "functorch/test_eager_transforms": {"TestMakeFunctional": 0.20700000000000007, "TestSliceArgnums": 0.035}, "functorch/test_logging": {"TestAOTLogging": 0.542}, "functorch/test_memory_efficient_fusion": {"NoChangeTestCase": 1.2215, "RandomOpTestCase": 0.138, "ReduceTestCase": 0.17149999999999999, "TestMemoryEfficientOpAuthoring": 0.0055}, "functorch/test_minifier": {"TestMinifier": 0.8300000000000001}, "functorch/test_parsing": {"TestAnonymousAxis": 0.5115, "TestParsedExpression": 0.011, "TestParsingUtils": 0.012, "TestValidateRearrangeExpressions": 0.012}, "functorch/test_rearrange": {"TestRearrange": 0.5815000000000001}, "functorch/test_vmap": {"TestVmapAPI": 0.5540000000000003, "TestVmapOperators": 4.791499999999992}, "functorch/test_vmap_registrations": {"TestFunctorchDispatcher": 6.850999999999748}, "higher_order_ops/test_with_effects": {"TestWithEffects": 1.2695000000000003}, "inductor/test_fx_fusion": {"TestFxFusion": 0.35100000000000003}, "lazy/test_debug_util": {"DebugUtilTest": 0.0015}, "lazy/test_functionalization": {"LazyFuncionalizationTest": 0.573}, "lazy/test_generator": {"LazyGeneratorTest": 0.6074999999999999}, "lazy/test_reuse_ir": {"TestLazyReuseIr": 0.003}, "lazy/test_step_closures": {"ClosuresTest": 3.4825}, "lazy/test_ts_opinfo": {"TestLazyDynamicOps": 0.5125, "TestLazyTensor": 0.1395}, "nn/test_convolution": {"TestConvolutionNN": 30.475500000000004}, "nn/test_dropout": {"TestDropoutNN": 0.139}, "nn/test_embedding": {"TestEmbeddingNN": 0.13150000000000006}, "nn/test_init": {"TestNNInit": 240.67749999999992}, "nn/test_lazy_modules": {"TestLazyModules": 0.5900000000000003}, "nn/test_load_state_dict": {"TestLoadStateDict": 1.137, "TestLoadStateDictSwap": 0.08050000000000002}, "nn/test_module_hooks": {"TestModuleGlobalHooks": 0.045, "TestModuleHookNN": 0.157, "TestModuleHooks": 0.15000000000000002, "TestStateDictHooks": 0.0555}, "nn/test_multihead_attention": {"TestMultiheadAttentionNN": 9.7045}, "nn/test_packed_sequence": {"PackedSequenceTest": 0.8315000000000001}, "nn/test_parametrization": {"TestNNParametrization": 1.4895}, "nn/test_pooling": {"TestAvgPool": 0.4625, "TestPoolingNN": 0.735}, "nn/test_pruning": {"TestPruningNN": 0.21850000000000008}, "profiler/test_execution_trace": {"TestExecutionTrace": 0.41350000000000003}, "profiler/test_memory_profiler": {"TestDataFlow": 1.478, "TestIdentifyGradients": 0.3075, "TestMemoryProfiler": 0.491, "TestMemoryProfilerE2E": 5.8905}, "profiler/test_profiler": {"TestExecutionTrace": 0.101, "TestExperimentalUtils": 10.4575, "TestProfiler": 21.0245, "TestProfilerCUDA": 0.0015, "TestProfilerITT": 0.009000000000000001, "TestRecordFunction": 0.055, "TestTorchTidyProfiler": 4.579999999999999}, "profiler/test_profiler_tree": {"TestProfilerTree": 0.6505000000000001}, "profiler/test_record_function": {"TestRecordFunction": 0.539}, "profiler/test_torch_tidy": {"TestTorchTidyProfiler": 5.1754999999999995}, "test_ao_sparsity": {"TestActivationSparsifier": 0.1345, "TestBaseDataScheduler": 0.06, "TestBaseDataSparsifier": 0.1395, "TestBaseSparsifier": 0.05450000000000001, "TestBaseStructuredSparsifier": 2.8375000000000004, "TestComposability": 3.299, "TestCubicScheduler": 0.0075, "TestFPGMPruner": 0.0505, "TestFakeSparsity": 0.134, "TestFxComposability": 2.9485, "TestNearlyDiagonalSparsifier": 1.3170000000000002, "TestNormDataSparsifiers": 1.4049999999999998, "TestQuantizationUtils": 0.052000000000000005, "TestQuantizedSparseKernels": 0.483, "TestQuantizedSparseLayers": 0.3655, "TestSaliencyPruner": 0.0615, "TestScheduler": 0.025, "TestSparsityUtilFunctions": 0.0865, "TestWeightNormSparsifier": 0.4645}, "test_autocast": {"TestAutocastCPU": 3.28, "TestAutocastGPU": 0.002, "TestTorchAutocast": 0.014}, "test_autograd": {"TestAllowMutationOnSaved": 0.06000000000000001, "TestAutograd": 49.128000000000014, "TestAutogradComplex": 0.0115, "TestAutogradForwardMode": 0.15750000000000008, "TestAutogradForwardModeBatchedGrad": 0.031000000000000003, "TestAutogradFunctional": 15.432499999999985, "TestAutogradInferenceMode": 0.07350000000000002, "TestAutogradLogging": 0.036000000000000004, "TestMultithreadAutograd": 0.3295, "TestNestedCheckpoint": 0.6785000000000001, "TestSelectiveActivationCheckpoint": 0.028999999999999998}, "test_autograd_fallback": {"TestAutogradFallback": 0.6680000000000001}, "test_bundled_inputs": {"TestBundledInputs": 2.079999999999999}, "test_comparison_utils": {"TestComparisonUtils": 0.48350000000000004}, "test_compile_benchmark_util": {"TestCompileBenchmarkUtil": 0.0015}, "test_cpp_api_parity": {"TestCppApiParity": 8.184000000000012}, "test_cpp_extensions_aot_ninja": {"TestCppExtensionAOT": 0.0475, "TestMAIATensor": 0.018000000000000002, "TestORTTensor": 0.634, "TestPybindTypeCasters": 0.0045000000000000005, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.0015}, "test_cpp_extensions_aot_no_ninja": {"TestCppExtensionAOT": 0.04700000000000001, "TestMAIATensor": 0.018000000000000002, "TestORTTensor": 0.634, "TestPybindTypeCasters": 0.0045000000000000005, "TestRNGExtension": 0.006, "TestTorchLibrary": 0.0015}, "test_cpp_extensions_jit": {"TestCppExtensionJIT": 338.1355}, "test_cpp_extensions_mtia_backend": {"TestCppExtensionMTIABackend": 0.0075}, "test_cpp_extensions_open_device_registration": {"TestCppExtensionOpenRgistration": 23.981}, "test_cpp_extensions_stream_and_event": {"TestCppExtensionStreamAndEvent": 0.0015}, "test_custom_backend": {"TestCustomBackend": 0.15000000000000002}, "test_custom_ops": {"MiniOpTest": 1.0515000000000003, "MiniOpTestOther": 0.10600000000000004, "TestCustomOp": 22.456999999999997, "TestCustomOpAPI": 0.20050000000000007, "TestCustomOperators": 0.337, "TestGenerateOpcheckTests": 5.302}, "test_dataloader": {"IntegrationTestDataLoaderDataPipe": 0.0015, "TestConcatDataset": 0.023, "TestConvAfterFork": 0.0015, "TestCustomPinFn": 0.003, "TestDataLoader": 360.31549999999993, "TestDataLoaderPersistentWorkers": 366.642, "TestDatasetRandomSplit": 0.064, "TestDictDataLoader": 5.372, "TestIndividualWorkerQueue": 0.0015, "TestNamedTupleDataLoader": 0.006, "TestSetAffinity": 0.0015, "TestStackDataset": 0.05700000000000001, "TestStringDataLoader": 0.0015, "TestTensorDataset": 0.041999999999999996}, "test_datapipe": {"TestCaptureDataFrame": 0.0015, "TestCircularSerialization": 0.009000000000000001, "TestDataChunk": 0.0105, "TestDataFramesPipes": 0.009000000000000001, "TestFunctionalIterDataPipe": 5.8495, "TestFunctionalMapDataPipe": 0.08399999999999999, "TestGraph": 0.028, "TestIterDataPipeCountSampleYielded": 0.0235, "TestIterDataPipeGraphFastForward": 0.0735, "TestIterDataPipeSingletonConstraint": 0.0425, "TestIterableDataPipeBasic": 0.0885, "TestSerialization": 0.003, "TestSharding": 11.194500000000001, "TestStreamWrapper": 0.48650000000000004, "TestTyping": 0.015000000000000003}, "test_decomp": {"HasDecompTest": 0.314}, "test_deploy": {"TestFreezer": 0.4625}, "test_dispatch": {"TestDispatch": 79.6545, "TestPythonDispatcher": 0.033}, "test_dynamic_shapes": {"TestDimConstraints": 4.455, "TestFloorDiv": 0.019500000000000003, "TestGuardsExpressions": 0.026000000000000002, "TestPySymInt": 2.986999999999998, "TestSymNumberMagicMethods": 3.6104999999999947}, "test_fake_tensor": {"FakeTensorConstHandling": 0.12600000000000003, "FakeTensorConverterTest": 0.05450000000000001, "FakeTensorDispatchCache": 0.14350000000000002, "FakeTensorOperatorInvariants": 0.6215, "FakeTensorPropTest": 0.119, "FakeTensorSerialization": 0.0105, "FakeTensorTest": 1.4400000000000004, "PropagateRealTensorsFakeTensorConstHandling": 0.18100000000000005, "PropagateRealTensorsFakeTensorConverterTest": 0.053000000000000005, "PropagateRealTensorsFakeTensorOperatorInvariants": 0.35250000000000004, "PropagateRealTensorsFakeTensorPropTest": 0.0835, "PropagateRealTensorsFakeTensorTest": 0.5180000000000001}, "test_flop_counter": {"TestFlopCounter": 0.3480000000000001}, "test_function_schema": {"TestFunctionSchema": 1.0525}, "test_functional_autograd_benchmark": {"TestFunctionalAutogradBenchmark": 0.003}, "test_functional_optim": {"TestFunctionalOptimParity": 0.6765}, "test_functionalization": {"TestCrossRefFunctionalization": 3.637999999999999, "TestFunctionalization": 4.088}, "test_futures": {"TestFuture": 1.4480000000000002}, "test_fx": {"AnnotationsTest": 0.030000000000000006, "TestCSEPass": 0.5055000000000001, "TestCommonPass": 0.1235, "TestConstFold": 0.25250000000000006, "TestConstParamShapeInControlFlow": 0.068, "TestDCE": 0.0495, "TestFX": 10.023499999999975, "TestFXAPIBackwardCompatibility": 0.06, "TestFunctionalTracing": 0.6475000000000005, "TestMatcher": 0.119, "TestPassManager": 0.0455, "TestSourceMatcher": 2.9155, "TestSubgraphRewriter": 0.43600000000000017, "TypeCheckerTest": 0.4545000000000001}, "test_fx_experimental": {"TestFXExperimental": 2.8789999999999987, "TestTranslationValidation": 0.265}, "test_fx_passes": {"TestFXGraphPasses": 1.0900000000000003, "TestFXMatcherUtils": 0.14500000000000005}, "test_fx_reinplace_pass": {"TestReinplacePass": 0.8065}, "test_import_stats": {"TestImportTime": 6.349}, "test_itt": {"TestItt": 0.477}, "test_jit": {"TestAliasAnalysis": 0.5485000000000001, "TestAsync": 0.5535000000000001, "TestAtenPow": 0.014, "TestAutodiffJit": 0.15350000000000003, "TestAutodiffSubgraphSlicing": 0.4910000000000002, "TestAwait": 0.31700000000000006, "TestBackends": 0.0045000000000000005, "TestBackendsWithCompiler": 0.003, "TestBatchMM": 0.127, "TestBuiltins": 0.0935, "TestClassType": 3.789999999999999, "TestComplex": 1.3130000000000002, "TestCustomOperators": 0.0775, "TestDCE": 0.028499999999999998, "TestDataParallel": 0.0075, "TestDataclasses": 7.167999999999999, "TestDeviceAnalysis": 0.24950000000000003, "TestDict": 0.6300000000000003, "TestDtypeAnalysis": 0.253, "TestEnum": 0.31450000000000006, "TestFreezing": 3.6779999999999995, "TestFrontend": 0.624, "TestFrozenOptimizations": 14.813000000000006, "TestFunctionalBlocks": 0.0105, "TestFunctionalToInplaceActivation": 0.156, "TestGenerator": 0.12, "TestGetDefaultAttr": 0.029, "TestGraphRewritePasses": 0.08299999999999999, "TestHash": 0.11999999999999998, "TestHooks": 1.0820000000000005, "TestIgnorableArgs": 0.019000000000000003, "TestIgnoreContextManager": 0.0045000000000000005, "TestInplaceToFunctionalActivation": 0.0775, "TestIsinstance": 0.3370000000000001, "TestJit": 9.311999999999994, "TestJitGeneratedModule": 21.304000000000062, "TestJitProfiler": 0.0015, "TestJitUtils": 0.03350000000000001, "TestList": 1.8245000000000007, "TestLogging": 0.07800000000000001, "TestMKLDNNReinplacing": 0.29400000000000004, "TestMisc": 0.2855000000000001, "TestMixTracingScripting": 2.0735, "TestModels": 2.2115, "TestModuleAPIs": 0.239, "TestModuleContainers": 1.8849999999999998, "TestModuleInterface": 0.9410000000000002, "TestModules": 0.0305, "TestNamedTuple": 0.11050000000000001, "TestNnapiBackend": 0.045000000000000026, "TestOpDecompositions": 0.0335, "TestOptimizeForMobilePreserveDebugInfo": 0.2775, "TestParametrization": 0.147, "TestPeephole": 0.7095000000000002, "TestProducerVersion": 0.004, "TestProfiler": 0.21200000000000008, "TestPythonBindings": 0.060000000000000005, "TestPythonBuiltinOP": 0.6295000000000002, "TestPythonIr": 0.0385, "TestRecursiveScript": 1.1095000000000004, "TestRemoveMutation": 0.18200000000000002, "TestSaveLoad": 0.7160000000000002, "TestSaveLoadFlatbuffer": 0.7875000000000001, "TestSaveLoadForOpVersion": 2.745, "TestScript": 58.466000000000015, "TestScriptDict": 0.050499999999999996, "TestScriptList": 1.2570000000000001, "TestScriptModuleInstanceAttributeTypeAnnotation": 0.2395, "TestScriptProfile": 0.5609999999999999, "TestSlice": 0.23850000000000013, "TestSparse": 0.040999999999999995, "TestStringFormatting": 0.19000000000000006, "TestSymbolicShapeAnalysis": 2.339499999999999, "TestTensorBuiltins": 0.1175, "TestTensorCreationOps": 0.07150000000000001, "TestTensorMethods": 0.025, "TestTorchbind": 0.19000000000000009, "TestTracer": 4.576999999999997, "TestTypeSharing": 0.7135000000000002, "TestTypesAndAnnotation": 0.19200000000000003, "TestTyping": 0.5915000000000004, "TestUnion": 0.6990000000000003, "TestUnsupportedOps": 0.043, "TestUpgraders": 0.11450000000000002, "TestWarn": 0.08750000000000001, "TestWith": 0.5}, "test_jit_autocast": {"TestAutocast": 0.23300000000000004, "TestJitTraceAutocast": 16.019499999999997}, "test_jit_disabled": {"TestJitDisabled": 0.8654999999999999}, "test_jit_fuser_te": {"TestFuserCommon": 0.1265, "TestTEFuserDynamic": 249.5925000000001, "TestTEFuserStatic": 236.579}, "test_jit_llga_fuser": {"TestDynamoAOT": 0.0015, "TestEnableDisableLlgaFuser": 0.0015, "TestModel": 0.05000000000000003}, "test_legacy_vmap": {"TestVmapAPI": 2.4379999999999966, "TestVmapAPILegacy": 1.933499999999998, "TestVmapOperators": 1.1929999999999998, "TestVmapOperatorsLegacy": 1.7489999999999997}, "test_license": {"TestLicense": 0.003}, "test_logging": {"LoggingTest": 3.5700000000000003}, "test_maskedtensor": {"TestBinary": 0.6345000000000005, "TestReductions": 0.12550000000000003, "TestUnary": 0.7245000000000006}, "test_meta": {"TestMetaConverter": 0.11200000000000004}, "test_mkl_verbose": {"TestMKLVerbose": 6.750500000000001}, "test_mkldnn_fusion": {"TestMkldnnFusion": 294.697}, "test_mkldnn_verbose": {"TestMKLDNNVerbose": 6.927}, "test_mobile_optimizer": {"TestOptimizer": 1.4445}, "test_model_dump": {"TestModelDump": 0.7100000000000001}, "test_model_exports_to_core_aten": {"TestQuantizePT2EModels": 0.0015}, "test_module_tracker": {"TestModuleTracker": 0.492}, "test_monitor": {"TestMonitor": 0.5055000000000001, "TestMonitorTensorboard": 0.6785}, "test_multiprocessing": {"TestMultiprocessing": 946.8289999999998}, "test_multiprocessing_spawn": {"ErrorTest": 0.0035, "ForkTest": 0.005, "SpawnTest": 47.66700000000001}, "test_namedtensor": {"TestNamedTensor": 0.7150000000000003}, "test_namedtuple_return_api": {"TestNamedTupleAPI": 3.205}, "test_native_functions": {"TestNativeFunctions": 0.6880000000000002}, "test_nestedtensor": {"TestNestedTensor": 0.2825000000000002}, "test_nn": {"TestAddRelu": 0.0085, "TestConstantPadNd": 0.0075, "TestFunctionalPickle": 0.004, "TestFusionEval": 0.522, "TestFusionUtils": 0.011, "TestNN": 78.44450000000003, "TestUtils": 0.008}, "test_numba_integration": {"TestNumbaIntegration": 0.012}, "test_openmp": {"TestOpenMP_ParallelFor": 6.733499999999999}, "test_ops": {"TestSelfKwarg": 0.0075}, "test_optim": {"TestDifferentiableOptimizer": 0.315, "TestLRScheduler": 1.6529999999999982, "TestOptim": 67.52666666666666, "TestSWAUtils": 0.26999999999999996}, "test_out_dtype_op": {"TestOutDtypeOp": 0.8190000000000001}, "test_overrides": {"TestBroadcastAllOverride": 0.0045000000000000005, "TestDisabledTorchFunction": 0.0045000000000000005, "TestDisabledUserWarnings": 0.003, "TestEinsumOverride": 0.006, "TestGradCheckOverride": 0.0315, "TestGradNewOnesOverride": 0.0035, "TestIndexing": 0.016, "TestIterator": 0.003, "TestNamedTuple": 0.0045000000000000005, "TestPickle": 0.0045000000000000005, "TestRNN": 0.006, "TestResolveName": 0.1545, "TestTorchFunctionMode": 0.08100000000000004, "TestTorchFunctionOverride": 4.79099999999981, "TestTorchFunctionWarning": 0.0195, "TestWrapTorchFunction": 0.0035}, "test_package": {"DirectoryReaderTest": 0.012, "ModelTest": 0.0045000000000000005, "TestAnalyze": 0.45399999999999996, "TestDependencyAPI": 0.09600000000000004, "TestDependencyHooks": 0.0225, "TestDiGraph": 0.04000000000000001, "TestGlobGroup": 0.05800000000000001, "TestImporter": 0.025, "TestLoadBCPackages": 0.10949999999999999, "TestMangling": 0.04, "TestMisc": 0.08000000000000002, "TestPackageFX": 0.0995, "TestPackageScript": 0.5515000000000001, "TestRepackage": 0.018000000000000002, "TestResources": 0.025, "TestSaveLoad": 0.07450000000000001}, "test_per_overload_api": {"TestPerOverloadAPI": 0.478}, "test_prims": {"TestPrimsBasic": 0.024}, "test_proxy_tensor": {"TestFakeProxyTensor": 0.21550000000000002, "TestGenericProxyTensorFake": 1.0385000000000004, "TestGenericProxyTensorReal": 0.9445000000000003, "TestGenericProxyTensorSymbolic": 1.4769999999999999, "TestRealProxyTensor": 0.037, "TestSymbolicTracing": 3.940499999999998}, "test_pruning_op": {"PruningOpTest": 0.718}, "test_public_bindings": {"TestPublicBindings": 0.489}, "test_python_dispatch": {"TestDispatcherPythonBindings": 0.009000000000000001, "TestPythonDispatch": 7.3955, "TestPythonDispatcher": 0.013500000000000002, "TestPythonRegistration": 0.385}, "test_pytree": {"TestCxxPytree": 0.02250000000000001, "TestGenericPytree": 0.7060000000000002, "TestPythonPytree": 0.12450000000000006}, "test_quantization": {"TestAOMigrationNNIntrinsic": 0.035, "TestAOMigrationNNQuantized": 0.07250000000000001, "TestAOMigrationQuantization": 0.04100000000000001, "TestAOMigrationQuantizationFx": 0.0565, "TestBackendConfig": 0.12400000000000004, "TestBiasCorrectionEager": 1.4329999999999998, "TestBits": 0.005, "TestComparatorOps": 2.1915, "TestDeprecatedJitQuantized": 6.743499999999999, "TestDistributed": 0.049999999999999996, "TestDuplicateDQPass": 0.006, "TestDynamicQuantizedModule": 24.0165, "TestDynamicQuantizedOps": 9.1625, "TestEqualizeEager": 0.178, "TestEqualizeFx": 6.8795, "TestFXGraphMatcher": 2.8845, "TestFXGraphMatcherModels": 0.003, "TestFXNumericSuiteCoreAPIs": 44.671, "TestFXNumericSuiteCoreAPIsModels": 34.3795, "TestFXNumericSuiteNShadows": 0.03600000000000002, "TestFakeQuantize": 0.48450000000000004, "TestFakeQuantizeOps": 3.285999999999999, "TestFuseEager": 3.7935, "TestFuseFx": 3.3184999999999993, "TestFusedObsFakeQuant": 0.14650000000000002, "TestFusedObsFakeQuantModule": 0.34049999999999997, "TestFusionPasses": 0.045, "TestFxDetectInputWeightEqualization": 0.26, "TestFxDetectOutliers": 0.444, "TestFxModelReportClass": 0.7170000000000001, "TestFxModelReportDetectDynamicStatic": 0.0955, "TestFxModelReportDetector": 0.1265, "TestFxModelReportObserver": 0.33649999999999997, "TestFxModelReportVisualizer": 0.381, "TestGenerateNumericDebugHandle": 0.003, "TestGraphUtils": 0.0045000000000000005, "TestHistogramObserver": 64.95100000000001, "TestMetaDataPorting": 0.0105, "TestModelNumericsEager": 0.775, "TestNumericSuiteEager": 7.301, "TestObserver": 6.5335, "TestPT2ERepresentation": 0.012, "TestPadding": 17.932000000000002, "TestQNNPackOps": 0.018000000000000006, "TestQuantizationDocs": 0.6445, "TestQuantizeDynamicJitOps": 2.7335000000000003, "TestQuantizeDynamicJitPasses": 6.045999999999999, "TestQuantizeEagerOps": 2.549, "TestQuantizeEagerPTQDynamic": 14.778999999999998, "TestQuantizeEagerPTQStatic": 28.439500000000002, "TestQuantizeEagerQAT": 7.8055, "TestQuantizeEagerQATNumerics": 3.101, "TestQuantizeFx": 46.64949999999999, "TestQuantizeFxModels": 3.908499999999999, "TestQuantizeFxOps": 166.50550000000004, "TestQuantizeJit": 22.2185, "TestQuantizeJitOps": 276.4025, "TestQuantizeJitPasses": 9.015, "TestQuantizePT2E": 0.06050000000000004, "TestQuantizePT2EQAT": 0.014000000000000005, "TestQuantizePT2EQATModels": 0.003, "TestQuantizePT2EQAT_ConvBn1d": 0.025500000000000012, "TestQuantizePT2EQAT_ConvBn2d": 0.025500000000000012, "TestQuantizePT2EX86Inductor": 0.04650000000000003, "TestQuantizedConv": 32.386, "TestQuantizedEmbeddingOps": 1.38, "TestQuantizedFunctionalOps": 1.123, "TestQuantizedLinear": 23.830000000000002, "TestQuantizedOps": 167.87350000000006, "TestQuantizedTensor": 3.736499999999999, "TestRecordHistogramObserver": 0.068, "TestReferenceQuantizedModule": 0.092, "TestSerialization": 1.795, "TestStaticQuantizedModule": 76.8565, "TestSubgraphRewriter": 0.9850000000000002, "TestUtils": 0.0445, "TestXNNPACKQuantizer": 0.03750000000000002, "TestXNNPACKQuantizerModels": 0.0015}, "test_schema_check": {"TestSchemaCheck": 0.27400000000000013}, "test_serialization": {"TestOldSerialization": 61.14099999999999, "TestSerialization": 14.007999999999996, "TestSubclassSerialization": 0.0485}, "test_set_default_mobile_cpu_allocator": {"TestSetDefaultMobileCPUAllocator": 0.46599999999999997}, "test_show_pickle": {"TestShowPickle": 0.0015}, "test_sparse": {"TestSparseLegacyAndDeprecation": 0.037500000000000006, "TestSparseMeta": 6.251, "TestSparseOneOff": 0.003}, "test_sparse_csr": {"TestSparseCSRSampler": 0.8375}, "test_sparse_semi_structured": {"SparseSemiStructuredTensorCompileTest": 0.0045000000000000005}, "test_stateless": {"TestPythonOptimizeMode": 8.36, "TestStatelessDeprecation": 3.1075, "TestStatelessFunctionalAPI": 0.4790000000000001}, "test_subclass": {"TestSubclass": 0.8105000000000002}, "test_sympy_utils": {"TestNumbers": 0.052000000000000005, "TestSingletonInt": 0.009000000000000001, "TestSympyInterp": 13.488, "TestSympySolve": 0.30950000000000005, "TestValueRanges": 10.368499999999997}, "test_tensorboard": {"TestTensorBoardEmbedding": 0.0345, "TestTensorBoardFigure": 0.003, "TestTensorBoardNumpy": 0.012, "TestTensorBoardPyTorchNumpy": 0.379, "TestTensorBoardPytorchGraph": 0.5335000000000001, "TestTensorBoardSummary": 0.08300000000000003, "TestTensorBoardSummaryWriter": 0.0225, "TestTensorBoardUtils": 0.3015, "TestTensorBoardWriter": 0.5055000000000001, "TestTensorProtoSummary": 0.029500000000000002}, "test_tensorexpr": {"TestTensorExprFuser": 46.445499999999996}, "test_tensorexpr_pybind": {"TestExprHandlePyBind": 0.018000000000000002, "TestTensorExprPyBind": 0.506}, "test_testing": {"TestAssertClose": 0.23400000000000012, "TestAssertCloseContainer": 0.017, "TestAssertCloseErrorMessage": 0.11500000000000002, "TestAssertCloseQuantized": 0.024, "TestAssertCloseSparseBSC": 0.028500000000000004, "TestAssertCloseSparseBSR": 0.0375, "TestAssertCloseSparseCOO": 0.056, "TestAssertCloseSparseCSC": 0.0455, "TestAssertCloseSparseCSR": 0.044500000000000005, "TestFrameworkUtils": 0.0015, "TestImports": 8.742999999999999, "TestOpInfos": 0.009000000000000001, "TestTestParametrization": 0.09050000000000004}, "test_torch": {"TestBasicVitalSigns": 0.03, "TestTorch": 6.825999999999983}, "test_type_hints": {"TestTypeHints": 0.0015}, "test_type_info": {"TestDTypeInfo": 0.48450000000000004}, "test_typing": {"TestTyping": 0.008}, "test_utils": {"TestAssert": 0.11199999999999999, "TestBottleneck": 26.0725, "TestCheckpoint": 0.13400000000000004, "TestCollectEnv": 5.2715, "TestCppExtensionUtils": 0.008, "TestDataLoaderUtils": 23.4485, "TestExtensionUtils": 0.01, "TestHipify": 0.003, "TestHipifyTrie": 0.012, "TestONNXUtils": 0.009000000000000001, "TestRenderUtils": 0.024, "TestStandaloneCPPJIT": 19.5375, "TestTraceback": 0.023}, "test_vulkan": {"TestVulkanRewritePass": 0.0015}, "test_weak": {"WeakKeyDictionaryScriptObjectTestCase": 0.031, "WeakKeyDictionaryTestCase": 0.0465, "WeakTest": 5.8084999999999996}, "test_xnnpack_integration": {"TestXNNPACKConv1dTransformPass": 0.003, "TestXNNPACKOps": 4.757, "TestXNNPACKRewritePass": 2.222, "TestXNNPACKSerDes": 6.2204999999999995}, "torch_np/numpy_tests/core/test_dlpack": {"TestDLPack": 0.017}, "torch_np/numpy_tests/core/test_dtype": {"TestBuiltin": 0.5395000000000001, "TestClassGetItem": 0.0045000000000000005, "TestDtypeAttributeDeletion": 0.001, "TestFromDTypeAttribute": 0.0055, "TestMisc": 0.0075, "TestPickling": 0.18000000000000005, "TestPromotion": 0.0075}, "torch_np/numpy_tests/core/test_einsum": {"TestEinsum": 22.4185, "TestEinsumPath": 0.0055, "TestMisc": 0.010499999999999999}, "torch_np/numpy_tests/core/test_getlimits": {"TestDouble": 0.0005, "TestFinfo": 0.003, "TestHalf": 0.0015, "TestIinfo": 0.49250000000000005, "TestMisc": 0.0075, "TestPythonFloat": 0.0015, "TestRepr": 0.006, "TestSingle": 0.0015}, "torch_np/numpy_tests/core/test_indexing": {"TestArrayToIndexDeprecation": 0.005, "TestBooleanIndexing": 0.014, "TestBroadcastedAssignments": 0.0385, "TestFancyIndexingCast": 0.007, "TestFloatNonIntegerArgument": 0.020000000000000004, "TestIndexing": 0.7165000000000002, "TestMultiIndexingAutomated": 0.015500000000000002, "TestMultipleEllipsisError": 0.005, "TestNonIntegerArrayLike": 0.0015}, "torch_np/numpy_tests/core/test_multiarray": {"TestArange": 0.045500000000000006, "TestArgmax": 1.9205000000000005, "TestArgmaxArgminCommon": 0.3085000000000002, "TestArgmin": 1.9605000000000004, "TestArrayAttributeDeletion": 0.015, "TestArrayConstruction": 0.07800000000000001, "TestArrayCreationCopyArgument": 0.029000000000000015, "TestArrayInterface": 0.021000000000000005, "TestAssignment": 0.020500000000000004, "TestAttributes": 0.031000000000000007, "TestBinop": 0.0305, "TestBool": 34.4315, "TestCequenceMethods": 0.005, "TestChoose": 0.037000000000000005, "TestClip": 0.012, "TestCompress": 0.0105, "TestConversion": 0.051500000000000004, "TestCreation": 0.006, "TestDelMisc": 0.003, "TestDot": 0.12000000000000006, "TestDtypedescr": 0.004, "TestFancyIndexing": 0.0635, "TestFlag": 0.019500000000000003, "TestFormat": 0.0105, "TestFromBuffer": 0.028500000000000004, "TestHash": 0.46299999999999997, "TestHashing": 0.006, "TestIO": 0.012, "TestInner": 0.30400000000000005, "TestLexsort": 0.0465, "TestMatmul": 0.6135000000000002, "TestMatmulOperator": 0.428, "TestMethods": 2.1970000000000005, "TestMinMax": 0.0105, "TestMinScalarType": 0.02, "TestNewaxis": 0.0075, "TestPEP3118Dtype": 0.015000000000000003, "TestPutmask": 0.026500000000000003, "TestRepeat": 0.025500000000000002, "TestResize": 0.07150000000000001, "TestRichcompareScalar": 0.0015, "TestScalarIndexing": 0.029000000000000005, "TestSizeOf": 0.020000000000000004, "TestSortFloatMisc": 0.248, "TestStats": 0.391, "TestSubscripting": 0.0055, "TestTake": 0.060500000000000005, "TestVdot": 0.05750000000000001, "TestViewDtype": 0.012, "TestWarnings": 0.006, "TestWhere": 0.5265, "TestWritebackIfCopy": 0.068}, "torch_np/numpy_tests/core/test_numeric": {"TestAllclose": 0.034, "TestArgwhere": 0.0575, "TestArrayComparisons": 0.022500000000000003, "TestBaseRepr": 0.012, "TestBinaryRepr": 0.018000000000000002, "TestBoolArray": 3.9225, "TestBoolCmp": 0.2415, "TestBoolScalar": 0.021, "TestBroadcast": 0.013500000000000002, "TestClip": 0.32750000000000024, "TestConvolve": 0.035500000000000004, "TestCorrelate": 0.062000000000000006, "TestCreationFuncs": 1.4875, "TestCross": 0.07550000000000001, "TestDtypePositional": 0.005, "TestFloatExceptions": 0.02, "TestFromiter": 0.0025, "TestIndex": 0.0115, "TestIndices": 0.069, "TestIsclose": 0.12500000000000003, "TestIsscalar": 0.0045000000000000005, "TestLikeFuncs": 0.003, "TestMoveaxis": 0.02, "TestNonarrayArgs": 0.1980000000000001, "TestNonzeroAndCountNonzero": 0.36200000000000004, "TestOuterMisc": 0.009000000000000001, "TestRequire": 0.013500000000000002, "TestResize": 0.5095000000000001, "TestRoll": 0.0635, "TestRollaxis": 0.0105, "TestSeterr": 0.0145, "TestStdVar": 0.0455, "TestStdVarComplex": 0.0165, "TestStringFunction": 0.005, "TestTensordot": 0.028499999999999998, "TestTypes": 0.028499999999999998}, "torch_np/numpy_tests/core/test_numerictypes": {"TestBitName": 0.003, "TestCommonType": 0.487, "TestDocStrings": 0.0015, "TestIsSubDType": 0.018500000000000003, "TestScalarTypeNames": 0.06300000000000003}, "torch_np/numpy_tests/core/test_scalar_ctors": {"TestArrayFromScalar": 0.1845000000000001, "TestFromInt": 0.013500000000000002, "TestFromString": 0.4685}, "torch_np/numpy_tests/core/test_scalar_methods": {"TestAsIntegerRatio": 0.01, "TestBitCount": 0.004, "TestClassGetItem": 0.015000000000000005, "TestClassGetitemMisc": 0.0045000000000000005, "TestIsInteger": 0.014}, "torch_np/numpy_tests/core/test_scalarinherit": {"TestInherit": 0.003}, "torch_np/numpy_tests/core/test_scalarmath": {"TestAbs": 0.15, "TestBaseMath": 13.603, "TestBitShifts": 0.14100000000000001, "TestComplexDivision": 0.11200000000000002, "TestConversion": 0.0925, "TestHash": 0.0045000000000000005, "TestModulus": 1.4885000000000002, "TestMultiply": 0.0005, "TestNegative": 0.0295, "TestPower": 0.187, "TestRepr": 0.0035, "TestScalarOpsMisc": 0.12500000000000006, "TestScalarSubclassingMisc": 0.11700000000000008, "TestSubtract": 0.03, "TestTypes": 21.991999999999997}, "torch_np/numpy_tests/core/test_shape_base": {"TestAtleast1d": 0.5680000000000001, "TestAtleast2d": 0.0295, "TestAtleast3d": 0.028, "TestBlock": 0.07150000000000004, "TestConcatenate": 0.2775000000000002, "TestHstack": 0.036, "TestStackMisc": 0.031500000000000014, "TestVstack": 0.043000000000000003}, "torch_np/numpy_tests/fft/test_helper": {"TestFFTFreq": 0.015, "TestFFTShift": 8.782499999999999, "TestIRFFTN": 0.0075, "TestRFFTFreq": 0.015}, "torch_np/numpy_tests/fft/test_pocketfft": {"TestFFT1D": 4.5625, "TestFFTShift": 0.45699999999999996, "TestFFTThreadSafe": 1.0265}, "torch_np/numpy_tests/lib/test_arraypad": {"TestConstant": 0.517}, "torch_np/numpy_tests/lib/test_arraysetops": {"TestSetOps": 0.015500000000000002, "TestUnique": 0.6935}, "torch_np/numpy_tests/lib/test_function_base": {"TestAll": 0.013500000000000002, "TestAmax": 0.0105, "TestAmin": 0.01, "TestAngle": 0.012, "TestAny": 0.014000000000000002, "TestAverage": 0.044000000000000004, "TestBincount": 0.08299999999999999, "TestCheckFinite": 0.006, "TestCopy": 0.014000000000000002, "TestCorrCoef": 0.0645, "TestCov": 0.10400000000000001, "TestCumprod": 0.043500000000000004, "TestCumsum": 0.0595, "TestDelete": 0.0315, "TestDiff": 0.1335, "TestDigitize": 0.036000000000000004, "TestExtins": 0.0145, "TestFilterwindows": 0.9940000000000007, "TestFlip": 0.063, "TestGradient": 0.23450000000000004, "TestInsert": 0.021000000000000005, "TestInterp": 0.11600000000000006, "TestKaiser": 0.0195, "TestMedian": 0.18150000000000005, "TestMeshgrid": 0.099, "TestMsort": 0.0015, "TestPercentile": 0.30700000000000016, "TestPiecewise": 0.0265, "TestProd": 0.042, "TestPtp": 0.014499999999999999, "TestQuantile": 0.12850000000000006, "TestRot90": 0.6014999999999999, "TestSelect": 0.021, "TestSinc": 0.013500000000000002, "TestSortComplex": 0.024, "TestTrapz": 0.0105, "TestTrimZeros": 0.031, "TestUnique": 0.009000000000000001, "Test_I0": 0.0255}, "torch_np/numpy_tests/lib/test_histograms": {"TestHistogram": 0.7335000000000003, "TestHistogramOptimBinNums": 0.06300000000000003, "TestHistogramdd": 0.24650000000000005}, "torch_np/numpy_tests/lib/test_index_tricks": {"TestC": 0.003, "TestConcatenator": 0.0205, "TestDiagIndices": 0.008, "TestDiagIndicesFrom": 0.013500000000000002, "TestFillDiagonal": 0.043500000000000004, "TestGrid": 0.025500000000000002, "TestIndexExpression": 0.017, "TestIx_": 0.015, "TestNdIndex": 0.003, "TestNdenumerate": 0.003, "TestRavelUnravelIndex": 0.497}, "torch_np/numpy_tests/lib/test_shape_base_": {"TestApplyAlongAxis": 0.03200000000000001, "TestApplyOverAxes": 0.0045000000000000005, "TestArraySplit": 0.23450000000000004, "TestColumnStack": 0.018000000000000002, "TestDsplit": 0.02, "TestDstack": 0.030000000000000006, "TestExpandDims": 0.014000000000000002, "TestHsplit": 0.021, "TestKron": 0.02650000000000001, "TestMayShareMemory": 0.0045000000000000005, "TestPutAlongAxis": 0.0185, "TestSplit": 0.0115, "TestSqueeze": 0.04350000000000001, "TestTakeAlongAxis": 0.555, "TestTile": 0.11850000000000002, "TestVsplit": 0.0165}, "torch_np/numpy_tests/lib/test_twodim_base": {"TestDiag": 0.0495, "TestEye": 0.536, "TestFliplr": 0.009000000000000001, "TestFlipud": 0.009000000000000001, "TestHistogram2d": 0.06100000000000001, "TestTri": 0.1395, "TestTrilIndicesFrom": 0.005, "TestTriuIndices": 0.007, "TestTriuIndicesFrom": 0.0055, "TestVander": 0.0355}, "torch_np/numpy_tests/lib/test_type_check": {"TestArrayConversion": 0.003, "TestCommonType": 0.4565, "TestImag": 0.019500000000000003, "TestIscomplex": 0.0105, "TestIscomplexobj": 0.009000000000000001, "TestIsfinite": 0.0305, "TestIsinf": 0.028499999999999998, "TestIsnan": 0.0305, "TestIsneginf": 0.0045000000000000005, "TestIsposinf": 0.0045000000000000005, "TestIsreal": 0.015, "TestIsrealobj": 0.003, "TestIsscalar": 0.0035, "TestMintypecode": 0.012, "TestNanToNum": 0.029000000000000005, "TestReal": 0.02, "TestRealIfClose": 0.0075}, "torch_np/numpy_tests/linalg/test_linalg": {"TestCholesky": 0.3165, "TestCond": 0.3135, "TestDet": 0.22450000000000003, "TestEig": 0.06150000000000001, "TestEigh": 0.043500000000000004, "TestEighCases": 0.0005, "TestEigvals": 0.12100000000000002, "TestEigvalsh": 0.0445, "TestEigvalshCases": 0.0, "TestInv": 0.07700000000000001, "TestLstsq": 0.32500000000000007, "TestMatrixRank": 0.5455000000000001, "TestMisc": 0.0205, "TestMisc2": 0.008, "TestMultiDot": 0.11650000000000002, "TestNormDouble": 1.1265, "TestNormInt64": 1.1155, "TestNormSingle": 1.1280000000000001, "TestNorm_NonSystematic": 0.006500000000000001, "TestPinv": 0.1705, "TestPinvHermitian": 0.0635, "TestQR": 6.745000000000001, "TestSVD": 0.08450000000000002, "TestSVDHermitian": 0.14300000000000002, "TestSolve": 0.5465, "TestTensorinv": 0.05299999999999999, "TestTensorsolve": 0.036000000000000004}, "torch_np/test_basic": {"TestArrayToSequence": 0.018000000000000002, "TestCopyTo": 0.0145, "TestCtorNested": 0.006, "TestDefaultDtype": 0.015000000000000001, "TestDivmod": 0.0295, "TestExport": 0.0005, "TestMisc": 0.0045000000000000005, "TestNormalizations": 0.0105, "TestOneArr": 0.7170000000000005, "TestOneArrAndAxesTuple": 0.027000000000000003, "TestOneArrAndAxis": 0.41100000000000025, "TestOneArrAndShape": 0.02250000000000001, "TestOneArrToScalar": 0.030000000000000006, "TestPythonArgsToArray": 0.035, "TestSequenceOfArrays": 0.04800000000000002, "TestSequenceOfArraysToSingle": 0.0235, "TestShapeLikeToArray": 0.012, "TestSmokeNotImpl": 0.0035}, "torch_np/test_binary_ufuncs": {"TestBinaryUfuncBasic": 0.6075000000000002}, "torch_np/test_dtype": {"TestConvertDType": 0.4735000000000001}, "torch_np/test_function_base": {"TestAppend": 0.47250000000000003}, "torch_np/test_ndarray_methods": {"TestAmax": 0.012, "TestAmin": 0.012, "TestArgmax": 1.6710000000000007, "TestArgmaxArgminCommon": 2.2984999999999935, "TestArgmin": 1.8715000000000006, "TestContains": 0.0045000000000000005, "TestIndexing": 0.499, "TestIter": 0.009000000000000001, "TestNoExtraMethods": 0.018000000000000002, "TestNonzero": 0.21500000000000002, "TestRavel": 0.015, "TestReshape": 0.012, "TestTranspose": 0.02}, "torch_np/test_nep50_examples": {"TestCompareToNumpy": 0.6255000000000004, "TestNEP50Table": 0.0075}, "torch_np/test_random": {"TestChoice": 0.018000000000000002, "TestNumpyGlobal": 0.0075, "TestScalarReturn": 0.5680000000000001, "TestShuffle": 0.029000000000000005}, "torch_np/test_reductions": {"TestAll": 0.0215, "TestAny": 0.021, "TestFlatnonzero": 0.5055, "TestGenericCumSumProd": 0.039, "TestGenericReductions": 4.093999999999952, "TestMean": 0.036, "TestSum": 0.3305}, "torch_np/test_scalars_0D_arrays": {"TestArrayScalars": 0.5195000000000001, "TestIsScalar": 0.06100000000000003}, "torch_np/test_ufuncs_basic": {"TestBinaryUfuncs": 1.2805000000000009, "TestNdarrayDunderVsUfunc": 0.32250000000000023, "TestUfuncDtypeKwd": 0.0105, "TestUnaryUfuncs": 0.5635000000000001}, "torch_np/test_unary_ufuncs": {"TestUnaryUfuncs": 0.6730000000000003}}}} \ No newline at end of file diff --git a/.additional_ci_files/test-times.json b/.additional_ci_files/test-times.json new file mode 100644 index 0000000000000..23ef9aa0414bb --- /dev/null +++ b/.additional_ci_files/test-times.json @@ -0,0 +1 @@ +{"cuda12.1-py3.10-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 3.51, "distributed/_composable/fsdp/test_fully_shard_comm": 110.39150000000001, "distributed/_composable/fsdp/test_fully_shard_frozen": 10.389499999999998, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 7.05, "distributed/_composable/fsdp/test_fully_shard_training": 21.664, "distributed/_tensor/test_dtensor_compile": 22.538999999999998, "distributed/fsdp/test_fsdp_tp_integration": 10.125, "distributed/tensor/parallel/test_fsdp_2d_parallel": 33.96050000000001, "distributed/test_c10d_functional_native": 147.18950000000004, "distributed/test_dynamo_distributed": 114.283, "distributed/test_inductor_collectives": 54.069, "inductor/test_aot_inductor": 6129.129499999997, "inductor/test_torchinductor": 2305.388, "inductor/test_torchinductor_opinfo": 8049.36599999999, "test_modules": 564.5784999999856, "test_ops": 2169.7869999998647, "test_ops_gradients": 1375.356499999892, "test_torch": 1577.308999999997}, "inductor_cpp_wrapper_abi_compatible": {"inductor/test_cpu_cpp_wrapper": 746.8210000000004, "inductor/test_cuda_cpp_wrapper": 885.2804999999998}, "inductor_distributed": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 10.721499999999999, "distributed/_composable/fsdp/test_fully_shard_comm": 130.37599999999998, "distributed/_composable/fsdp/test_fully_shard_frozen": 25.994999999999997, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 17.564, "distributed/_composable/fsdp/test_fully_shard_training": 165.496, "distributed/_tensor/test_dtensor_compile": 32.778, "distributed/fsdp/test_fsdp_tp_integration": 24.756, "distributed/tensor/parallel/test_fsdp_2d_parallel": 66.10549999999999, "distributed/test_c10d_functional_native": 164.6975, "distributed/test_dynamo_distributed": 220.02949999999998, "distributed/test_inductor_collectives": 89.56050000000002, "inductor/test_aot_inductor": 51.736000000000004, "inductor/test_torchinductor": 6.6215}}, "cuda12.1-py3.10-gcc9-sm86-periodic-dynamo-benchmarks": {"aot_eager_huggingface": {"backends/xeon/test_launch": 2.085, "benchmark_utils/test_benchmark_utils": 2.1359999999999997, "distributions/test_distributions": 67.75299999999999, "dynamo/test_activation_checkpointing": 19.102, "dynamo/test_after_aot": 4.797, "dynamo/test_aot_autograd": 13.072000000000001, "dynamo/test_aot_autograd_cache": 0.9560000000000001, "dynamo/test_autograd_function": 5.439999999999999, "dynamo/test_backends": 11.918999999999999, "dynamo/test_backward_higher_order_ops": 11.816, "dynamo/test_base_output": 0.002, "dynamo/test_bytecode_utils": 4.791, "dynamo/test_compile": 5.545, "dynamo/test_comptime": 0.556, "dynamo/test_config": 0.546, "dynamo/test_ctx_manager": 3.108999999999999, "dynamo/test_cudagraphs": 3.3859999999999997, "dynamo/test_debug_utils": 0.331, "dynamo/test_decorators": 0.6820000000000002, "dynamo/test_deviceguard": 0.022000000000000002, "dynamo/test_dynamic_shapes": 1527.4139999999989, "dynamo/test_exc": 1.7949999999999997, "dynamo/test_export": 13.932000000000002, "dynamo/test_export_mutations": 0.53, "dynamo/test_frame_init": 0.204, "dynamo/test_functions": 20.778000000000024, "dynamo/test_fx_passes_pre_grad": 1.162, "dynamo/test_global": 0.515, "dynamo/test_guard_manager": 0.232, "dynamo/test_higher_order_ops": 26.481, "dynamo/test_hooks": 23.098999999999997, "dynamo/test_input_attr_tracking": 6.5040000000000004, "dynamo/test_interop": 0.5469999999999999, "dynamo/test_logging": 18.500999999999998, "dynamo/test_minifier": 2.0469999999999997, "dynamo/test_misc": 47.07500000000009, "dynamo/test_model_output": 0.633, "dynamo/test_modules": 10.505999999999997, "dynamo/test_nops": 0.299, "dynamo/test_optimizers": 0.618, "dynamo/test_pre_dispatch": 0.466, "dynamo/test_profiler": 1.269, "dynamo/test_python_autograd": 0.625, "dynamo/test_recompile_ux": 0.8030000000000002, "dynamo/test_recompiles": 0.799, "dynamo/test_reorder_logs": 0.504, "dynamo/test_repros": 29.47400000000001, "dynamo/test_resume": 0.421, "dynamo/test_sdpa": 0.467, "dynamo/test_skip_non_tensor": 0.603, "dynamo/test_sources": 0.47600000000000003, "dynamo/test_structured_trace": 13.992, "dynamo/test_subclasses": 15.514999999999997, "dynamo/test_subgraphs": 1.951999999999999, "dynamo/test_trace_rules": 1.254, "dynamo/test_unspec": 10.329999999999998, "dynamo/test_verify_correctness": 0.562, "export/test_converter": 0.281, "export/test_db": 2.798, "export/test_experimental": 0.915, "export/test_export": 25.37199999999999, "export/test_export_nonstrict": 20.72799999999999, "export/test_functionalized_assertions": 0.636, "export/test_hop": 1.656, "export/test_lift_unlift": 0.082, "export/test_pass_infra": 0.8280000000000002, "export/test_passes": 10.901, "export/test_retraceability": 35.43600000000002, "export/test_schema": 0.23800000000000002, "export/test_serdes": 24.046999999999993, "export/test_serialize": 8.488999999999999, "export/test_sparse": 52.72899999999987, "export/test_tools": 0.543, "export/test_torchbind": 2.4359999999999995, "export/test_tree_utils": 0.213, "export/test_unflatten": 2.8360000000000007, "export/test_verifier": 0.8520000000000001, "functorch/test_aotdispatch": 17.980000000000004, "functorch/test_control_flow": 110.06200000000017, "functorch/test_dims": 25.629999999999995, "functorch/test_eager_transforms": 9.613, "functorch/test_logging": 0.24, "functorch/test_memory_efficient_fusion": 7.5760000000000005, "functorch/test_minifier": 0.3770000000000001, "functorch/test_ops": 4169.963999999979, "functorch/test_parsing": 0.663, "functorch/test_rearrange": 0.6980000000000001, "functorch/test_vmap": 274.07199999999926, "functorch/test_vmap_registrations": 2.4029999999998584, "higher_order_ops/test_with_effects": 4.847000000000001, "inductor/test_aot_inductor": 5998.078999999999, "inductor/test_benchmark_fusion": 100.13400000000001, "inductor/test_binary_folding": 34.054, "inductor/test_codecache": 123.423, "inductor/test_codegen_triton": 0.215, "inductor/test_compile_worker": 5.032, "inductor/test_compiled_autograd": 357.97300000000075, "inductor/test_compiled_optimizers": 2013.4810000000007, "inductor/test_config": 5.279000000000002, "inductor/test_control_flow": 119.87699999999998, "inductor/test_coordinate_descent_tuner": 3.265, "inductor/test_cpu_repro": 635.313, "inductor/test_cuda_cpp_wrapper": 1969.2509999999997, "inductor/test_cuda_repro": 78.10499999999999, "inductor/test_cudagraph_trees": 65.05899999999997, "inductor/test_custom_lowering": 3.502, "inductor/test_custom_post_grad_passes": 9.978, "inductor/test_cutlass_backend": 127.25400000000002, "inductor/test_debug_trace": 13.651, "inductor/test_decompose_mem_bound_mm": 33.289, "inductor/test_dependencies": 0.21000000000000002, "inductor/test_distributed_patterns": 33.81099999999999, "inductor/test_efficient_conv_bn_eval": 299.743, "inductor/test_extension_backend": 16.923, "inductor/test_flex_attention": 407.2029999999997, "inductor/test_foreach": 296.3810000000001, "inductor/test_fp8": 0.010000000000000002, "inductor/test_fused_attention": 217.52300000000002, "inductor/test_fx_fusion": 0.177, "inductor/test_group_batch_fusion": 107.004, "inductor/test_indexing": 0.5780000000000001, "inductor/test_inductor_freezing": 80.72300000000001, "inductor/test_inplacing_pass": 6.975, "inductor/test_kernel_benchmark": 124.56300000000002, "inductor/test_layout_optim": 13.487999999999998, "inductor/test_max_autotune": 241.14100000000005, "inductor/test_memory_planning": 29.028, "inductor/test_metrics": 3.798000000000001, "inductor/test_minifier": 28.125000000000004, "inductor/test_minifier_isolate": 90.581, "inductor/test_mkldnn_pattern_matcher": 483.0369999999997, "inductor/test_mmdecomp": 9.134999999999998, "inductor/test_move_constructors_to_cuda": 14.784, "inductor/test_multi_kernel": 72.816, "inductor/test_pad_mm": 127.444, "inductor/test_padding": 18.628000000000004, "inductor/test_pattern_matcher": 90.64599999999999, "inductor/test_perf": 65.757, "inductor/test_profiler": 7.9079999999999995, "inductor/test_select_algorithm": 113.91600000000001, "inductor/test_smoke": 6.072, "inductor/test_snode_runtime": 13.796, "inductor/test_split_cat_fx_passes": 98.208, "inductor/test_standalone_compile": 18.065, "inductor/test_torchbind": 6.262, "inductor/test_torchinductor": 17.669, "inductor/test_torchinductor_codegen_dynamic_shapes": 15.529, "inductor/test_torchinductor_dynamic_shapes": 9.072, "nn/test_convolution": 71.58999999999952, "nn/test_pooling": 5.912999999999997, "profiler/test_profiler": 0.7080000000000001, "test_autocast": 2.1239999999999997, "test_autograd_fallback": 0.7290000000000001, "test_cpp_api_parity": 8.696999999999981, "test_cpp_extensions_aot_ninja": 0.7390000000000001, "test_cpp_extensions_aot_no_ninja": 0.7140000000000001, "test_cpp_extensions_jit": 166.06700000000004, "test_cpp_extensions_mtia_backend": 0.426, "test_cpp_extensions_open_device_registration": 6.656, "test_cpp_extensions_stream_and_event": 0.419, "test_cuda": 14.392000000000001, "test_cuda_expandable_segments": 16.103, "test_cuda_multigpu": 0.857, "test_cuda_nvml_based_avail": 4.037, "test_cuda_primary_ctx": 1.261, "test_cuda_trace": 6.696, "test_dispatch": 32.97300000000001, "test_fake_tensor": 16.598000000000013, "test_fx": 218.51699999999997, "test_indexing": 0.564, "test_jit_disabled": 0.7260000000000001, "test_linalg": 13.14, "test_mobile_optimizer": 2.5330000000000004, "test_multiprocessing": 86.09200000000003, "test_multiprocessing_spawn": 19.627, "test_namedtuple_return_api": 1.942, "test_native_mha": 1.042, "test_nn": 166.52500000000427, "test_overrides": 2.3019999999998904, "test_python_dispatch": 1.5749999999999995, "test_reductions": 132.13600000000284, "test_serialization": 5.803, "test_show_pickle": 0.643, "test_sort_and_select": 4.068999999999995, "test_spectral_ops": 18.79299999999997, "test_tensor_creation_ops": 78.6970000000003, "test_tensorexpr": 114.01900000000002, "test_torch": 86.42399999999999, "test_utils": 25.386000000000575}, "aot_eager_timm": {"backends/xeon/test_launch": 2.04, "benchmark_utils/test_benchmark_utils": 2.1299999999999994, "distributions/test_distributions": 67.305, "dynamo/test_activation_checkpointing": 19.426, "dynamo/test_after_aot": 4.752, "dynamo/test_aot_autograd": 13.092000000000002, "dynamo/test_aot_autograd_cache": 0.932, "dynamo/test_autograd_function": 5.31, "dynamo/test_backends": 13.485999999999999, "dynamo/test_backward_higher_order_ops": 10.613000000000001, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_utils": 7.6579999999999995, "dynamo/test_compile": 5.511, "dynamo/test_comptime": 0.5650000000000001, "dynamo/test_config": 0.534, "dynamo/test_ctx_manager": 3.0439999999999996, "dynamo/test_cudagraphs": 3.293, "dynamo/test_debug_utils": 0.303, "dynamo/test_decorators": 0.6410000000000001, "dynamo/test_deviceguard": 0.015, "dynamo/test_dynamic_shapes": 1524.776, "dynamo/test_exc": 1.817, "dynamo/test_export": 13.615000000000004, "dynamo/test_export_mutations": 0.52, "dynamo/test_frame_init": 0.2, "dynamo/test_functions": 20.813000000000002, "dynamo/test_fx_passes_pre_grad": 1.137, "dynamo/test_global": 0.507, "dynamo/test_guard_manager": 0.22200000000000003, "dynamo/test_higher_order_ops": 26.292, "dynamo/test_hooks": 23.15500000000001, "dynamo/test_input_attr_tracking": 6.454, "dynamo/test_interop": 0.5449999999999999, "dynamo/test_logging": 18.373, "dynamo/test_minifier": 2.069, "dynamo/test_misc": 47.119000000000035, "dynamo/test_model_output": 0.644, "dynamo/test_modules": 10.424, "dynamo/test_nops": 0.279, "dynamo/test_optimizers": 0.615, "dynamo/test_pre_dispatch": 0.47100000000000003, "dynamo/test_profiler": 1.244, "dynamo/test_python_autograd": 0.603, "dynamo/test_recompile_ux": 0.7920000000000001, "dynamo/test_recompiles": 0.7910000000000001, "dynamo/test_reorder_logs": 0.5, "dynamo/test_repros": 29.129, "dynamo/test_resume": 0.42, "dynamo/test_sdpa": 0.461, "dynamo/test_skip_non_tensor": 0.5820000000000001, "dynamo/test_sources": 0.454, "dynamo/test_structured_trace": 13.898, "dynamo/test_subclasses": 15.493, "dynamo/test_subgraphs": 1.9889999999999992, "dynamo/test_trace_rules": 1.222, "dynamo/test_unspec": 10.323999999999996, "dynamo/test_verify_correctness": 0.555, "export/test_converter": 0.275, "export/test_db": 2.7359999999999993, "export/test_experimental": 0.899, "export/test_export": 25.168000000000013, "export/test_export_nonstrict": 20.90899999999999, "export/test_functionalized_assertions": 0.624, "export/test_hop": 1.6559999999999995, "export/test_lift_unlift": 0.084, "export/test_pass_infra": 0.8250000000000002, "export/test_passes": 10.911999999999999, "export/test_retraceability": 35.746999999999986, "export/test_schema": 0.23900000000000002, "export/test_serdes": 23.56600000000001, "export/test_serialize": 8.202, "export/test_sparse": 52.302999999999884, "export/test_tools": 0.515, "export/test_torchbind": 2.314999999999999, "export/test_tree_utils": 0.197, "export/test_unflatten": 2.742, "export/test_verifier": 0.8370000000000001, "functorch/test_aotdispatch": 17.452999999999996, "functorch/test_control_flow": 108.1920000000001, "functorch/test_dims": 25.377999999999997, "functorch/test_eager_transforms": 9.476, "functorch/test_logging": 0.241, "functorch/test_memory_efficient_fusion": 7.629, "functorch/test_minifier": 0.3770000000000001, "functorch/test_ops": 4144.264999999986, "functorch/test_parsing": 0.652, "functorch/test_rearrange": 0.679, "functorch/test_vmap": 284.32799999999907, "functorch/test_vmap_registrations": 2.429999999999855, "higher_order_ops/test_with_effects": 4.716, "inductor/test_aot_inductor": 6010.077999999999, "inductor/test_benchmark_fusion": 100.155, "inductor/test_binary_folding": 34.324999999999996, "inductor/test_codecache": 125.98500000000003, "inductor/test_codegen_triton": 0.224, "inductor/test_compile_worker": 4.920999999999999, "inductor/test_compiled_autograd": 362.0670000000007, "inductor/test_compiled_optimizers": 2007.6020000000008, "inductor/test_config": 5.259, "inductor/test_control_flow": 120.71799999999999, "inductor/test_coordinate_descent_tuner": 3.0800000000000005, "inductor/test_cpu_repro": 639.409, "inductor/test_cuda_cpp_wrapper": 1971.0449999999998, "inductor/test_cuda_repro": 78.537, "inductor/test_cudagraph_trees": 65.142, "inductor/test_custom_lowering": 3.5460000000000003, "inductor/test_custom_post_grad_passes": 10.231, "inductor/test_cutlass_backend": 127.06800000000004, "inductor/test_debug_trace": 13.325, "inductor/test_decompose_mem_bound_mm": 33.345, "inductor/test_dependencies": 0.21200000000000002, "inductor/test_distributed_patterns": 33.939, "inductor/test_efficient_conv_bn_eval": 299.492, "inductor/test_extension_backend": 16.671, "inductor/test_flex_attention": 406.94799999999987, "inductor/test_foreach": 294.35800000000006, "inductor/test_fp8": 0.008, "inductor/test_fused_attention": 217.73400000000004, "inductor/test_fx_fusion": 0.173, "inductor/test_group_batch_fusion": 106.735, "inductor/test_indexing": 0.5690000000000001, "inductor/test_inductor_freezing": 81.45899999999999, "inductor/test_inplacing_pass": 6.901999999999999, "inductor/test_kernel_benchmark": 123.97799999999998, "inductor/test_layout_optim": 13.371999999999998, "inductor/test_max_autotune": 239.78500000000005, "inductor/test_memory_planning": 28.86, "inductor/test_metrics": 3.7650000000000006, "inductor/test_minifier": 28.123, "inductor/test_minifier_isolate": 89.435, "inductor/test_mkldnn_pattern_matcher": 474.1679999999998, "inductor/test_mmdecomp": 8.962999999999997, "inductor/test_move_constructors_to_cuda": 14.693000000000001, "inductor/test_multi_kernel": 71.05499999999999, "inductor/test_pad_mm": 126.084, "inductor/test_padding": 18.592000000000002, "inductor/test_pattern_matcher": 91.666, "inductor/test_perf": 66.247, "inductor/test_profiler": 7.6370000000000005, "inductor/test_select_algorithm": 114.45300000000003, "inductor/test_smoke": 5.96, "inductor/test_snode_runtime": 13.414000000000001, "inductor/test_split_cat_fx_passes": 98.04599999999999, "inductor/test_standalone_compile": 18.16, "inductor/test_torchbind": 6.176, "inductor/test_torchinductor": 2707.732999999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 2608.0480000000007, "inductor/test_torchinductor_dynamic_shapes": 3082.7289999999994, "inductor/test_torchinductor_opinfo": 1639.4039999999968, "inductor/test_triton_extension_backend": 0.522, "inductor/test_triton_heuristics": 0.005, "inductor/test_triton_kernels": 93.77500000000002, "inductor/test_triton_wrapper": 6.97, "inductor/test_unbacked_symints": 19.034000000000002, "inductor/test_utils": 0.204, "lazy/test_debug_util": 0.685, "lazy/test_functionalization": 0.7120000000000001, "lazy/test_generator": 0.682, "lazy/test_reuse_ir": 0.8280000000000001, "lazy/test_step_closures": 2.632, "lazy/test_ts_opinfo": 0.7060000000000001, "nn/test_convolution": 72.08699999999949, "nn/test_dropout": 0.998, "nn/test_embedding": 10.784000000000002, "nn/test_init": 3.9319999999999986, "nn/test_lazy_modules": 0.8170000000000002, "nn/test_load_state_dict": 1.036, "nn/test_module_hooks": 0.6910000000000001, "nn/test_multihead_attention": 4.891000000000002, "nn/test_packed_sequence": 1.7359999999999995, "nn/test_parametrization": 1.2409999999999992, "nn/test_pooling": 5.766999999999998, "nn/test_pruning": 0.49900000000000005, "profiler/test_execution_trace": 2.235, "profiler/test_memory_profiler": 4.488999999999999, "profiler/test_profiler": 28.132999999999996, "profiler/test_profiler_tree": 0.686, "profiler/test_record_function": 0.672, "profiler/test_torch_tidy": 3.696999999999999, "test_ao_sparsity": 8.810999999999998, "test_autocast": 2.1609999999999996, "test_autograd": 26.755999999999982, "test_autograd_fallback": 0.7300000000000001, "test_binary_ufuncs": 189.847999999996, "test_bundled_inputs": 1.3209999999999995, "test_comparison_utils": 0.635, "test_compile_benchmark_util": 0.0, "test_complex": 0.507, "test_content_store": 2.566, "test_cpp_api_parity": 8.663999999999989, "test_cpp_extensions_aot_ninja": 0.7450000000000001, "test_cpp_extensions_aot_no_ninja": 0.7250000000000001, "test_cpp_extensions_jit": 164.21699999999996, "test_cpp_extensions_mtia_backend": 0.422, "test_cpp_extensions_open_device_registration": 6.570000000000002, "test_cpp_extensions_stream_and_event": 0.42, "test_cuda": 121.75600000000004, "test_cuda_expandable_segments": 118.96699999999998, "test_cuda_multigpu": 1.3119999999999998, "test_cuda_nvml_based_avail": 4.034000000000001, "test_cuda_primary_ctx": 1.257, "test_cuda_sanitizer": 0.7190000000000001, "test_cuda_trace": 6.704, "test_custom_ops": 7.498999999999993, "test_dataloader": 279.211, "test_datapipe": 9.796, "test_decomp": 12716.714000000042, "test_deploy": 0.635, "test_dispatch": 32.43600000000002, "test_dlpack": 0.7390000000000001, "test_dynamic_shapes": 4.1789999999999985, "test_expanded_weights": 11.878, "test_fake_tensor": 16.655000000000012, "test_flop_counter": 0.601, "test_foreach": 400.1350000000087, "test_function_schema": 0.881, "test_functional_autograd_benchmark": 16.348000000000003, "test_functional_optim": 0.29000000000000004, "test_functionalization": 3.957999999999997, "test_functionalization_of_rng_ops": 2.309, "test_futures": 1.25, "test_fx": 218.2940000000001, "test_fx_experimental": 12.772000000000002, "test_fx_passes": 0.9990000000000002, "test_fx_reinplace_pass": 0.7670000000000001, "test_import_stats": 3.6020000000000003, "test_indexing": 2.4959999999999933, "test_itt": 0.639, "test_jit": 96.85700000000006, "test_jit_autocast": 26.546, "test_jit_disabled": 0.7230000000000001, "test_jit_fuser_te": 1053.1890000000008, "test_jit_llga_fuser": 0.061, "test_jiterator": 19.481000000000027, "test_legacy_vmap": 2.3149999999999986, "test_license": 0.64, "test_linalg": 1507.6299999999896, "test_logging": 2.682, "test_masked": 31.925000000000033, "test_maskedtensor": 7.2359999999998825, "test_matmul_cuda": 87.92600000000002, "test_meta": 1621.326999999602, "test_mkl_verbose": 3.686, "test_mkldnn_fusion": 33.125, "test_mkldnn_verbose": 3.532, "test_mobile_optimizer": 2.643, "test_model_dump": 1.23, "test_model_exports_to_core_aten": 0.203, "test_module_tracker": 0.623, "test_modules": 2515.2050000000236, "test_monitor": 0.984, "test_multiprocessing": 85.909, "test_multiprocessing_spawn": 19.482, "test_namedtensor": 1.1049999999999998, "test_namedtuple_return_api": 1.982, "test_native_functions": 0.7370000000000001, "test_native_mha": 0.9540000000000004, "test_nestedtensor": 9.070999999999993, "test_nn": 166.99600000000433, "test_numba_integration": 0.532, "test_numpy_interop": 0.5880000000000001, "test_openmp": 3.9059999999999997, "test_ops": 3014.9869999999914, "test_ops_fwd_gradients": 513.8009999999987, "test_ops_gradients": 1797.2929999998946, "test_overrides": 2.3029999999998902, "test_python_dispatch": 1.5829999999999997, "test_reductions": 131.65800000000232, "test_serialization": 5.851, "test_show_pickle": 0.64, "test_sort_and_select": 3.978999999999995, "test_spectral_ops": 18.755999999999954, "test_tensor_creation_ops": 81.17000000000027, "test_tensorexpr": 112.79300000000006, "test_torch": 87.11499999999998, "test_utils": 25.52000000000058}, "aot_eager_torchbench": {"backends/xeon/test_launch": 2.1109999999999998, "benchmark_utils/test_benchmark_utils": 2.151, "distributions/test_distributions": 67.904, "dynamo/test_activation_checkpointing": 19.375999999999994, "dynamo/test_after_aot": 4.739999999999999, "dynamo/test_aot_autograd": 12.959999999999999, "dynamo/test_aot_autograd_cache": 0.9730000000000001, "dynamo/test_autograd_function": 5.285999999999999, "dynamo/test_backends": 13.214, "dynamo/test_backward_higher_order_ops": 10.513, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_utils": 6.311, "dynamo/test_compile": 5.542, "dynamo/test_comptime": 0.5670000000000001, "dynamo/test_config": 0.548, "dynamo/test_ctx_manager": 3.0500000000000003, "dynamo/test_cudagraphs": 3.363, "dynamo/test_debug_utils": 0.299, "dynamo/test_decorators": 0.6350000000000001, "dynamo/test_deviceguard": 0.015, "dynamo/test_dynamic_shapes": 1526.0069999999996, "dynamo/test_exc": 1.8259999999999998, "dynamo/test_export": 13.653999999999998, "dynamo/test_export_mutations": 0.525, "dynamo/test_frame_init": 0.201, "dynamo/test_functions": 20.348999999999997, "dynamo/test_fx_passes_pre_grad": 1.126, "dynamo/test_global": 0.4930000000000001, "dynamo/test_guard_manager": 0.232, "dynamo/test_higher_order_ops": 26.184999999999995, "dynamo/test_hooks": 22.988000000000003, "dynamo/test_input_attr_tracking": 6.4239999999999995, "dynamo/test_interop": 0.5459999999999999, "dynamo/test_logging": 18.322, "dynamo/test_minifier": 2.067, "dynamo/test_misc": 46.89100000000007, "dynamo/test_model_output": 0.659, "dynamo/test_modules": 10.341999999999995, "dynamo/test_nops": 0.28600000000000003, "dynamo/test_optimizers": 0.611, "dynamo/test_pre_dispatch": 0.47300000000000003, "dynamo/test_profiler": 1.2299999999999998, "dynamo/test_python_autograd": 0.615, "dynamo/test_recompile_ux": 0.8060000000000002, "dynamo/test_recompiles": 0.7850000000000001, "dynamo/test_reorder_logs": 0.526, "dynamo/test_repros": 29.281000000000006, "dynamo/test_resume": 0.444, "dynamo/test_sdpa": 0.452, "dynamo/test_skip_non_tensor": 0.5850000000000001, "dynamo/test_sources": 0.474, "dynamo/test_structured_trace": 14.020000000000001, "dynamo/test_subclasses": 15.442000000000004, "dynamo/test_subgraphs": 1.959999999999999, "dynamo/test_trace_rules": 1.2389999999999999, "dynamo/test_unspec": 10.358999999999996, "dynamo/test_verify_correctness": 0.552, "export/test_converter": 0.282, "export/test_db": 2.698, "export/test_experimental": 0.891, "export/test_export": 25.279999999999998, "export/test_export_nonstrict": 20.551999999999996, "export/test_functionalized_assertions": 0.656, "export/test_hop": 1.638, "export/test_lift_unlift": 0.081, "export/test_pass_infra": 0.8220000000000002, "export/test_passes": 10.800999999999998, "export/test_retraceability": 35.62700000000001, "export/test_schema": 0.23700000000000002, "export/test_serdes": 23.555000000000007, "export/test_serialize": 8.176000000000002, "export/test_sparse": 51.943999999999875, "export/test_tools": 0.535, "export/test_torchbind": 2.4699999999999998, "export/test_tree_utils": 0.207, "export/test_unflatten": 2.9090000000000003, "export/test_verifier": 0.9000000000000001, "functorch/test_aotdispatch": 17.547999999999995, "functorch/test_control_flow": 109.28200000000012, "functorch/test_dims": 25.355999999999995, "functorch/test_eager_transforms": 9.401000000000002, "functorch/test_logging": 0.241, "functorch/test_memory_efficient_fusion": 7.620000000000001, "functorch/test_minifier": 0.3750000000000001, "functorch/test_ops": 4098.133999999959, "functorch/test_parsing": 0.621, "functorch/test_rearrange": 0.647, "functorch/test_vmap": 269.78699999999935, "functorch/test_vmap_registrations": 2.422999999999857, "higher_order_ops/test_with_effects": 4.790000000000001, "inductor/test_aot_inductor": 6037.761999999999, "inductor/test_benchmark_fusion": 100.257, "inductor/test_binary_folding": 34.722, "inductor/test_codecache": 126.89099999999998, "inductor/test_codegen_triton": 0.209, "inductor/test_compile_worker": 5.074, "inductor/test_compiled_autograd": 365.99900000000093, "inductor/test_compiled_optimizers": 1999.6939999999988, "inductor/test_config": 5.281000000000001, "inductor/test_control_flow": 119.36800000000002, "inductor/test_coordinate_descent_tuner": 3.097, "inductor/test_cpu_repro": 634.4519999999997, "inductor/test_cuda_cpp_wrapper": 2008.468, "inductor/test_cuda_repro": 79.04399999999998, "inductor/test_cudagraph_trees": 69.221, "inductor/test_custom_lowering": 3.5309999999999997, "inductor/test_custom_post_grad_passes": 10.284, "inductor/test_cutlass_backend": 127.94600000000001, "inductor/test_debug_trace": 13.411999999999999, "inductor/test_decompose_mem_bound_mm": 33.55799999999999, "inductor/test_dependencies": 0.21100000000000002, "inductor/test_distributed_patterns": 34.141, "inductor/test_efficient_conv_bn_eval": 303.692, "inductor/test_extension_backend": 16.721, "inductor/test_flex_attention": 407.5859999999999, "inductor/test_foreach": 294.94500000000005, "inductor/test_fp8": 0.009000000000000001, "inductor/test_fused_attention": 215.541, "inductor/test_fx_fusion": 0.16999999999999998, "inductor/test_group_batch_fusion": 107.04, "inductor/test_indexing": 0.5700000000000001, "inductor/test_inductor_freezing": 81.03, "inductor/test_inplacing_pass": 6.901999999999999, "inductor/test_kernel_benchmark": 123.53500000000001, "inductor/test_layout_optim": 13.370000000000001, "inductor/test_max_autotune": 241.46900000000005, "inductor/test_memory_planning": 28.843, "inductor/test_metrics": 3.7310000000000003, "inductor/test_minifier": 27.743000000000002, "inductor/test_minifier_isolate": 89.477, "inductor/test_mkldnn_pattern_matcher": 471.86399999999986, "inductor/test_mmdecomp": 9.152999999999999, "inductor/test_move_constructors_to_cuda": 14.815, "inductor/test_multi_kernel": 72.303, "inductor/test_pad_mm": 125.19800000000002, "inductor/test_padding": 18.915000000000003, "inductor/test_pattern_matcher": 92.172, "inductor/test_perf": 67.119, "inductor/test_profiler": 7.7909999999999995, "inductor/test_select_algorithm": 113.89200000000001, "inductor/test_smoke": 6.015, "inductor/test_snode_runtime": 13.686, "inductor/test_split_cat_fx_passes": 98.97900000000001, "inductor/test_standalone_compile": 18.533, "inductor/test_torchbind": 6.302, "inductor/test_torchinductor": 2701.65, "inductor/test_torchinductor_codegen_dynamic_shapes": 2611.9899999999984, "inductor/test_torchinductor_dynamic_shapes": 3082.062999999999, "inductor/test_torchinductor_opinfo": 1644.9859999999999, "inductor/test_triton_extension_backend": 0.521, "inductor/test_triton_heuristics": 0.005, "inductor/test_triton_kernels": 94.16099999999999, "inductor/test_triton_wrapper": 7.126, "inductor/test_unbacked_symints": 19.222, "inductor/test_utils": 0.206, "lazy/test_debug_util": 0.672, "lazy/test_functionalization": 0.705, "lazy/test_generator": 0.701, "lazy/test_reuse_ir": 0.8220000000000001, "lazy/test_step_closures": 2.642, "lazy/test_ts_opinfo": 0.7100000000000001, "nn/test_convolution": 72.00699999999948, "nn/test_dropout": 1.0670000000000002, "nn/test_embedding": 10.776000000000007, "nn/test_init": 3.9079999999999986, "nn/test_lazy_modules": 0.8040000000000002, "nn/test_load_state_dict": 1.057, "nn/test_module_hooks": 0.629, "nn/test_multihead_attention": 5.311000000000002, "nn/test_packed_sequence": 1.112, "nn/test_parametrization": 1.3329999999999989, "nn/test_pooling": 5.8439999999999985, "nn/test_pruning": 0.502, "profiler/test_execution_trace": 2.213, "profiler/test_memory_profiler": 4.467999999999999, "profiler/test_profiler": 28.034999999999997, "profiler/test_profiler_tree": 0.708, "profiler/test_record_function": 0.682, "profiler/test_torch_tidy": 3.7299999999999995, "test_ao_sparsity": 8.402, "test_autocast": 2.1479999999999997, "test_autograd": 27.085999999999988, "test_autograd_fallback": 0.752, "test_binary_ufuncs": 192.9829999999896, "test_bundled_inputs": 1.4449999999999996, "test_comparison_utils": 0.646, "test_compile_benchmark_util": 0.0, "test_complex": 0.51, "test_content_store": 2.5349999999999997, "test_cpp_api_parity": 8.48799999999999, "test_cpp_extensions_aot_ninja": 0.7520000000000001, "test_cpp_extensions_aot_no_ninja": 0.7180000000000001, "test_cpp_extensions_jit": 167.20499999999998, "test_cpp_extensions_mtia_backend": 0.43, "test_cpp_extensions_open_device_registration": 6.548000000000002, "test_cpp_extensions_stream_and_event": 0.429, "test_cuda": 121.34700000000008, "test_cuda_expandable_segments": 119.22900000000001, "test_cuda_multigpu": 1.31, "test_cuda_nvml_based_avail": 4.092, "test_cuda_primary_ctx": 1.281, "test_cuda_sanitizer": 0.6950000000000001, "test_cuda_trace": 6.864, "test_custom_ops": 7.6689999999999925, "test_dataloader": 274.94400000000013, "test_datapipe": 9.925000000000004, "test_decomp": 12470.275000000038, "test_deploy": 0.649, "test_dispatch": 32.493000000000016, "test_dlpack": 0.7740000000000001, "test_dynamic_shapes": 4.114999999999998, "test_expanded_weights": 12.071999999999997, "test_fake_tensor": 19.794000000000022, "test_flop_counter": 0.603, "test_foreach": 398.033000000008, "test_function_schema": 0.904, "test_functional_autograd_benchmark": 16.931, "test_functional_optim": 0.30000000000000004, "test_functionalization": 4.037999999999998, "test_functionalization_of_rng_ops": 2.317, "test_futures": 1.281, "test_fx": 220.36699999999988, "test_fx_experimental": 13.164000000000003, "test_fx_passes": 0.9860000000000002, "test_fx_reinplace_pass": 0.7990000000000002, "test_import_stats": 3.727, "test_indexing": 2.607999999999997, "test_itt": 0.653, "test_jit": 98.61099999999999, "test_jit_autocast": 27.256, "test_jit_disabled": 0.7390000000000001, "test_jit_fuser_te": 1046.8680000000006, "test_jit_llga_fuser": 0.061, "test_jiterator": 19.549999999999997, "test_legacy_vmap": 2.3629999999999987, "test_license": 0.649, "test_linalg": 1512.4719999999895, "test_logging": 2.696, "test_masked": 38.443000000000005, "test_maskedtensor": 6.969999999999925, "test_matmul_cuda": 87.487, "test_meta": 1645.8259999996342, "test_mkl_verbose": 4.4190000000000005, "test_mkldnn_fusion": 33.129000000000005, "test_mkldnn_verbose": 3.7199999999999998, "test_mobile_optimizer": 2.521, "test_model_dump": 1.2149999999999999, "test_model_exports_to_core_aten": 0.211, "test_module_tracker": 0.65, "test_modules": 2585.7570000000205, "test_monitor": 1.066, "test_multiprocessing": 86.254, "test_multiprocessing_spawn": 19.596000000000004, "test_namedtensor": 1.139999999999998, "test_namedtuple_return_api": 2.0020000000000002, "test_native_functions": 0.7700000000000001, "test_native_mha": 0.9570000000000004, "test_nestedtensor": 9.293999999999992, "test_nn": 168.86000000000428, "test_numba_integration": 0.562, "test_numpy_interop": 0.5840000000000001, "test_openmp": 3.948, "test_ops": 2972.9299999999844, "test_ops_fwd_gradients": 512.1880000000031, "test_ops_gradients": 1761.9459999998987, "test_overrides": 2.3179999999998895, "test_python_dispatch": 1.5710000000000002, "test_reductions": 135.2930000000027, "test_serialization": 5.867, "test_show_pickle": 0.66, "test_sort_and_select": 3.915999999999996, "test_spectral_ops": 18.66199999999997, "test_tensor_creation_ops": 77.4100000000003, "test_tensorexpr": 114.18600000000002, "test_torch": 88.32600000000005, "test_utils": 25.444000000000592}, "dynamic_aot_eager_huggingface": {"backends/xeon/test_launch": 2.041, "benchmark_utils/test_benchmark_utils": 2.254, "distributions/test_distributions": 67.289, "dynamo/test_activation_checkpointing": 19.144000000000005, "dynamo/test_after_aot": 4.873, "dynamo/test_aot_autograd": 13.240000000000006, "dynamo/test_aot_autograd_cache": 0.9520000000000001, "dynamo/test_autograd_function": 5.595, "dynamo/test_backends": 12.067, "dynamo/test_backward_higher_order_ops": 11.807, "dynamo/test_base_output": 0.002, "dynamo/test_bytecode_utils": 4.846, "dynamo/test_compile": 5.568, "dynamo/test_comptime": 0.5730000000000001, "dynamo/test_config": 0.589, "dynamo/test_ctx_manager": 3.0699999999999994, "dynamo/test_cudagraphs": 3.6839999999999997, "dynamo/test_debug_utils": 0.315, "dynamo/test_decorators": 0.7330000000000002, "dynamo/test_deviceguard": 0.016, "dynamo/test_dynamic_shapes": 1526.023, "dynamo/test_exc": 1.7979999999999998, "dynamo/test_export": 13.903999999999995, "dynamo/test_export_mutations": 0.543, "dynamo/test_frame_init": 0.205, "dynamo/test_functions": 20.50900000000002, "dynamo/test_fx_passes_pre_grad": 1.153, "dynamo/test_global": 0.522, "dynamo/test_guard_manager": 0.23900000000000002, "dynamo/test_higher_order_ops": 26.566000000000003, "dynamo/test_hooks": 23.534000000000002, "dynamo/test_input_attr_tracking": 6.452999999999999, "dynamo/test_interop": 0.5469999999999999, "dynamo/test_logging": 18.686000000000003, "dynamo/test_minifier": 2.064, "dynamo/test_misc": 47.72600000000011, "dynamo/test_model_output": 0.649, "dynamo/test_modules": 10.525999999999996, "dynamo/test_nops": 0.294, "dynamo/test_optimizers": 0.634, "dynamo/test_pre_dispatch": 0.47600000000000003, "dynamo/test_profiler": 1.268, "dynamo/test_python_autograd": 0.6100000000000001, "dynamo/test_recompile_ux": 0.8520000000000001, "dynamo/test_recompiles": 0.8580000000000001, "dynamo/test_reorder_logs": 0.521, "dynamo/test_repros": 29.562000000000037, "dynamo/test_resume": 0.42, "dynamo/test_sdpa": 0.47800000000000004, "dynamo/test_skip_non_tensor": 0.6, "dynamo/test_sources": 0.48, "dynamo/test_structured_trace": 14.29, "dynamo/test_subclasses": 15.741, "dynamo/test_subgraphs": 1.9799999999999993, "dynamo/test_trace_rules": 1.276, "dynamo/test_unspec": 10.607000000000001, "dynamo/test_verify_correctness": 0.5650000000000001, "export/test_converter": 0.306, "export/test_db": 2.7099999999999995, "export/test_experimental": 0.89, "export/test_export": 25.205, "export/test_export_nonstrict": 21.861999999999995, "export/test_functionalized_assertions": 0.639, "export/test_hop": 1.6529999999999998, "export/test_lift_unlift": 0.081, "export/test_pass_infra": 0.8220000000000002, "export/test_passes": 11.062999999999999, "export/test_retraceability": 35.981, "export/test_schema": 0.24, "export/test_serdes": 23.815999999999995, "export/test_serialize": 8.137999999999998, "export/test_sparse": 51.60899999999989, "export/test_tools": 0.553, "export/test_torchbind": 2.385, "export/test_tree_utils": 0.208, "export/test_unflatten": 2.8469999999999995, "export/test_verifier": 0.8450000000000001, "functorch/test_aotdispatch": 17.129, "functorch/test_control_flow": 110.42600000000007, "functorch/test_dims": 26.024, "functorch/test_eager_transforms": 9.607000000000003, "functorch/test_logging": 0.251, "functorch/test_memory_efficient_fusion": 7.579, "functorch/test_minifier": 0.38300000000000006, "functorch/test_ops": 4159.657999999983, "functorch/test_parsing": 0.673, "functorch/test_rearrange": 0.6960000000000001, "functorch/test_vmap": 276.53199999999947, "functorch/test_vmap_registrations": 2.3919999999998596, "higher_order_ops/test_with_effects": 4.662, "inductor/test_aot_inductor": 6059.445999999999, "inductor/test_benchmark_fusion": 100.198, "inductor/test_binary_folding": 34.56, "inductor/test_codecache": 125.20899999999999, "inductor/test_codegen_triton": 0.214, "inductor/test_compile_worker": 5.04, "inductor/test_compiled_autograd": 363.01900000000086, "inductor/test_compiled_optimizers": 2021.192, "inductor/test_config": 5.4220000000000015, "inductor/test_control_flow": 121.61600000000001, "inductor/test_coordinate_descent_tuner": 3.148, "inductor/test_cpu_repro": 642.9640000000002, "inductor/test_cuda_cpp_wrapper": 1986.2490000000005, "inductor/test_cuda_repro": 78.55599999999998, "inductor/test_cudagraph_trees": 65.939, "inductor/test_custom_lowering": 3.517, "inductor/test_custom_post_grad_passes": 10.283, "inductor/test_cutlass_backend": 127.765, "inductor/test_debug_trace": 12.181, "inductor/test_decompose_mem_bound_mm": 33.321, "inductor/test_dependencies": 0.203, "inductor/test_distributed_patterns": 34.077999999999996, "inductor/test_efficient_conv_bn_eval": 301.927, "inductor/test_extension_backend": 16.838, "inductor/test_flex_attention": 407.443, "inductor/test_foreach": 297.1200000000002, "inductor/test_fp8": 0.010000000000000002, "inductor/test_fused_attention": 219.78300000000002, "inductor/test_fx_fusion": 0.175, "inductor/test_group_batch_fusion": 107.724, "inductor/test_indexing": 0.5700000000000001, "inductor/test_inductor_freezing": 80.742, "inductor/test_inplacing_pass": 7.059999999999999, "inductor/test_kernel_benchmark": 125.20099999999998, "inductor/test_layout_optim": 13.487, "inductor/test_max_autotune": 241.02300000000002, "inductor/test_memory_planning": 29.358999999999998, "inductor/test_metrics": 3.83, "inductor/test_minifier": 28.498, "inductor/test_minifier_isolate": 91.03, "inductor/test_mkldnn_pattern_matcher": 485.4579999999997, "inductor/test_mmdecomp": 9.004999999999997, "inductor/test_move_constructors_to_cuda": 15.024, "inductor/test_multi_kernel": 72.86099999999999, "inductor/test_pad_mm": 126.505, "inductor/test_padding": 18.807000000000006, "inductor/test_pattern_matcher": 91.73200000000003, "inductor/test_perf": 66.386, "inductor/test_profiler": 7.954, "inductor/test_select_algorithm": 114.208, "inductor/test_smoke": 6.116, "inductor/test_snode_runtime": 14.003, "inductor/test_split_cat_fx_passes": 99.48400000000001, "inductor/test_standalone_compile": 18.371, "inductor/test_torchbind": 6.275, "inductor/test_torchinductor": 17.781000000000002, "inductor/test_torchinductor_codegen_dynamic_shapes": 15.485, "inductor/test_torchinductor_dynamic_shapes": 9.116, "nn/test_convolution": 71.57399999999947, "nn/test_pooling": 5.908999999999998, "profiler/test_profiler": 0.7110000000000001, "test_autocast": 2.1249999999999996, "test_autograd_fallback": 0.7290000000000001, "test_cpp_api_parity": 8.709999999999983, "test_cpp_extensions_aot_ninja": 0.7510000000000001, "test_cpp_extensions_aot_no_ninja": 0.7300000000000001, "test_cpp_extensions_jit": 165.996, "test_cpp_extensions_mtia_backend": 0.423, "test_cpp_extensions_open_device_registration": 6.681000000000001, "test_cpp_extensions_stream_and_event": 0.422, "test_cuda": 15.005999999999998, "test_cuda_expandable_segments": 16.323, "test_cuda_multigpu": 0.856, "test_cuda_nvml_based_avail": 4.0329999999999995, "test_cuda_primary_ctx": 1.268, "test_cuda_trace": 6.728, "test_dispatch": 32.650000000000006, "test_fake_tensor": 16.55200000000001, "test_fx": 220.17299999999997, "test_indexing": 0.554, "test_jit_disabled": 0.7230000000000001, "test_linalg": 13.372, "test_mobile_optimizer": 2.638, "test_multiprocessing": 85.95200000000001, "test_multiprocessing_spawn": 19.490999999999996, "test_namedtuple_return_api": 1.9900000000000002, "test_native_mha": 1.0450000000000002, "test_nn": 166.21700000000436, "test_overrides": 2.3149999999998894, "test_python_dispatch": 1.6989999999999998, "test_reductions": 132.69500000000238, "test_serialization": 5.785, "test_show_pickle": 0.644, "test_sort_and_select": 3.967999999999995, "test_spectral_ops": 18.69099999999996, "test_tensor_creation_ops": 76.91800000000025, "test_tensorexpr": 114.41000000000001, "test_torch": 87.79100000000007, "test_utils": 25.724000000000576}, "dynamic_aot_eager_timm": {"backends/xeon/test_launch": 2.209, "benchmark_utils/test_benchmark_utils": 2.215, "distributions/test_distributions": 68.00800000000002, "dynamo/test_activation_checkpointing": 19.563000000000006, "dynamo/test_after_aot": 4.829000000000001, "dynamo/test_aot_autograd": 13.21, "dynamo/test_aot_autograd_cache": 0.9620000000000001, "dynamo/test_autograd_function": 5.384, "dynamo/test_backends": 13.528, "dynamo/test_backward_higher_order_ops": 10.688, "dynamo/test_base_output": 0.003, "dynamo/test_bytecode_utils": 6.085999999999999, "dynamo/test_compile": 5.601, "dynamo/test_comptime": 0.5680000000000001, "dynamo/test_config": 0.565, "dynamo/test_ctx_manager": 3.0719999999999996, "dynamo/test_cudagraphs": 3.591, "dynamo/test_debug_utils": 0.304, "dynamo/test_decorators": 0.6720000000000002, "dynamo/test_deviceguard": 0.016, "dynamo/test_dynamic_shapes": 1527.6340000000002, "dynamo/test_exc": 1.8800000000000001, "dynamo/test_export": 13.794999999999993, "dynamo/test_export_mutations": 0.525, "dynamo/test_frame_init": 0.204, "dynamo/test_functions": 20.95599999999998, "dynamo/test_fx_passes_pre_grad": 1.186, "dynamo/test_global": 0.514, "dynamo/test_guard_manager": 0.22500000000000003, "dynamo/test_higher_order_ops": 26.906, "dynamo/test_hooks": 23.360000000000014, "dynamo/test_input_attr_tracking": 6.532, "dynamo/test_interop": 0.5549999999999999, "dynamo/test_logging": 18.564999999999998, "dynamo/test_minifier": 2.072, "dynamo/test_misc": 47.73800000000007, "dynamo/test_model_output": 0.639, "dynamo/test_modules": 10.698999999999996, "dynamo/test_nops": 0.299, "dynamo/test_optimizers": 0.627, "dynamo/test_pre_dispatch": 0.47700000000000004, "dynamo/test_profiler": 1.2829999999999997, "dynamo/test_python_autograd": 0.632, "dynamo/test_recompile_ux": 0.8120000000000002, "dynamo/test_recompiles": 0.799, "dynamo/test_reorder_logs": 0.503, "dynamo/test_repros": 29.776999999999997, "dynamo/test_resume": 0.48, "dynamo/test_sdpa": 0.465, "dynamo/test_skip_non_tensor": 0.5800000000000001, "dynamo/test_sources": 0.466, "dynamo/test_structured_trace": 14.24, "dynamo/test_subclasses": 15.772999999999998, "dynamo/test_subgraphs": 2.0399999999999996, "dynamo/test_trace_rules": 1.246, "dynamo/test_unspec": 10.407, "dynamo/test_verify_correctness": 0.5650000000000001, "export/test_converter": 0.303, "export/test_db": 2.7199999999999993, "export/test_experimental": 0.9, "export/test_export": 25.244999999999997, "export/test_export_nonstrict": 20.578999999999994, "export/test_functionalized_assertions": 0.638, "export/test_hop": 1.6619999999999997, "export/test_lift_unlift": 0.081, "export/test_pass_infra": 0.8240000000000002, "export/test_passes": 10.775, "export/test_retraceability": 36.00900000000001, "export/test_schema": 0.245, "export/test_serdes": 24.079999999999995, "export/test_serialize": 8.481999999999998, "export/test_sparse": 52.9679999999999, "export/test_tools": 0.529, "export/test_torchbind": 2.402999999999999, "export/test_tree_utils": 0.209, "export/test_unflatten": 3.029, "export/test_verifier": 0.8770000000000001, "functorch/test_aotdispatch": 17.957000000000004, "functorch/test_control_flow": 113.14300000000004, "functorch/test_dims": 26.375999999999998, "functorch/test_eager_transforms": 9.440000000000001, "functorch/test_logging": 0.246, "functorch/test_memory_efficient_fusion": 7.6019999999999985, "functorch/test_minifier": 0.3820000000000001, "functorch/test_ops": 4079.956999999955, "functorch/test_parsing": 0.678, "functorch/test_rearrange": 0.7080000000000001, "functorch/test_vmap": 257.20899999999955, "functorch/test_vmap_registrations": 2.4229999999998575, "higher_order_ops/test_with_effects": 4.831, "inductor/test_aot_inductor": 6063.726999999998, "inductor/test_benchmark_fusion": 100.061, "inductor/test_binary_folding": 34.544, "inductor/test_codecache": 126.26200000000003, "inductor/test_codegen_triton": 0.21, "inductor/test_compile_worker": 5.036, "inductor/test_compiled_autograd": 363.8450000000009, "inductor/test_compiled_optimizers": 2043.1670000000004, "inductor/test_config": 5.430000000000001, "inductor/test_control_flow": 121.762, "inductor/test_coordinate_descent_tuner": 3.18, "inductor/test_cpu_repro": 643.1419999999997, "inductor/test_cuda_cpp_wrapper": 1982.551, "inductor/test_cuda_repro": 78.24300000000001, "inductor/test_cudagraph_trees": 66.418, "inductor/test_custom_lowering": 3.584, "inductor/test_custom_post_grad_passes": 10.109, "inductor/test_cutlass_backend": 127.39500000000004, "inductor/test_debug_trace": 13.453000000000001, "inductor/test_decompose_mem_bound_mm": 33.589, "inductor/test_dependencies": 0.21100000000000002, "inductor/test_distributed_patterns": 34.006, "inductor/test_efficient_conv_bn_eval": 301.272, "inductor/test_extension_backend": 16.884, "inductor/test_flex_attention": 406.83299999999974, "inductor/test_foreach": 294.5940000000001, "inductor/test_fp8": 0.008, "inductor/test_fused_attention": 217.849, "inductor/test_fx_fusion": 0.18, "inductor/test_group_batch_fusion": 108.088, "inductor/test_indexing": 0.5750000000000001, "inductor/test_inductor_freezing": 81.892, "inductor/test_inplacing_pass": 7.0249999999999995, "inductor/test_kernel_benchmark": 125.64299999999997, "inductor/test_layout_optim": 13.676, "inductor/test_max_autotune": 240.39500000000007, "inductor/test_memory_planning": 29.487, "inductor/test_metrics": 3.814000000000001, "inductor/test_minifier": 28.287, "inductor/test_minifier_isolate": 91.53999999999999, "inductor/test_mkldnn_pattern_matcher": 477.56699999999995, "inductor/test_mmdecomp": 9.021999999999998, "inductor/test_move_constructors_to_cuda": 14.790000000000001, "inductor/test_multi_kernel": 71.87799999999999, "inductor/test_pad_mm": 126.95899999999999, "inductor/test_padding": 19.125999999999998, "inductor/test_pattern_matcher": 92.15199999999999, "inductor/test_perf": 66.74300000000001, "inductor/test_profiler": 7.667, "inductor/test_select_algorithm": 115.85300000000001, "inductor/test_smoke": 6.145, "inductor/test_snode_runtime": 13.566, "inductor/test_split_cat_fx_passes": 98.422, "inductor/test_standalone_compile": 18.233, "inductor/test_torchbind": 6.186, "inductor/test_torchinductor": 2727.796999999998, "inductor/test_torchinductor_codegen_dynamic_shapes": 2617.656999999999, "inductor/test_torchinductor_dynamic_shapes": 3094.2470000000008, "inductor/test_torchinductor_opinfo": 1646.414999999999, "inductor/test_triton_extension_backend": 0.541, "inductor/test_triton_heuristics": 0.007, "inductor/test_triton_kernels": 94.96800000000002, "inductor/test_triton_wrapper": 7.103, "inductor/test_unbacked_symints": 19.179, "inductor/test_utils": 0.21, "lazy/test_debug_util": 0.69, "lazy/test_functionalization": 0.7230000000000001, "lazy/test_generator": 0.697, "lazy/test_reuse_ir": 0.848, "lazy/test_step_closures": 2.6479999999999997, "lazy/test_ts_opinfo": 0.7110000000000001, "nn/test_convolution": 72.6299999999995, "nn/test_dropout": 1.014, "nn/test_embedding": 9.807999999999993, "nn/test_init": 3.994999999999999, "nn/test_lazy_modules": 0.8350000000000002, "nn/test_load_state_dict": 1.1089999999999995, "nn/test_module_hooks": 0.6460000000000001, "nn/test_multihead_attention": 5.434999999999999, "nn/test_packed_sequence": 1.2499999999999998, "nn/test_parametrization": 1.339999999999999, "nn/test_pooling": 5.835999999999997, "nn/test_pruning": 0.508, "profiler/test_execution_trace": 2.357, "profiler/test_memory_profiler": 4.603999999999999, "profiler/test_profiler": 28.506, "profiler/test_profiler_tree": 0.706, "profiler/test_record_function": 0.675, "profiler/test_torch_tidy": 3.9699999999999993, "test_ao_sparsity": 9.133999999999999, "test_autocast": 2.13, "test_autograd": 27.38199999999998, "test_autograd_fallback": 0.7310000000000001, "test_binary_ufuncs": 190.51799999999622, "test_bundled_inputs": 1.329, "test_comparison_utils": 0.654, "test_compile_benchmark_util": 0.0, "test_complex": 0.52, "test_content_store": 2.659, "test_cpp_api_parity": 8.475999999999994, "test_cpp_extensions_aot_ninja": 0.7450000000000001, "test_cpp_extensions_aot_no_ninja": 0.7110000000000001, "test_cpp_extensions_jit": 165.30100000000002, "test_cpp_extensions_mtia_backend": 0.42, "test_cpp_extensions_open_device_registration": 6.511000000000003, "test_cpp_extensions_stream_and_event": 0.42, "test_cuda": 122.4, "test_cuda_expandable_segments": 122.16600000000001, "test_cuda_multigpu": 1.334, "test_cuda_nvml_based_avail": 4.042999999999999, "test_cuda_primary_ctx": 1.256, "test_cuda_sanitizer": 0.7250000000000001, "test_cuda_trace": 6.662000000000001, "test_custom_ops": 7.820999999999994, "test_dataloader": 280.00000000000006, "test_datapipe": 10.539, "test_decomp": 12680.937000000054, "test_deploy": 0.624, "test_dispatch": 32.244000000000014, "test_dlpack": 0.7450000000000001, "test_dynamic_shapes": 4.168999999999999, "test_expanded_weights": 12.041999999999998, "test_fake_tensor": 16.60200000000001, "test_flop_counter": 0.609, "test_foreach": 402.69200000000814, "test_function_schema": 0.901, "test_functional_autograd_benchmark": 16.672, "test_functional_optim": 0.29400000000000004, "test_functionalization": 4.027999999999998, "test_functionalization_of_rng_ops": 2.305, "test_futures": 1.261, "test_fx": 218.80799999999988, "test_fx_experimental": 13.033999999999999, "test_fx_passes": 0.9950000000000002, "test_fx_reinplace_pass": 0.7820000000000001, "test_import_stats": 3.7059999999999995, "test_indexing": 2.765999999999994, "test_itt": 0.628, "test_jit": 97.849, "test_jit_autocast": 26.416999999999998, "test_jit_disabled": 0.7240000000000001, "test_jit_fuser_te": 1041.3900000000008, "test_jit_llga_fuser": 0.059000000000000004, "test_jiterator": 19.51000000000001, "test_legacy_vmap": 2.3649999999999984, "test_license": 0.622, "test_linalg": 1512.0079999999914, "test_logging": 2.716, "test_masked": 40.00299999999997, "test_maskedtensor": 6.979999999999922, "test_matmul_cuda": 89.664, "test_meta": 1647.7349999997136, "test_mkl_verbose": 3.774, "test_mkldnn_fusion": 34.058, "test_mkldnn_verbose": 3.567, "test_mobile_optimizer": 2.566, "test_model_dump": 1.238, "test_model_exports_to_core_aten": 0.204, "test_module_tracker": 0.636, "test_modules": 2532.230000000023, "test_monitor": 0.866, "test_multiprocessing": 85.61100000000003, "test_multiprocessing_spawn": 19.409, "test_namedtensor": 1.1549999999999978, "test_namedtuple_return_api": 1.983, "test_native_functions": 0.7430000000000001, "test_native_mha": 0.9500000000000004, "test_nestedtensor": 9.211999999999989, "test_nn": 167.57900000000436, "test_numba_integration": 0.521, "test_numpy_interop": 0.5930000000000001, "test_openmp": 4.021, "test_ops": 3057.063999999985, "test_ops_fwd_gradients": 512.3580000000035, "test_ops_gradients": 1806.3319999998796, "test_overrides": 2.309999999999888, "test_python_dispatch": 1.567, "test_reductions": 134.5689999999989, "test_serialization": 5.793, "test_show_pickle": 0.641, "test_sort_and_select": 3.857999999999995, "test_spectral_ops": 18.65399999999996, "test_tensor_creation_ops": 80.15700000000031, "test_tensorexpr": 114.13600000000001, "test_torch": 87.69600000000004, "test_utils": 25.38800000000058}, "dynamic_aot_eager_torchbench": {"backends/xeon/test_launch": 2.1919999999999997, "benchmark_utils/test_benchmark_utils": 2.1889999999999996, "distributions/test_distributions": 67.262, "dynamo/test_activation_checkpointing": 19.409, "dynamo/test_after_aot": 4.800999999999999, "dynamo/test_aot_autograd": 13.158000000000003, "dynamo/test_aot_autograd_cache": 0.9380000000000001, "dynamo/test_autograd_function": 5.3469999999999995, "dynamo/test_backends": 12.056999999999999, "dynamo/test_backward_higher_order_ops": 12.034, "dynamo/test_base_output": 0.002, "dynamo/test_bytecode_utils": 7.55, "dynamo/test_compile": 5.499, "dynamo/test_comptime": 0.56, "dynamo/test_config": 0.572, "dynamo/test_ctx_manager": 3.0179999999999993, "dynamo/test_cudagraphs": 3.3970000000000002, "dynamo/test_debug_utils": 0.318, "dynamo/test_decorators": 0.6850000000000002, "dynamo/test_deviceguard": 0.015, "dynamo/test_dynamic_shapes": 1526.0860000000002, "dynamo/test_exc": 1.7689999999999997, "dynamo/test_export": 13.825000000000005, "dynamo/test_export_mutations": 0.524, "dynamo/test_frame_init": 0.205, "dynamo/test_functions": 20.682000000000016, "dynamo/test_fx_passes_pre_grad": 1.124, "dynamo/test_global": 0.504, "dynamo/test_guard_manager": 0.22500000000000003, "dynamo/test_higher_order_ops": 26.748, "dynamo/test_hooks": 23.29300000000001, "dynamo/test_input_attr_tracking": 6.536999999999999, "dynamo/test_interop": 0.5409999999999999, "dynamo/test_logging": 18.595, "dynamo/test_minifier": 2.056, "dynamo/test_misc": 47.48900000000008, "dynamo/test_model_output": 0.626, "dynamo/test_modules": 10.448999999999995, "dynamo/test_nops": 0.292, "dynamo/test_optimizers": 0.609, "dynamo/test_pre_dispatch": 0.47500000000000003, "dynamo/test_profiler": 1.274, "dynamo/test_python_autograd": 0.611, "dynamo/test_recompile_ux": 0.7900000000000001, "dynamo/test_recompiles": 0.8210000000000001, "dynamo/test_reorder_logs": 0.506, "dynamo/test_repros": 29.606, "dynamo/test_resume": 0.423, "dynamo/test_sdpa": 0.49300000000000005, "dynamo/test_skip_non_tensor": 0.5850000000000001, "dynamo/test_sources": 0.47, "dynamo/test_structured_trace": 14.150999999999998, "dynamo/test_subclasses": 15.748999999999999, "dynamo/test_subgraphs": 1.979999999999999, "dynamo/test_trace_rules": 1.226, "dynamo/test_unspec": 10.423999999999998, "dynamo/test_verify_correctness": 0.556, "export/test_converter": 0.278, "export/test_db": 2.7529999999999992, "export/test_experimental": 0.914, "export/test_export": 25.450999999999986, "export/test_export_nonstrict": 20.805999999999994, "export/test_functionalized_assertions": 0.638, "export/test_hop": 1.6669999999999996, "export/test_lift_unlift": 0.083, "export/test_pass_infra": 0.8260000000000002, "export/test_passes": 10.71, "export/test_retraceability": 35.897, "export/test_schema": 0.23700000000000002, "export/test_serdes": 24.235999999999997, "export/test_serialize": 8.257, "export/test_sparse": 52.24199999999989, "export/test_tools": 0.533, "export/test_torchbind": 2.3889999999999993, "export/test_tree_utils": 0.207, "export/test_unflatten": 2.951, "export/test_verifier": 0.8630000000000001, "functorch/test_aotdispatch": 17.565999999999995, "functorch/test_control_flow": 110.67900000000009, "functorch/test_dims": 25.871000000000002, "functorch/test_eager_transforms": 9.584000000000001, "functorch/test_logging": 0.246, "functorch/test_memory_efficient_fusion": 7.561, "functorch/test_minifier": 0.384, "functorch/test_ops": 4112.096999999984, "functorch/test_parsing": 0.665, "functorch/test_rearrange": 0.6920000000000001, "functorch/test_vmap": 277.409999999999, "functorch/test_vmap_registrations": 2.4109999999998584, "higher_order_ops/test_with_effects": 4.879, "inductor/test_aot_inductor": 6058.982999999999, "inductor/test_benchmark_fusion": 99.77600000000001, "inductor/test_binary_folding": 34.015, "inductor/test_codecache": 125.40799999999997, "inductor/test_codegen_triton": 0.212, "inductor/test_compile_worker": 5.0280000000000005, "inductor/test_compiled_autograd": 362.9340000000008, "inductor/test_compiled_optimizers": 2033.8529999999996, "inductor/test_config": 5.399000000000001, "inductor/test_control_flow": 121.78500000000003, "inductor/test_coordinate_descent_tuner": 3.0820000000000003, "inductor/test_cpu_repro": 645.5740000000001, "inductor/test_cuda_cpp_wrapper": 1982.6370000000002, "inductor/test_cuda_repro": 77.55200000000002, "inductor/test_cudagraph_trees": 65.89399999999996, "inductor/test_custom_lowering": 3.535, "inductor/test_custom_post_grad_passes": 10.031, "inductor/test_cutlass_backend": 127.491, "inductor/test_debug_trace": 13.498, "inductor/test_decompose_mem_bound_mm": 33.498, "inductor/test_dependencies": 0.20800000000000002, "inductor/test_distributed_patterns": 33.849, "inductor/test_efficient_conv_bn_eval": 301.184, "inductor/test_extension_backend": 16.645, "inductor/test_flex_attention": 406.47399999999993, "inductor/test_foreach": 293.38199999999995, "inductor/test_fp8": 0.007, "inductor/test_fused_attention": 218.78199999999998, "inductor/test_fx_fusion": 0.174, "inductor/test_group_batch_fusion": 107.88899999999998, "inductor/test_indexing": 0.5690000000000001, "inductor/test_inductor_freezing": 81.844, "inductor/test_inplacing_pass": 6.9670000000000005, "inductor/test_kernel_benchmark": 125.846, "inductor/test_layout_optim": 13.601000000000003, "inductor/test_max_autotune": 240.47700000000003, "inductor/test_memory_planning": 29.348, "inductor/test_metrics": 3.846, "inductor/test_minifier": 28.157000000000004, "inductor/test_minifier_isolate": 91.065, "inductor/test_mkldnn_pattern_matcher": 476.01499999999976, "inductor/test_mmdecomp": 9.098999999999998, "inductor/test_move_constructors_to_cuda": 14.668, "inductor/test_multi_kernel": 71.37299999999999, "inductor/test_pad_mm": 122.96899999999998, "inductor/test_padding": 18.813000000000002, "inductor/test_pattern_matcher": 91.66800000000002, "inductor/test_perf": 66.87, "inductor/test_profiler": 7.691000000000001, "inductor/test_select_algorithm": 114.99699999999999, "inductor/test_smoke": 5.955, "inductor/test_snode_runtime": 13.447000000000001, "inductor/test_split_cat_fx_passes": 98.03899999999999, "inductor/test_standalone_compile": 18.154, "inductor/test_torchbind": 6.235, "inductor/test_torchinductor": 2725.810000000001, "inductor/test_torchinductor_codegen_dynamic_shapes": 2608.305, "inductor/test_torchinductor_dynamic_shapes": 3088.665, "inductor/test_torchinductor_opinfo": 1643.2669999999985, "inductor/test_triton_extension_backend": 0.533, "inductor/test_triton_heuristics": 0.005, "inductor/test_triton_kernels": 94.18799999999993, "inductor/test_triton_wrapper": 7.267, "inductor/test_unbacked_symints": 19.183, "inductor/test_utils": 0.211, "lazy/test_debug_util": 0.674, "lazy/test_functionalization": 0.6960000000000001, "lazy/test_generator": 0.717, "lazy/test_reuse_ir": 0.8400000000000001, "lazy/test_step_closures": 2.6569999999999996, "lazy/test_ts_opinfo": 0.7190000000000001, "nn/test_convolution": 71.46999999999944, "nn/test_dropout": 1.0230000000000001, "nn/test_embedding": 10.404000000000005, "nn/test_init": 3.941999999999999, "nn/test_lazy_modules": 0.7970000000000002, "nn/test_load_state_dict": 1.0719999999999994, "nn/test_module_hooks": 0.681, "nn/test_multihead_attention": 4.962000000000001, "nn/test_packed_sequence": 1.9229999999999994, "nn/test_parametrization": 1.286999999999999, "nn/test_pooling": 5.847999999999996, "nn/test_pruning": 0.49700000000000005, "profiler/test_execution_trace": 2.235, "profiler/test_memory_profiler": 4.593999999999999, "profiler/test_profiler": 28.23399999999999, "profiler/test_profiler_tree": 0.7030000000000001, "profiler/test_record_function": 0.673, "profiler/test_torch_tidy": 3.8229999999999995, "test_ao_sparsity": 8.630999999999998, "test_autocast": 2.18, "test_autograd": 27.318999999999978, "test_autograd_fallback": 0.7280000000000001, "test_binary_ufuncs": 192.01099999999084, "test_bundled_inputs": 1.3269999999999995, "test_comparison_utils": 0.64, "test_compile_benchmark_util": 0.0, "test_complex": 0.528, "test_content_store": 2.5949999999999998, "test_cpp_api_parity": 8.555999999999987, "test_cpp_extensions_aot_ninja": 0.7400000000000001, "test_cpp_extensions_aot_no_ninja": 0.7100000000000001, "test_cpp_extensions_jit": 165.61800000000002, "test_cpp_extensions_mtia_backend": 0.42, "test_cpp_extensions_open_device_registration": 6.662000000000003, "test_cpp_extensions_stream_and_event": 0.419, "test_cuda": 122.86200000000005, "test_cuda_expandable_segments": 121.363, "test_cuda_multigpu": 1.3229999999999993, "test_cuda_nvml_based_avail": 4.03, "test_cuda_primary_ctx": 1.248, "test_cuda_sanitizer": 0.7290000000000001, "test_cuda_trace": 6.628000000000001, "test_custom_ops": 7.627999999999993, "test_dataloader": 288.94500000000005, "test_datapipe": 9.888999999999998, "test_decomp": 12520.775000000023, "test_deploy": 0.638, "test_dispatch": 32.48600000000001, "test_dlpack": 0.7640000000000001, "test_dynamic_shapes": 4.132999999999999, "test_expanded_weights": 12.067000000000002, "test_fake_tensor": 16.600000000000016, "test_flop_counter": 0.611, "test_foreach": 387.1130000000071, "test_function_schema": 0.883, "test_functional_autograd_benchmark": 16.306, "test_functional_optim": 0.28800000000000003, "test_functionalization": 3.9279999999999977, "test_functionalization_of_rng_ops": 2.298, "test_futures": 1.257, "test_fx": 216.60600000000002, "test_fx_experimental": 12.855000000000004, "test_fx_passes": 1.0000000000000002, "test_fx_reinplace_pass": 0.7740000000000001, "test_import_stats": 3.6559999999999997, "test_indexing": 2.530999999999993, "test_itt": 0.628, "test_jit": 96.71999999999998, "test_jit_autocast": 26.916, "test_jit_disabled": 0.7170000000000001, "test_jit_fuser_te": 1043.9790000000007, "test_jit_llga_fuser": 0.061, "test_jiterator": 19.580000000000016, "test_legacy_vmap": 2.312999999999999, "test_license": 0.642, "test_linalg": 1509.3409999999892, "test_logging": 2.752, "test_masked": 39.32600000000002, "test_maskedtensor": 7.223999999999894, "test_matmul_cuda": 87.76200000000001, "test_meta": 1629.3709999996117, "test_mkl_verbose": 3.8659999999999997, "test_mkldnn_fusion": 34.78, "test_mkldnn_verbose": 3.529, "test_mobile_optimizer": 2.597, "test_model_dump": 1.172, "test_model_exports_to_core_aten": 0.198, "test_module_tracker": 0.646, "test_modules": 2547.987000000032, "test_monitor": 0.9259999999999999, "test_multiprocessing": 85.56800000000001, "test_multiprocessing_spawn": 19.335, "test_namedtensor": 1.0879999999999999, "test_namedtuple_return_api": 1.97, "test_native_functions": 0.7120000000000001, "test_native_mha": 0.9590000000000004, "test_nestedtensor": 8.95799999999999, "test_nn": 168.0900000000043, "test_numba_integration": 0.529, "test_numpy_interop": 0.5950000000000001, "test_openmp": 3.928, "test_ops": 3010.414999999983, "test_ops_fwd_gradients": 475.1170000000043, "test_ops_gradients": 1808.4939999998746, "test_overrides": 2.29599999999989, "test_python_dispatch": 1.5579999999999998, "test_reductions": 133.6980000000013, "test_serialization": 5.921, "test_show_pickle": 0.646, "test_sort_and_select": 3.7869999999999964, "test_spectral_ops": 18.640999999999966, "test_tensor_creation_ops": 77.24400000000031, "test_tensorexpr": 114.41600000000001, "test_torch": 87.65100000000002, "test_utils": 25.655000000000577}, "dynamo_eager_huggingface": {"backends/xeon/test_launch": 2.148, "benchmark_utils/test_benchmark_utils": 2.148, "distributions/test_distributions": 67.53399999999999, "dynamo/test_activation_checkpointing": 19.008000000000003, "dynamo/test_after_aot": 4.779, "dynamo/test_aot_autograd": 12.900999999999998, "dynamo/test_aot_autograd_cache": 0.9720000000000001, "dynamo/test_autograd_function": 5.4030000000000005, "dynamo/test_backends": 11.931999999999999, "dynamo/test_backward_higher_order_ops": 11.874, "dynamo/test_base_output": 0.002, "dynamo/test_bytecode_utils": 4.7490000000000006, "dynamo/test_compile": 5.462000000000001, "dynamo/test_comptime": 0.5860000000000001, "dynamo/test_config": 0.566, "dynamo/test_ctx_manager": 3.0419999999999985, "dynamo/test_cudagraphs": 3.3989999999999996, "dynamo/test_debug_utils": 0.323, "dynamo/test_decorators": 0.6480000000000001, "dynamo/test_deviceguard": 0.017, "dynamo/test_dynamic_shapes": 1523.789, "dynamo/test_exc": 1.8529999999999998, "dynamo/test_export": 13.659, "dynamo/test_export_mutations": 0.545, "dynamo/test_frame_init": 0.2, "dynamo/test_functions": 20.171000000000028, "dynamo/test_fx_passes_pre_grad": 1.155, "dynamo/test_global": 0.507, "dynamo/test_guard_manager": 0.22700000000000004, "dynamo/test_higher_order_ops": 25.965, "dynamo/test_hooks": 23.18900000000001, "dynamo/test_input_attr_tracking": 6.3889999999999985, "dynamo/test_interop": 0.5409999999999999, "dynamo/test_logging": 18.495999999999995, "dynamo/test_minifier": 2.0810000000000004, "dynamo/test_misc": 47.26700000000008, "dynamo/test_model_output": 0.627, "dynamo/test_modules": 10.502999999999997, "dynamo/test_nops": 0.28900000000000003, "dynamo/test_optimizers": 0.624, "dynamo/test_pre_dispatch": 0.468, "dynamo/test_profiler": 1.2530000000000001, "dynamo/test_python_autograd": 0.618, "dynamo/test_recompile_ux": 0.7990000000000002, "dynamo/test_recompiles": 0.782, "dynamo/test_reorder_logs": 0.528, "dynamo/test_repros": 29.443000000000026, "dynamo/test_resume": 0.45, "dynamo/test_sdpa": 0.46900000000000003, "dynamo/test_skip_non_tensor": 0.5880000000000001, "dynamo/test_sources": 0.476, "dynamo/test_structured_trace": 14.097, "dynamo/test_subclasses": 15.633000000000003, "dynamo/test_subgraphs": 2.0189999999999992, "dynamo/test_trace_rules": 1.2409999999999999, "dynamo/test_unspec": 10.466000000000001, "dynamo/test_verify_correctness": 0.56, "export/test_converter": 0.28, "export/test_db": 2.828, "export/test_experimental": 0.904, "export/test_export": 25.010999999999992, "export/test_export_nonstrict": 20.700000000000003, "export/test_functionalized_assertions": 0.626, "export/test_hop": 1.65, "export/test_lift_unlift": 0.081, "export/test_pass_infra": 0.8200000000000002, "export/test_passes": 10.873000000000001, "export/test_retraceability": 36.15999999999998, "export/test_schema": 0.23900000000000002, "export/test_serdes": 24.076999999999984, "export/test_serialize": 8.1, "export/test_sparse": 53.16499999999989, "export/test_tools": 0.536, "export/test_torchbind": 2.451999999999999, "export/test_tree_utils": 0.213, "export/test_unflatten": 3.004, "export/test_verifier": 0.8970000000000001, "functorch/test_aotdispatch": 18.060999999999993, "functorch/test_control_flow": 110.2910000000001, "functorch/test_dims": 25.747, "functorch/test_eager_transforms": 9.368, "functorch/test_logging": 0.244, "functorch/test_memory_efficient_fusion": 7.598000000000001, "functorch/test_minifier": 0.3760000000000001, "functorch/test_ops": 4103.409999999989, "functorch/test_parsing": 0.652, "functorch/test_rearrange": 0.6880000000000001, "functorch/test_vmap": 268.194999999999, "functorch/test_vmap_registrations": 2.4299999999998563, "higher_order_ops/test_with_effects": 4.777, "inductor/test_aot_inductor": 5998.1619999999975, "inductor/test_benchmark_fusion": 99.875, "inductor/test_binary_folding": 34.047000000000004, "inductor/test_codecache": 123.76300000000002, "inductor/test_codegen_triton": 0.221, "inductor/test_compile_worker": 5.032, "inductor/test_compiled_autograd": 358.71000000000083, "inductor/test_compiled_optimizers": 2000.6639999999989, "inductor/test_config": 5.304000000000001, "inductor/test_control_flow": 120.38400000000001, "inductor/test_coordinate_descent_tuner": 3.251, "inductor/test_cpu_repro": 635.4659999999997, "inductor/test_cuda_cpp_wrapper": 1963.8190000000002, "inductor/test_cuda_repro": 77.79999999999997, "inductor/test_cudagraph_trees": 65.123, "inductor/test_custom_lowering": 3.5650000000000004, "inductor/test_custom_post_grad_passes": 10.206, "inductor/test_cutlass_backend": 126.67000000000004, "inductor/test_debug_trace": 13.341, "inductor/test_decompose_mem_bound_mm": 33.389, "inductor/test_dependencies": 0.198, "inductor/test_distributed_patterns": 33.824, "inductor/test_efficient_conv_bn_eval": 299.106, "inductor/test_extension_backend": 16.527, "inductor/test_flex_attention": 407.30299999999994, "inductor/test_foreach": 296.274, "inductor/test_fp8": 0.008, "inductor/test_fused_attention": 217.02099999999996, "inductor/test_fx_fusion": 0.18, "inductor/test_group_batch_fusion": 107.382, "inductor/test_indexing": 0.5630000000000001, "inductor/test_inductor_freezing": 80.576, "inductor/test_inplacing_pass": 6.992, "inductor/test_kernel_benchmark": 124.23999999999998, "inductor/test_layout_optim": 13.485999999999999, "inductor/test_max_autotune": 240.877, "inductor/test_memory_planning": 29.128, "inductor/test_metrics": 3.795000000000001, "inductor/test_minifier": 28.292999999999996, "inductor/test_minifier_isolate": 90.013, "inductor/test_mkldnn_pattern_matcher": 479.5799999999999, "inductor/test_mmdecomp": 9.004999999999999, "inductor/test_move_constructors_to_cuda": 14.876999999999999, "inductor/test_multi_kernel": 72.425, "inductor/test_pad_mm": 125.57700000000001, "inductor/test_padding": 18.813999999999997, "inductor/test_pattern_matcher": 91.27699999999999, "inductor/test_perf": 66.4, "inductor/test_profiler": 7.897, "inductor/test_select_algorithm": 114.39500000000001, "inductor/test_smoke": 6.198, "inductor/test_snode_runtime": 13.541, "inductor/test_split_cat_fx_passes": 98.37, "inductor/test_standalone_compile": 18.042, "inductor/test_torchbind": 6.15, "inductor/test_torchinductor": 17.671000000000003, "inductor/test_torchinductor_codegen_dynamic_shapes": 15.599, "inductor/test_torchinductor_dynamic_shapes": 9.139999999999999, "nn/test_convolution": 70.99799999999945, "nn/test_pooling": 5.857999999999997, "profiler/test_profiler": 0.7050000000000001, "test_autocast": 2.131, "test_autograd_fallback": 0.7270000000000001, "test_cpp_api_parity": 8.567999999999994, "test_cpp_extensions_aot_ninja": 0.7410000000000001, "test_cpp_extensions_aot_no_ninja": 0.7080000000000001, "test_cpp_extensions_jit": 164.07500000000002, "test_cpp_extensions_mtia_backend": 0.421, "test_cpp_extensions_open_device_registration": 6.468000000000001, "test_cpp_extensions_stream_and_event": 0.421, "test_cuda": 14.454, "test_cuda_expandable_segments": 16.115, "test_cuda_multigpu": 0.854, "test_cuda_nvml_based_avail": 4.026, "test_cuda_primary_ctx": 1.259, "test_cuda_trace": 6.718000000000002, "test_dispatch": 32.80600000000002, "test_fake_tensor": 16.59900000000001, "test_fx": 217.81900000000007, "test_indexing": 0.563, "test_jit_disabled": 0.7160000000000001, "test_linalg": 13.406, "test_mobile_optimizer": 2.5109999999999997, "test_multiprocessing": 85.852, "test_multiprocessing_spawn": 19.428999999999995, "test_namedtuple_return_api": 1.964, "test_native_mha": 1.0340000000000003, "test_nn": 165.79300000000435, "test_overrides": 2.300999999999891, "test_python_dispatch": 1.6799999999999995, "test_reductions": 131.85900000000242, "test_serialization": 5.829, "test_show_pickle": 0.636, "test_sort_and_select": 4.091999999999995, "test_spectral_ops": 18.36799999999996, "test_tensor_creation_ops": 81.62800000000033, "test_tensorexpr": 113.64400000000002, "test_torch": 86.93000000000002, "test_utils": 25.78200000000058}, "dynamo_eager_timm": {"distributions/test_distributions": 354.061, "functorch/test_memory_efficient_fusion": 9.521, "nn/test_convolution": 20.348, "profiler/test_profiler": 15.439, "test_cuda": 14.914}, "dynamo_eager_torchbench": {"distributions/test_distributions": 357.45799999999997, "functorch/test_memory_efficient_fusion": 9.577, "nn/test_convolution": 20.889, "profiler/test_profiler": 15.479999999999999, "test_cuda": 14.826000000000004}}, "cuda12.1-py3.12-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 3.318, "distributed/_composable/fsdp/test_fully_shard_comm": 108.048, "distributed/_composable/fsdp/test_fully_shard_frozen": 9.945, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 6.665, "distributed/_composable/fsdp/test_fully_shard_training": 19.901, "distributed/_tensor/test_dtensor_compile": 21.519000000000002, "distributed/fsdp/test_fsdp_tp_integration": 9.83, "distributed/tensor/parallel/test_fsdp_2d_parallel": 32.798, "distributed/test_c10d_functional_native": 146.336, "distributed/test_dynamo_distributed": 110.215, "distributed/test_inductor_collectives": 51.342999999999996, "inductor/test_aot_inductor": 6080.618999999999, "inductor/test_torchinductor": 2183.277000000002, "inductor/test_torchinductor_opinfo": 7722.074999999983, "test_modules": 552.0919999999862, "test_ops": 2155.594000000085, "test_ops_gradients": 1386.1619999999973, "test_torch": 3578.6434999999997}}, "cuda12.4-py3.10-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 3.5115, "distributed/_composable/fsdp/test_fully_shard_comm": 104.086, "distributed/_composable/fsdp/test_fully_shard_frozen": 10.143, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 7.051, "distributed/_composable/fsdp/test_fully_shard_training": 28.484, "distributed/_tensor/test_dtensor_compile": 24.93, "distributed/fsdp/test_fsdp_tp_integration": 10.078, "distributed/tensor/parallel/test_fsdp_2d_parallel": 33.86200000000001, "distributed/test_c10d_functional_native": 149.9035, "distributed/test_dynamo_distributed": 119.4345, "distributed/test_inductor_collectives": 53.874, "inductor/test_aot_inductor": 6161.589999999999, "inductor/test_torchinductor": 2125.5285000000003, "inductor/test_torchinductor_opinfo": 1590.3884999999982, "test_modules": 546.2239999999865, "test_ops": 2127.9214999999067, "test_ops_gradients": 1327.7069999999333, "test_torch": 1609.8649999999984}, "inductor_cpp_wrapper_abi_compatible": {"inductor/test_cuda_cpp_wrapper": 869.586}, "inductor_distributed": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 10.621, "distributed/_composable/fsdp/test_fully_shard_comm": 119.934, "distributed/_composable/fsdp/test_fully_shard_frozen": 25.637, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 17.3695, "distributed/_composable/fsdp/test_fully_shard_training": 202.78750000000002, "distributed/_tensor/test_dtensor_compile": 38.253, "distributed/fsdp/test_fsdp_tp_integration": 24.7505, "distributed/tensor/parallel/test_fsdp_2d_parallel": 65.602, "distributed/test_c10d_functional_native": 162.3575, "distributed/test_dynamo_distributed": 234.08349999999996, "distributed/test_inductor_collectives": 88.0325, "inductor/test_aot_inductor": 50.0555, "inductor/test_torchinductor": 4.121}}, "cuda12.4-py3.12-gcc9-sm86": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 3.266, "distributed/_composable/fsdp/test_fully_shard_comm": 101.1405, "distributed/_composable/fsdp/test_fully_shard_frozen": 9.64, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 6.4625, "distributed/_composable/fsdp/test_fully_shard_training": 26.1075, "distributed/_tensor/test_dtensor_compile": 23.436500000000002, "distributed/fsdp/test_fsdp_tp_integration": 9.7, "distributed/tensor/parallel/test_fsdp_2d_parallel": 32.4915, "distributed/test_c10d_functional_native": 147.6785, "distributed/test_dynamo_distributed": 113.358, "distributed/test_inductor_collectives": 51.2975, "inductor/test_aot_inductor": 6135.287499999998, "inductor/test_torchinductor": 2091.18, "inductor/test_torchinductor_opinfo": 1555.4389999999933, "test_modules": 540.7639999999853, "test_ops": 2130.7499999999636, "test_ops_gradients": 1323.751499999988, "test_torch": 1817.5060000000028}}, "default": {"crossref": {"backends/xeon/test_launch": 1.9676666666666665, "benchmark_utils/test_benchmark_utils": 1.733333333333333, "distributions/test_constraints": 0.08583333333333339, "distributions/test_distributions": 53.52616666666667, "export/test_converter": 8.1075, "export/test_db": 3.192333333333333, "export/test_export": 34.956833333333336, "export/test_functionalized_assertions": 0.17566666666666667, "export/test_hop": 2.974666666666667, "export/test_lift_unlift": 0.13783333333333334, "export/test_pass_infra": 0.8623333333333334, "export/test_passes": 13.891000000000002, "export/test_schema": 0.2506666666666667, "export/test_serialize": 9.125166666666665, "export/test_sparse": 89.91583333333332, "export/test_tools": 0.42666666666666664, "export/test_torchbind": 3.6079999999999997, "export/test_tree_utils": 0.165, "export/test_unflatten": 3.3728333333333333, "export/test_verifier": 0.945, "functorch/test_aotdispatch": 3434.334499999999, "functorch/test_control_flow": 124.72016666666664, "functorch/test_dims": 30.77916666666667, "functorch/test_eager_transforms": 18.90533333333333, "functorch/test_logging": 0.18233333333333332, "functorch/test_memory_efficient_fusion": 0.5061666666666667, "functorch/test_minifier": 0.3526666666666667, "functorch/test_ops": 3686.686999999978, "functorch/test_parsing": 0.18533333333333335, "functorch/test_rearrange": 0.22183333333333338, "functorch/test_vmap": 668.422166666666, "functorch/test_vmap_registrations": 3.1619999999998756, "higher_order_ops/test_with_effects": 10.2165, "inductor/test_mmdecomp": 0.025833333333333344, "lazy/test_debug_util": 0.19783333333333333, "lazy/test_functionalization": 0.19483333333333336, "lazy/test_generator": 0.21016666666666667, "lazy/test_reuse_ir": 0.45466666666666666, "lazy/test_step_closures": 2.1413333333333333, "lazy/test_ts_opinfo": 10.163833333333315, "nn/test_convolution": 20.02549999999995, "nn/test_dropout": 0.5085, "nn/test_embedding": 10.07983333333334, "nn/test_init": 3.9334999999999996, "nn/test_lazy_modules": 0.5703333333333336, "nn/test_load_state_dict": 1.034333333333333, "nn/test_module_hooks": 0.28800000000000003, "nn/test_multihead_attention": 7.621333333333332, "nn/test_packed_sequence": 0.43200000000000005, "nn/test_parametrization": 1.4149999999999991, "nn/test_pooling": 31.088166666666666, "nn/test_pruning": 0.12216666666666674, "profiler/test_execution_trace": 0.12966666666666668, "profiler/test_memory_profiler": 5.431333333333333, "profiler/test_profiler": 22.597833333333334, "profiler/test_profiler_tree": 0.20600000000000004, "profiler/test_record_function": 0.24400000000000002, "profiler/test_torch_tidy": 4.244166666666667, "test_ao_sparsity": 10.681833333333334, "test_autocast": 0.7175, "test_autograd": 30.543833333333325, "test_autograd_fallback": 0.24183333333333337, "test_binary_ufuncs": 148.29033333333186, "test_bundled_inputs": 1.0935, "test_comparison_utils": 0.20700000000000002, "test_compile_benchmark_util": 0.0006666666666666666, "test_complex": 0.060833333333333336, "test_content_store": 7.3678333333333335, "test_cpp_api_parity": 3.572999999999988, "test_cpp_extensions_aot_ninja": 0.04550000000000001, "test_cpp_extensions_aot_no_ninja": 0.045500000000000006, "test_cpp_extensions_jit": 28.487000000000005, "test_cpp_extensions_mtia_backend": 0.5946666666666666, "test_cpp_extensions_open_device_registration": 8.3885, "test_cpp_extensions_stream_and_event": 0.6031666666666666, "test_custom_backend": 0.07299999999999998, "test_custom_ops": 10.16333333333333, "test_dataloader": 131.60216666666668, "test_datapipe": 12.971999999999998, "test_decomp": 252.50850000000037, "test_deploy": 0.15533333333333332, "test_dispatch": 24.772, "test_dlpack": 0.23350000000000015, "test_dynamic_shapes": 4.737999999999996, "test_expanded_weights": 9.412166666666666, "test_fake_tensor": 1.778166666666667, "test_flop_counter": 0.6186666666666667, "test_foreach": 73.92933333333349, "test_function_schema": 0.5141666666666667, "test_functional_autograd_benchmark": 38.052, "test_functional_optim": 0.37616666666666665, "test_functionalization": 5.240999999999998, "test_functionalization_of_rng_ops": 0.024333333333333332, "test_futures": 0.8051666666666667, "test_fx": 228.9076666666666, "test_fx_experimental": 73.36716666666669, "test_fx_passes": 0.6558333333333335, "test_fx_reinplace_pass": 0.40100000000000013, "test_import_stats": 3.373333333333334, "test_indexing": 2.0541666666666645, "test_itt": 0.17066666666666666, "test_jit": 119.27616666666674, "test_jit_autocast": 17.783166666666666, "test_jit_disabled": 0.25866666666666666, "test_jit_fuser_te": 235.4730000000004, "test_jit_llga_fuser": 50.74066666666667, "test_legacy_vmap": 2.264166666666666, "test_license": 0.155, "test_linalg": 161.29766666666688, "test_logging": 2.6660000000000004, "test_masked": 21.490999999999985, "test_maskedtensor": 7.639166666666614, "test_meta": 146.3114999999626, "test_mkl_verbose": 4.179666666666667, "test_mkldnn": 117.26149999999997, "test_mkldnn_fusion": 60.719333333333324, "test_mkldnn_verbose": 3.713, "test_mobile_optimizer": 2.766166666666667, "test_model_dump": 1.2368333333333332, "test_model_exports_to_core_aten": 0.10283333333333335, "test_module_tracker": 0.17766666666666667, "test_modules": 593.8869999999872, "test_monitor": 0.6493333333333333, "test_multiprocessing": 45.22333333333334, "test_multiprocessing_spawn": 25.2805, "test_namedtensor": 0.44633333333333347, "test_namedtuple_return_api": 1.4636666666666667, "test_native_functions": 0.2841666666666667, "test_native_mha": 0.21366666666666675, "test_nestedtensor": 21.789666666666683, "test_nn": 148.9025000000003, "test_numba_integration": 0.005166666666666667, "test_numpy_interop": 0.24716666666666676, "test_openmp": 7.492166666666666, "test_ops": 2700.5093333333084, "test_ops_fwd_gradients": 757.5736666666585, "test_ops_gradients": 1265.4273333333053, "test_ops_jit": 1062.2226666666643, "test_optim": 52.40116666666674, "test_out_dtype_op": 0.3701666666666667, "test_overrides": 1.7619999999999352, "test_package": 2.789333333333333, "test_per_overload_api": 0.15966666666666665, "test_prims": 0.1985, "test_proxy_tensor": 755.9336666666676, "test_pruning_op": 0.47683333333333333, "test_public_bindings": 5.941333333333333, "test_python_dispatch": 0.5855000000000001, "test_pytree": 0.39500000000000013, "test_quantization": 2233.886833333333, "test_reductions": 198.68283333332732, "test_scatter_gather_ops": 6.2251666666666665, "test_schema_check": 199.0764999999969, "test_segment_reductions": 1.488, "test_serialization": 36.00449999999999, "test_set_default_mobile_cpu_allocator": 0.16499999999999998, "test_shape_ops": 1.3356666666666657, "test_show_pickle": 0.1396666666666667, "test_sort_and_select": 2.2238333333333307, "test_sparse": 927.7628333333325, "test_sparse_csr": 211.79366666666664, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 6.4263333333333215, "test_stateless": 5.927999999999999, "test_subclass": 0.3256666666666668, "test_sympy_utils": 15.224499999999997, "test_tensor_creation_ops": 28.53433333333335, "test_tensorboard": 0.20483333333333337, "test_tensorexpr": 46.58049999999999, "test_tensorexpr_pybind": 0.7435, "test_testing": 35.619499999999974, "test_torch": 20.697333333333326, "test_transformers": 309.8716666666659, "test_type_hints": 0.21916666666666668, "test_type_info": 0.20433333333333334, "test_type_promotion": 3.661333333333331, "test_typing": 77.01016666666668, "test_unary_ufuncs": 454.3534999998891, "test_utils": 42.57233333333382, "test_view_ops": 20.487000000000002, "test_vulkan": 0.0008333333333333333, "test_weak": 4.858, "test_xnnpack_integration": 44.83583333333333, "torch_np/numpy_tests/core/test_dlpack": 0.09716666666666673, "torch_np/numpy_tests/core/test_dtype": 0.43733333333333335, "torch_np/numpy_tests/core/test_einsum": 14.984333333333334, "torch_np/numpy_tests/core/test_getlimits": 0.18266666666666667, "torch_np/numpy_tests/core/test_indexing": 0.40066666666666684, "torch_np/numpy_tests/core/test_multiarray": 36.736999999999995, "torch_np/numpy_tests/core/test_numeric": 5.305166666666667, "torch_np/numpy_tests/core/test_numerictypes": 0.2471666666666667, "torch_np/numpy_tests/core/test_scalar_ctors": 0.28316666666666673, "torch_np/numpy_tests/core/test_scalar_methods": 0.19250000000000003, "torch_np/numpy_tests/core/test_scalarinherit": 0.0008333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 25.948999999999998, "torch_np/numpy_tests/core/test_shape_base": 0.6096666666666669, "torch_np/numpy_tests/fft/test_helper": 5.709666666666667, "torch_np/numpy_tests/fft/test_pocketfft": 5.555833333333332, "torch_np/numpy_tests/lib/test_arraypad": 0.2445, "torch_np/numpy_tests/lib/test_arraysetops": 0.4098333333333334, "torch_np/numpy_tests/lib/test_function_base": 2.3260000000000005, "torch_np/numpy_tests/lib/test_histograms": 0.4940000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.2505, "torch_np/numpy_tests/lib/test_shape_base_": 0.6878333333333335, "torch_np/numpy_tests/lib/test_twodim_base": 0.39250000000000007, "torch_np/numpy_tests/lib/test_type_check": 0.3413333333333334, "torch_np/numpy_tests/linalg/test_linalg": 8.419333333333334, "torch_np/test_basic": 0.6303333333333339, "torch_np/test_binary_ufuncs": 0.29233333333333344, "torch_np/test_dtype": 0.1931666666666667, "torch_np/test_function_base": 0.15666666666666668, "torch_np/test_ndarray_methods": 4.221333333333332, "torch_np/test_nep50_examples": 1.8836666666666062, "torch_np/test_random": 0.20316666666666672, "torch_np/test_reductions": 3.131333333333285, "torch_np/test_scalars_0D_arrays": 0.2001666666666667, "torch_np/test_ufuncs_basic": 1.238833333333334, "torch_np/test_unary_ufuncs": 0.30183333333333345}, "default": {"backends/xeon/test_launch": 2.0264038461538467, "benchmark_utils/test_benchmark_utils": 1.650429487179487, "distributed/_composable/fsdp/test_fully_shard_autograd": 33.41277777777778, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 12.93145238095238, "distributed/_composable/fsdp/test_fully_shard_comm": 121.26854761904761, "distributed/_composable/fsdp/test_fully_shard_compile": 13.625444444444446, "distributed/_composable/fsdp/test_fully_shard_extensions": 22.105444444444444, "distributed/_composable/fsdp/test_fully_shard_frozen": 31.934642857142855, "distributed/_composable/fsdp/test_fully_shard_init": 11.625166666666665, "distributed/_composable/fsdp/test_fully_shard_memory": 13.053888888888887, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 36.377071428571426, "distributed/_composable/fsdp/test_fully_shard_overlap": 7.277333333333334, "distributed/_composable/fsdp/test_fully_shard_state": 0.1968888888888889, "distributed/_composable/fsdp/test_fully_shard_state_dict": 26.323444444444444, "distributed/_composable/fsdp/test_fully_shard_training": 170.71347916666667, "distributed/_composable/fully_shard/test_fully_shard_compile": 35.36183333333334, "distributed/_composable/fully_shard/test_fully_shard_init": 33.48494444444444, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 11.491166666666667, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 20.129944444444444, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 23.009666666666664, "distributed/_composable/fully_shard/test_fully_shard_runtime": 23.881888888888884, "distributed/_composable/fully_shard/test_fully_shard_util": 4.630777777777777, "distributed/_composable/test_checkpoint": 6.976499999999999, "distributed/_composable/test_compose": 88.89283333333333, "distributed/_composable/test_contract": 0.29838888888888887, "distributed/_composable/test_replicate": 54.73599999999999, "distributed/_composable/test_replicate_with_compiler": 57.699555555555555, "distributed/_shard/sharded_optim/test_sharded_optim": 3.844666666666667, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": 7.607666666666668, "distributed/_shard/sharded_tensor/ops/test_embedding": 3.8426666666666662, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": 3.8401666666666667, "distributed/_shard/sharded_tensor/ops/test_init": 5.751166666666665, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 14.230166666666667, "distributed/_shard/sharded_tensor/test_logger": 0.28938888888888886, "distributed/_shard/sharded_tensor/test_sharded_tensor": 261.6236666666667, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": 7.0554444444444435, "distributed/_shard/sharding_plan/test_sharding_plan": 10.615222222222222, "distributed/_shard/sharding_spec/test_sharding_spec": 13.809666666666669, "distributed/_shard/test_sharder": 5.797944444444444, "distributed/_tensor/debug/test_comm_mode": 6.5935, "distributed/_tensor/debug/test_op_coverage": 0.45611111111111113, "distributed/_tensor/experimental/test_local_map": 45.07005555555555, "distributed/_tensor/experimental/test_tp_transform": 26.762611111111113, "distributed/_tensor/test_api": 30.975833333333338, "distributed/_tensor/test_attention": 3.317166666666666, "distributed/_tensor/test_common_rules": 38.51533333333333, "distributed/_tensor/test_convolution_ops": 46.972388888888894, "distributed/_tensor/test_dtensor": 130.16088888888888, "distributed/_tensor/test_dtensor_compile": 42.39566666666666, "distributed/_tensor/test_dtensor_ops": 62.59200000000002, "distributed/_tensor/test_embedding_ops": 13.99211111111111, "distributed/_tensor/test_experimental_ops": 13.451666666666666, "distributed/_tensor/test_init": 27.633166666666664, "distributed/_tensor/test_math_ops": 48.515499999999996, "distributed/_tensor/test_matrix_ops": 79.99211111111111, "distributed/_tensor/test_op_strategy": 0.4376111111111112, "distributed/_tensor/test_optimizers": 120.10527777777777, "distributed/_tensor/test_pointwise_ops": 0.6277777777777779, "distributed/_tensor/test_random_ops": 33.70216666666667, "distributed/_tensor/test_redistribute": 44.40350000000001, "distributed/_tensor/test_tensor_ops": 182.90422222222222, "distributed/_tensor/test_utils": 23.87477777777778, "distributed/_tensor/test_view_ops": 27.83388888888889, "distributed/_tensor/test_xla_integration": 0.2886666666666667, "distributed/_tools/test_memory_tracker": 8.913166666666667, "distributed/_tools/test_mod_tracker": 0.29033333333333333, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 29.140777777777775, "distributed/algorithms/quantization/test_quantization": 42.45388888888888, "distributed/algorithms/test_join": 36.794444444444444, "distributed/checkpoint/e2e/test_e2e_save_and_load": 48.64194444444445, "distributed/checkpoint/e2e/test_fine_tuning": 2.9839444444444445, "distributed/checkpoint/e2e/test_fsdp_ep": 2.9725555555555556, "distributed/checkpoint/e2e/test_pipeline": 3.728, "distributed/checkpoint/fsdp/test_fsdp_dsd": 14.539333333333332, "distributed/checkpoint/test_checkpoint": 31.254875, "distributed/checkpoint/test_compatibility": 0.43272222222222223, "distributed/checkpoint/test_dedup_tensors": 0.31450000000000006, "distributed/checkpoint/test_dtensor_checkpoint": 4.835388888888889, "distributed/checkpoint/test_dtensor_resharding": 26.74372222222222, "distributed/checkpoint/test_file_system_checkpoint": 21.4825, "distributed/checkpoint/test_file_system_checkpoint_cpu": 38.30588888888889, "distributed/checkpoint/test_format_utils": 12.461888888888888, "distributed/checkpoint/test_fsdp_model_state": 15.287555555555556, "distributed/checkpoint/test_fsdp_optim_state": 22.751666666666665, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 11.743055555555557, "distributed/checkpoint/test_fsspec": 14.626055555555554, "distributed/checkpoint/test_hsdp_checkpoint": 14.92827777777778, "distributed/checkpoint/test_nested_dict": 0.28994444444444445, "distributed/checkpoint/test_planner": 0.4603333333333334, "distributed/checkpoint/test_save_load_api": 3.8168333333333333, "distributed/checkpoint/test_state_dict": 156.56238888888888, "distributed/checkpoint/test_state_dict_utils": 14.793999999999999, "distributed/checkpoint/test_tp_checkpoint": 16.425, "distributed/checkpoint/test_traverse": 0.2953333333333333, "distributed/checkpoint/test_utils": 0.3013888888888889, "distributed/elastic/events/lib_test": 0.3678333333333334, "distributed/elastic/metrics/api_test": 0.30088888888888893, "distributed/elastic/multiprocessing/api_test": 37.07105555555555, "distributed/elastic/test_control_plane": 4.9078333333333335, "distributed/elastic/timer/local_timer_example": 14.971055555555553, "distributed/elastic/timer/local_timer_test": 5.749444444444445, "distributed/elastic/utils/distributed_test": 2.691444444444444, "distributed/elastic/utils/logging_test": 0.3277222222222222, "distributed/elastic/utils/util_test": 0.3638333333333333, "distributed/fsdp/test_checkpoint_wrapper": 5.281, "distributed/fsdp/test_distributed_checkpoint": 0.30470833333333336, "distributed/fsdp/test_fsdp_apply": 15.121749999999999, "distributed/fsdp/test_fsdp_backward_prefetch": 11.917874999999999, "distributed/fsdp/test_fsdp_checkpoint": 173.22970833333335, "distributed/fsdp/test_fsdp_clip_grad_norm": 55.458375, "distributed/fsdp/test_fsdp_comm": 100.80808333333333, "distributed/fsdp/test_fsdp_comm_hooks": 209.35137500000005, "distributed/fsdp/test_fsdp_core": 1311.574708333333, "distributed/fsdp/test_fsdp_dtensor_state_dict": 148.79108333333335, "distributed/fsdp/test_fsdp_exec_order": 81.06995833333333, "distributed/fsdp/test_fsdp_fine_tune": 46.93870833333334, "distributed/fsdp/test_fsdp_flatten_params": 64.57333333333334, "distributed/fsdp/test_fsdp_freezing_weights": 333.7752916666667, "distributed/fsdp/test_fsdp_fx": 0.32433333333333336, "distributed/fsdp/test_fsdp_grad_acc": 64.846, "distributed/fsdp/test_fsdp_hybrid_shard": 56.932375, "distributed/fsdp/test_fsdp_ignored_modules": 101.27754166666665, "distributed/fsdp/test_fsdp_input": 19.035083333333333, "distributed/fsdp/test_fsdp_memory": 24.812333333333335, "distributed/fsdp/test_fsdp_meta": 68.71883333333335, "distributed/fsdp/test_fsdp_misc": 113.20095833333335, "distributed/fsdp/test_fsdp_mixed_precision": 602.5179166666667, "distributed/fsdp/test_fsdp_multiple_forward": 10.419083333333333, "distributed/fsdp/test_fsdp_multiple_wrapping": 10.312958333333333, "distributed/fsdp/test_fsdp_optim_state": 621.6459166666667, "distributed/fsdp/test_fsdp_overlap": 50.84916666666667, "distributed/fsdp/test_fsdp_pure_fp16": 20.521124999999998, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 195.69804166666668, "distributed/fsdp/test_fsdp_state_dict": 986.6132083333333, "distributed/fsdp/test_fsdp_tp_integration": 22.29254166666667, "distributed/fsdp/test_fsdp_traversal": 4.954083333333333, "distributed/fsdp/test_fsdp_uneven": 10.312999999999999, "distributed/fsdp/test_fsdp_unshard_params": 88.64566666666667, "distributed/fsdp/test_fsdp_use_orig_params": 309.9157083333333, "distributed/fsdp/test_hsdp_dtensor_state_dict": 39.82325, "distributed/fsdp/test_shard_utils": 9.6945, "distributed/fsdp/test_utils": 0.48287499999999994, "distributed/fsdp/test_wrap": 191.60125, "distributed/launcher/test_run": 43.455611111111104, "distributed/nn/jit/test_instantiator": 0.3082777777777778, "distributed/optim/test_zero_redundancy_optimizer": 204.78305555555553, "distributed/pipelining/test_backward": 0.31733333333333336, "distributed/pipelining/test_composability": 32.416000000000004, "distributed/pipelining/test_microbatch": 0.7111666666666666, "distributed/pipelining/test_pipe": 1.2026111111111109, "distributed/pipelining/test_schedule": 27.225833333333327, "distributed/pipelining/test_stage": 23.225583333333333, "distributed/pipelining/test_transformer": 1.0212222222222223, "distributed/pipelining/test_unflatten": 0.9515000000000001, "distributed/rpc/cuda/test_tensorpipe_agent": 610.9160555555555, "distributed/rpc/test_faulty_agent": 246.30000000000004, "distributed/rpc/test_share_memory": 3.7123333333333335, "distributed/rpc/test_tensorpipe_agent": 1606.172666666667, "distributed/tensor/parallel/test_ddp_2d_parallel": 5.087666666666666, "distributed/tensor/parallel/test_fsdp_2d_parallel": 66.19558333333333, "distributed/tensor/parallel/test_micro_pipeline_tp": 11.137500000000001, "distributed/tensor/parallel/test_parallelize_api": 38.60938888888889, "distributed/tensor/parallel/test_tp_examples": 53.93841666666667, "distributed/tensor/parallel/test_tp_random_state": 5.03975, "distributed/tensor/parallel/test_tp_style": 67.87922222222223, "distributed/test_c10d_common": 98.27733333333333, "distributed/test_c10d_functional_native": 131.75790476190477, "distributed/test_c10d_gloo": 636.739625, "distributed/test_c10d_logger": 16.512666666666664, "distributed/test_c10d_nccl": 1292.3803333333333, "distributed/test_c10d_object_collectives": 41.899, "distributed/test_c10d_ops_nccl": 8.399, "distributed/test_c10d_pypg": 351.81766666666664, "distributed/test_c10d_spawn_gloo": 52.028416666666665, "distributed/test_c10d_spawn_nccl": 42.59004166666667, "distributed/test_c10d_spawn_ucc": 7.778166666666667, "distributed/test_c10d_ucc": 257.8016666666667, "distributed/test_compute_comm_reordering": 2.935222222222222, "distributed/test_control_collectives": 0.3472777777777778, "distributed/test_cuda_p2p": 6.934749999999999, "distributed/test_data_parallel": 15.123944444444446, "distributed/test_device_mesh": 168.94758333333334, "distributed/test_distributed_spawn": 5279.935888888899, "distributed/test_dynamo_distributed": 130.24769047619048, "distributed/test_fake_pg": 6.841555555555555, "distributed/test_functional_api": 71.281, "distributed/test_inductor_collectives": 93.86485714285713, "distributed/test_launcher": 1.5170000000000001, "distributed/test_multi_threaded_pg": 0.6487222222222223, "distributed/test_nccl": 0.5566666666666666, "distributed/test_pg_wrapper": 77.54166666666666, "distributed/test_store": 74.971, "distributed/test_symmetric_memory": 0.0006666666666666666, "distributions/test_constraints": 0.1666547619047618, "distributions/test_distributions": 143.52907692307693, "dynamo/test_activation_checkpointing": 3.9584629629629635, "dynamo/test_after_aot": 7.682259259259259, "dynamo/test_aot_autograd": 16.996805555555557, "dynamo/test_aot_autograd_cache": 14.420120370370373, "dynamo/test_autograd_function": 3.9038148148148144, "dynamo/test_backends": 17.847537037037032, "dynamo/test_backward_higher_order_ops": 15.869750000000002, "dynamo/test_base_output": 0.003953703703703705, "dynamo/test_bytecode_utils": 7.829148148148148, "dynamo/test_compile": 8.87336111111111, "dynamo/test_comptime": 0.756101851851852, "dynamo/test_config": 0.695388888888889, "dynamo/test_ctx_manager": 2.8833981481481477, "dynamo/test_cudagraphs": 4.560404761904762, "dynamo/test_debug_utils": 1.1581944444444445, "dynamo/test_decorators": 8.323694444444444, "dynamo/test_deviceguard": 0.023305555555555562, "dynamo/test_dynamic_shapes": 676.8682685185187, "dynamo/test_exc": 2.400555555555556, "dynamo/test_exceptions": 0.6440277777777779, "dynamo/test_export": 20.563972222222223, "dynamo/test_export_mutations": 0.6783703703703705, "dynamo/test_frame_init": 0.2683148148148148, "dynamo/test_functions": 31.29831481481487, "dynamo/test_fx_passes_pre_grad": 1.5337592592592595, "dynamo/test_global": 0.6499722222222223, "dynamo/test_guard_manager": 0.31780555555555556, "dynamo/test_higher_order_ops": 28.252657407407412, "dynamo/test_hooks": 32.61055555555557, "dynamo/test_inline_inbuilt_nn_modules": 130.93542592592604, "dynamo/test_input_attr_tracking": 10.147685185185184, "dynamo/test_interop": 0.7015, "dynamo/test_logging": 23.041064814814817, "dynamo/test_minifier": 3.004222222222223, "dynamo/test_misc": 74.28342592592604, "dynamo/test_model_output": 0.00803703703703704, "dynamo/test_modules": 26.88958333333333, "dynamo/test_nops": 0.3869444444444443, "dynamo/test_optimizers": 0.803675925925926, "dynamo/test_pre_dispatch": 0.5880092592592593, "dynamo/test_profiler": 1.624388888888889, "dynamo/test_python_autograd": 0.8207592592592593, "dynamo/test_recompile_ux": 1.0725000000000002, "dynamo/test_recompiles": 1.06487962962963, "dynamo/test_reorder_logs": 0.6325462962962964, "dynamo/test_repros": 56.90831481481483, "dynamo/test_resume": 0.5256481481481481, "dynamo/test_sdpa": 0.5850185185185186, "dynamo/test_skip_non_tensor": 0.6720740740740742, "dynamo/test_sources": 0.5925462962962963, "dynamo/test_structured_trace": 17.57995370370371, "dynamo/test_subclasses": 19.405749999999998, "dynamo/test_subgraphs": 2.8246111111111096, "dynamo/test_trace_rules": 1.531675925925926, "dynamo/test_unspec": 16.58600925925926, "dynamo/test_verify_correctness": 0.7303888888888888, "dynamo/test_view": 0.7666759259259258, "export/test_converter": 7.849514492753622, "export/test_db": 3.3310507246376817, "export/test_experimental": 1.2302685185185185, "export/test_export": 33.517731884057966, "export/test_export_nonstrict": 33.04324074074074, "export/test_functionalized_assertions": 0.37809420289855067, "export/test_hop": 2.393536231884058, "export/test_lift_unlift": 0.23539130434782607, "export/test_pass_infra": 1.1792753623188406, "export/test_passes": 16.292231884057973, "export/test_retraceability": 55.02753703703703, "export/test_schema": 0.4237173913043478, "export/test_serdes": 38.84162962962964, "export/test_serialize": 10.238195652173912, "export/test_sparse": 85.0647101449275, "export/test_tools": 0.7853623188405798, "export/test_torchbind": 3.923007246376811, "export/test_tree_utils": 0.3665724637681159, "export/test_unflatten": 4.086101449275363, "export/test_verifier": 1.2445942028985508, "functorch/test_ac": 12.085833333333333, "functorch/test_aotdispatch": 1337.0378012820509, "functorch/test_control_flow": 149.26425, "functorch/test_dims": 32.67565972222223, "functorch/test_eager_transforms": 35.53798076923078, "functorch/test_logging": 0.44119871794871796, "functorch/test_memory_efficient_fusion": 4.0614583333333325, "functorch/test_minifier": 0.7323141025641028, "functorch/test_ops": 3606.7123809523723, "functorch/test_parsing": 0.43572916666666656, "functorch/test_rearrange": 0.776652777777778, "functorch/test_vmap": 575.6617820512813, "functorch/test_vmap_registrations": 4.627544871794706, "higher_order_ops/test_with_effects": 7.904121794871794, "inductor/test_aot_inductor": 4864.353104166666, "inductor/test_benchmark_fusion": 30.49606862745098, "inductor/test_binary_folding": 49.54854901960785, "inductor/test_codecache": 69.64498148148148, "inductor/test_codegen_triton": 0.2792314814814815, "inductor/test_compile_worker": 11.937111111111111, "inductor/test_compiled_autograd": 610.0040555555562, "inductor/test_compiled_optimizers": 877.6954722222226, "inductor/test_config": 7.706185185185183, "inductor/test_control_flow": 22.343972222222227, "inductor/test_coordinate_descent_tuner": 3.4170000000000003, "inductor/test_cpu_cpp_wrapper": 2846.60180952381, "inductor/test_cpu_repro": 877.8436470588235, "inductor/test_cpu_select_algorithm": 3806.3494166666665, "inductor/test_cuda_cpp_wrapper": 1624.6897083333333, "inductor/test_cuda_repro": 139.61511111111113, "inductor/test_cudagraph_trees": 81.14294444444444, "inductor/test_custom_lowering": 0.5315370370370371, "inductor/test_custom_post_grad_passes": 14.52320588235294, "inductor/test_cutlass_backend": 82.83066666666667, "inductor/test_debug_trace": 6.902240740740742, "inductor/test_decompose_mem_bound_mm": 7.324694444444442, "inductor/test_dependencies": 0.1935, "inductor/test_distributed_patterns": 48.03400980392157, "inductor/test_efficient_conv_bn_eval": 78.17291176470592, "inductor/test_extension_backend": 25.413196078431373, "inductor/test_flex_attention": 125.13767592592593, "inductor/test_foreach": 75.83787037037045, "inductor/test_fp8": 0.010000000000000002, "inductor/test_fused_attention": 213.21442156862744, "inductor/test_fx_fusion": 0.26066666666666666, "inductor/test_graph_transform_observer": 0.019490196078431374, "inductor/test_group_batch_fusion": 27.754268518518515, "inductor/test_halide": 1.8415, "inductor/test_indexing": 1.0643703703703704, "inductor/test_inductor_freezing": 74.60327450980391, "inductor/test_inplacing_pass": 5.649333333333334, "inductor/test_kernel_benchmark": 195.26311111111113, "inductor/test_layout_optim": 15.802777777777777, "inductor/test_loop_ordering": 9.034611111111111, "inductor/test_max_autotune": 297.7432222222222, "inductor/test_memory_planning": 30.02355555555555, "inductor/test_metrics": 3.9586666666666672, "inductor/test_minifier": 32.57388541666668, "inductor/test_minifier_isolate": 70.84967857142856, "inductor/test_mkldnn_pattern_matcher": 847.4455294117647, "inductor/test_mmdecomp": 5.653333333333337, "inductor/test_move_constructors_to_cuda": 14.044333333333334, "inductor/test_multi_kernel": 82.72833333333334, "inductor/test_pad_mm": 139.20988888888886, "inductor/test_padding": 22.814888888888888, "inductor/test_pattern_matcher": 105.98333333333333, "inductor/test_perf": 84.07622222222223, "inductor/test_profiler": 6.621555555555555, "inductor/test_select_algorithm": 119.06477777777779, "inductor/test_snode_runtime": 14.782333333333334, "inductor/test_split_cat_fx_passes": 100.75111111111111, "inductor/test_standalone_compile": 22.586814814814815, "inductor/test_torchbind": 10.770675925925921, "inductor/test_torchinductor": 2196.2889090909084, "inductor/test_torchinductor_codegen_dynamic_shapes": 2116.678935185184, "inductor/test_torchinductor_dynamic_shapes": 2299.6757549019603, "inductor/test_torchinductor_opinfo": 12432.592421568637, "inductor/test_torchinductor_strided_blocks": 18.653000000000002, "inductor/test_triton_extension_backend": 1.1911960784313729, "inductor/test_triton_heuristics": 23.89633333333333, "inductor/test_triton_kernels": 18.991583333333335, "inductor/test_triton_wrapper": 9.376444444444445, "inductor/test_unbacked_symints": 24.20477777777778, "inductor/test_utils": 0.2687777777777778, "lazy/test_debug_util": 0.33257051282051286, "lazy/test_functionalization": 0.4865705128205128, "lazy/test_generator": 0.48208333333333336, "lazy/test_reuse_ir": 0.659525641025641, "lazy/test_step_closures": 2.756134615384615, "lazy/test_ts_opinfo": 4.78764102564102, "nn/test_convolution": 68.16264743589741, "nn/test_dropout": 1.3449358974358971, "nn/test_embedding": 34.9656987179487, "nn/test_init": 30.246070512820513, "nn/test_lazy_modules": 2.1443974358974356, "nn/test_load_state_dict": 1.2810833333333334, "nn/test_module_hooks": 2.259666666666667, "nn/test_multihead_attention": 24.733358974358982, "nn/test_packed_sequence": 1.3024423076923077, "nn/test_parametrization": 4.460102564102564, "nn/test_pooling": 24.513852564102557, "nn/test_pruning": 0.9004679487179483, "onnx/dynamo/test_dynamo_with_onnxruntime_backend": 30.188000000000006, "onnx/dynamo/test_exporter_api": 158.60166666666666, "onnx/dynamo/test_registry_dispatcher": 0.12166666666666669, "onnx/internal/test_beartype": 0.06433333333333334, "onnx/internal/test_diagnostics": 0.18533333333333335, "onnx/internal/test_registraion": 0.10800000000000004, "onnx/test_autograd_funs": 0.09333333333333334, "onnx/test_custom_ops": 0.12566666666666668, "onnx/test_export_modes": 0.12333333333333335, "onnx/test_fx_op_consistency": 8982.724999999993, "onnx/test_fx_passes": 2.236666666666667, "onnx/test_fx_to_onnx": 50.69466666666667, "onnx/test_fx_to_onnx_decomp_skip": 3.1043333333333334, "onnx/test_fx_to_onnx_with_onnxruntime": 772.2583333333333, "onnx/test_fx_type_promotion": 0.05533333333333334, "onnx/test_models_onnxruntime": 333.81700000000006, "onnx/test_onnx_opset": 0.779, "onnx/test_onnxscript_runtime": 0.09000000000000001, "onnx/test_op_consistency": 74.06133333333332, "onnx/test_operators": 3.262666666666662, "onnx/test_pytorch_jit_onnx": 0.1206666666666667, "onnx/test_pytorch_onnx_no_runtime": 1.182333333333333, "onnx/test_pytorch_onnx_onnxruntime": 1761.1743333333316, "onnx/test_pytorch_onnx_shape_inference": 0.2866666666666667, "onnx/test_symbolic_helper": 0.08333333333333333, "onnx/test_utility_funs": 13.836, "onnx/test_verification": 0.5626666666666666, "onnx/torch_export/test_torch_export_with_onnxruntime": 3.031333333333334, "profiler/test_execution_trace": 1.1824935897435898, "profiler/test_memory_profiler": 5.5639102564102565, "profiler/test_profiler": 34.25280128205128, "profiler/test_profiler_tree": 4.040743589743591, "profiler/test_record_function": 0.5024807692307692, "profiler/test_torch_tidy": 4.94950641025641, "test_ao_sparsity": 20.507935897435896, "test_autocast": 3.7270128205128192, "test_autograd": 54.28626282051284, "test_autograd_fallback": 0.6000256410256412, "test_binary_ufuncs": 233.47634285714162, "test_bundled_inputs": 1.797480769230769, "test_comparison_utils": 0.4069294871794872, "test_compile_benchmark_util": 0.0008269230769230771, "test_complex": 0.34245238095238095, "test_content_store": 4.635833333333333, "test_cpp_api_parity": 21.871206666666634, "test_cpp_extensions_aot_ninja": 0.36387179487179494, "test_cpp_extensions_aot_no_ninja": 0.35970512820512823, "test_cpp_extensions_jit": 112.31814102564104, "test_cpp_extensions_mtia_backend": 0.5156410256410257, "test_cpp_extensions_open_device_registration": 11.452352564102565, "test_cpp_extensions_stream_and_event": 0.5182051282051282, "test_cuda": 129.18372916666672, "test_cuda_expandable_segments": 148.48889583333332, "test_cuda_multigpu": 1.8183333333333327, "test_cuda_nvml_based_avail": 0.2793333333333333, "test_cuda_primary_ctx": 0.16933333333333334, "test_cuda_sanitizer": 0.7215208333333334, "test_cuda_trace": 3.0655416666666664, "test_custom_backend": 0.12878787878787878, "test_custom_ops": 16.588769230769234, "test_dataloader": 311.1027371794872, "test_datapipe": 15.275378205128204, "test_decomp": 5363.126006410258, "test_deploy": 0.41510897435897437, "test_dispatch": 43.28533333333333, "test_dlpack": 1.5400634920634917, "test_dynamic_shapes": 5.755782051282044, "test_expanded_weights": 19.888428571428573, "test_fake_tensor": 11.960141025641029, "test_flop_counter": 1.3397051282051278, "test_foreach": 151.40812878788185, "test_function_schema": 0.8325448717948718, "test_functional_autograd_benchmark": 35.15772435897436, "test_functional_optim": 0.6265961538461539, "test_functionalization": 5.739499999999998, "test_functionalization_of_rng_ops": 1.2398947368421052, "test_futures": 1.3745961538461537, "test_fx": 271.10505769230764, "test_fx_experimental": 83.5885192307692, "test_fx_passes": 1.7130448717948719, "test_fx_reinplace_pass": 0.7816538461538461, "test_import_stats": 4.591839743589744, "test_indexing": 14.397253968253969, "test_itt": 0.38069230769230783, "test_jit": 171.56768589743595, "test_jit_autocast": 24.735230769230768, "test_jit_disabled": 0.46371794871794864, "test_jit_fuser_legacy": 0.007541666666666667, "test_jit_fuser_te": 502.5448205128211, "test_jit_legacy": 156.2709166666667, "test_jit_llga_fuser": 27.746589743589745, "test_jiterator": 27.43806249999995, "test_legacy_vmap": 26.296153846153857, "test_license": 0.25544871794871793, "test_linalg": 598.1417142857133, "test_logging": 3.223083333333334, "test_masked": 29.237507936507946, "test_maskedtensor": 11.670871794871765, "test_matmul_cuda": 74.86960416666666, "test_meta": 1322.5010705127556, "test_metal": 1.1053333333333333, "test_mkl_verbose": 5.103474358974359, "test_mkldnn": 120.2768205128205, "test_mkldnn_fusion": 140.11917948717948, "test_mkldnn_verbose": 4.7358076923076915, "test_mobile_optimizer": 3.414371794871795, "test_model_dump": 1.398858974358974, "test_model_exports_to_core_aten": 0.1952564102564103, "test_module_tracker": 0.4170192307692308, "test_modules": 812.3954133333267, "test_monitor": 0.6701410256410257, "test_mps": 2175.6303333333276, "test_multiprocessing": 167.23316025641026, "test_multiprocessing_spawn": 33.98603205128205, "test_namedtensor": 1.5637051282051277, "test_namedtuple_return_api": 2.0914615384615383, "test_native_functions": 0.6123076923076924, "test_native_mha": 4.133126984126984, "test_nestedtensor": 18.193301282051284, "test_nn": 240.88267564102608, "test_numba_integration": 0.18616666666666662, "test_numpy_interop": 1.4535079365079366, "test_openmp": 5.860102564102563, "test_ops": 3066.1972126436344, "test_ops_fwd_gradients": 916.2197936507897, "test_ops_gradients": 1492.8383680555307, "test_ops_jit": 1224.3820714285703, "test_optim": 174.5229999999999, "test_out_dtype_op": 0.588852564102564, "test_overrides": 31.755262820512876, "test_package": 18.834660256410253, "test_per_overload_api": 0.4735769230769231, "test_prims": 0.5025128205128206, "test_proxy_tensor": 304.8435705128196, "test_pruning_op": 0.6129038461538463, "test_public_bindings": 5.343858974358975, "test_python_dispatch": 3.025839743589743, "test_pytree": 1.534653846153846, "test_quantization": 2624.9969423076927, "test_reductions": 220.1963253968245, "test_scatter_gather_ops": 31.387404761904754, "test_schema_check": 209.52447435897105, "test_segment_reductions": 5.895277777777777, "test_serialization": 52.837820512820514, "test_set_default_mobile_cpu_allocator": 0.38826282051282046, "test_shape_ops": 4.845031746031746, "test_show_pickle": 0.2682692307692308, "test_sort_and_select": 9.244626984126977, "test_sparse": 654.0138012820508, "test_sparse_csr": 343.79502564102546, "test_sparse_semi_structured": 2.4390705128205123, "test_spectral_ops": 28.899809523809534, "test_stateless": 8.287217948717949, "test_subclass": 0.9680384615384612, "test_sympy_utils": 20.82968589743589, "test_tensor_creation_ops": 84.023619047619, "test_tensorboard": 36.86485256410258, "test_tensorexpr": 76.75428205128205, "test_tensorexpr_pybind": 1.2382371794871796, "test_testing": 44.7857692307692, "test_torch": 341.80017816091936, "test_transformers": 520.5455793650185, "test_type_hints": 0.2563461538461539, "test_type_info": 0.4482884615384616, "test_type_promotion": 14.383563492063496, "test_typing": 72.59346153846153, "test_unary_ufuncs": 513.5732619046792, "test_utils": 49.899461538462, "test_view_ops": 24.395523809523805, "test_vulkan": 0.0012115384615384618, "test_weak": 5.092621794871794, "test_xnnpack_integration": 52.23732051282052, "torch_np/numpy_tests/core/test_dlpack": 0.08976923076923082, "torch_np/numpy_tests/core/test_dtype": 0.6541858974358974, "torch_np/numpy_tests/core/test_einsum": 18.453544871794872, "torch_np/numpy_tests/core/test_getlimits": 0.4269487179487178, "torch_np/numpy_tests/core/test_indexing": 0.9285192307692307, "torch_np/numpy_tests/core/test_multiarray": 37.328187500000006, "torch_np/numpy_tests/core/test_numeric": 8.64678846153846, "torch_np/numpy_tests/core/test_numerictypes": 0.4953525641025641, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6804871794871795, "torch_np/numpy_tests/core/test_scalar_methods": 0.12857051282051277, "torch_np/numpy_tests/core/test_scalarinherit": 0.0009935897435897436, "torch_np/numpy_tests/core/test_scalarmath": 26.86311538461538, "torch_np/numpy_tests/core/test_shape_base": 1.218224358974359, "torch_np/numpy_tests/fft/test_helper": 6.463801282051282, "torch_np/numpy_tests/fft/test_pocketfft": 13.497525641025645, "torch_np/numpy_tests/lib/test_arraypad": 0.4738205128205128, "torch_np/numpy_tests/lib/test_arraysetops": 0.9522692307692308, "torch_np/numpy_tests/lib/test_function_base": 6.509230769230769, "torch_np/numpy_tests/lib/test_histograms": 1.4514102564102562, "torch_np/numpy_tests/lib/test_index_tricks": 0.6811089743589744, "torch_np/numpy_tests/lib/test_shape_base_": 1.3006730769230768, "torch_np/numpy_tests/lib/test_twodim_base": 0.9263397435897436, "torch_np/numpy_tests/lib/test_type_check": 0.8469935897435898, "torch_np/numpy_tests/linalg/test_linalg": 9.332769230769232, "torch_np/test_basic": 2.6604807692307677, "torch_np/test_binary_ufuncs": 0.6515769230769227, "torch_np/test_dtype": 0.5296089743589744, "torch_np/test_function_base": 0.40403205128205133, "torch_np/test_ndarray_methods": 5.392647435897436, "torch_np/test_nep50_examples": 2.4421346153845893, "torch_np/test_random": 0.5658205128205129, "torch_np/test_reductions": 4.43687179487175, "torch_np/test_scalars_0D_arrays": 0.5409551282051281, "torch_np/test_ufuncs_basic": 3.324044871794873, "torch_np/test_unary_ufuncs": 0.6813653846153845}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": 33.41277777777778, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 15.671888888888887, "distributed/_composable/fsdp/test_fully_shard_comm": 105.03844444444444, "distributed/_composable/fsdp/test_fully_shard_compile": 13.625444444444446, "distributed/_composable/fsdp/test_fully_shard_extensions": 22.105444444444444, "distributed/_composable/fsdp/test_fully_shard_frozen": 35.542, "distributed/_composable/fsdp/test_fully_shard_init": 11.625166666666665, "distributed/_composable/fsdp/test_fully_shard_memory": 13.053888888888887, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 58.738, "distributed/_composable/fsdp/test_fully_shard_overlap": 7.277333333333334, "distributed/_composable/fsdp/test_fully_shard_state": 0.1968888888888889, "distributed/_composable/fsdp/test_fully_shard_state_dict": 26.323444444444444, "distributed/_composable/fsdp/test_fully_shard_training": 233.3319444444444, "distributed/_composable/fully_shard/test_fully_shard_compile": 35.36183333333334, "distributed/_composable/fully_shard/test_fully_shard_init": 33.48494444444444, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 11.491166666666667, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 20.129944444444444, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 23.009666666666664, "distributed/_composable/fully_shard/test_fully_shard_runtime": 23.881888888888884, "distributed/_composable/fully_shard/test_fully_shard_util": 4.630777777777777, "distributed/_composable/test_checkpoint": 6.976499999999999, "distributed/_composable/test_compose": 88.89283333333333, "distributed/_composable/test_contract": 0.29838888888888887, "distributed/_composable/test_replicate": 54.73599999999999, "distributed/_composable/test_replicate_with_compiler": 57.699555555555555, "distributed/_shard/sharded_optim/test_sharded_optim": 3.844666666666667, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": 7.607666666666668, "distributed/_shard/sharded_tensor/ops/test_embedding": 3.8426666666666662, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": 3.8401666666666667, "distributed/_shard/sharded_tensor/ops/test_init": 5.751166666666665, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 14.230166666666667, "distributed/_shard/sharded_tensor/test_logger": 0.28938888888888886, "distributed/_shard/sharded_tensor/test_sharded_tensor": 118.86999999999999, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": 3.8626666666666662, "distributed/_shard/sharding_plan/test_sharding_plan": 5.666333333333333, "distributed/_shard/sharding_spec/test_sharding_spec": 10.112055555555557, "distributed/_shard/test_sharder": 5.797944444444444, "distributed/_tensor/debug/test_comm_mode": 6.5935, "distributed/_tensor/debug/test_op_coverage": 0.45611111111111113, "distributed/_tensor/experimental/test_local_map": 45.07005555555555, "distributed/_tensor/experimental/test_tp_transform": 26.762611111111113, "distributed/_tensor/test_api": 30.975833333333338, "distributed/_tensor/test_attention": 3.317166666666666, "distributed/_tensor/test_common_rules": 38.51533333333333, "distributed/_tensor/test_convolution_ops": 46.972388888888894, "distributed/_tensor/test_dtensor": 130.16088888888888, "distributed/_tensor/test_dtensor_compile": 33.715111111111106, "distributed/_tensor/test_dtensor_ops": 62.59200000000002, "distributed/_tensor/test_embedding_ops": 13.99211111111111, "distributed/_tensor/test_experimental_ops": 13.451666666666666, "distributed/_tensor/test_init": 27.633166666666664, "distributed/_tensor/test_math_ops": 48.515499999999996, "distributed/_tensor/test_matrix_ops": 79.99211111111111, "distributed/_tensor/test_op_strategy": 0.4376111111111112, "distributed/_tensor/test_optimizers": 120.10527777777777, "distributed/_tensor/test_pointwise_ops": 0.6277777777777779, "distributed/_tensor/test_random_ops": 29.48238888888889, "distributed/_tensor/test_redistribute": 44.40350000000001, "distributed/_tensor/test_tensor_ops": 182.90422222222222, "distributed/_tensor/test_utils": 23.87477777777778, "distributed/_tensor/test_view_ops": 27.83388888888889, "distributed/_tensor/test_xla_integration": 0.2886666666666667, "distributed/_tools/test_memory_tracker": 8.913166666666667, "distributed/_tools/test_mod_tracker": 0.29033333333333333, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 29.140777777777775, "distributed/algorithms/quantization/test_quantization": 42.45388888888888, "distributed/algorithms/test_join": 36.794444444444444, "distributed/checkpoint/e2e/test_e2e_save_and_load": 48.64194444444445, "distributed/checkpoint/e2e/test_fine_tuning": 2.9839444444444445, "distributed/checkpoint/e2e/test_fsdp_ep": 2.9725555555555556, "distributed/checkpoint/e2e/test_pipeline": 3.728, "distributed/checkpoint/fsdp/test_fsdp_dsd": 14.539333333333332, "distributed/checkpoint/test_checkpoint": 25.91166666666666, "distributed/checkpoint/test_compatibility": 0.43272222222222223, "distributed/checkpoint/test_dedup_tensors": 0.31450000000000006, "distributed/checkpoint/test_dtensor_checkpoint": 4.835388888888889, "distributed/checkpoint/test_dtensor_resharding": 26.74372222222222, "distributed/checkpoint/test_file_system_checkpoint": 18.843666666666667, "distributed/checkpoint/test_file_system_checkpoint_cpu": 38.30588888888889, "distributed/checkpoint/test_format_utils": 12.461888888888888, "distributed/checkpoint/test_fsdp_model_state": 15.287555555555556, "distributed/checkpoint/test_fsdp_optim_state": 22.751666666666665, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 11.743055555555557, "distributed/checkpoint/test_fsspec": 14.626055555555554, "distributed/checkpoint/test_hsdp_checkpoint": 14.92827777777778, "distributed/checkpoint/test_nested_dict": 0.28994444444444445, "distributed/checkpoint/test_planner": 0.4603333333333334, "distributed/checkpoint/test_save_load_api": 3.8168333333333333, "distributed/checkpoint/test_state_dict": 156.56238888888888, "distributed/checkpoint/test_state_dict_utils": 14.793999999999999, "distributed/checkpoint/test_tp_checkpoint": 16.425, "distributed/checkpoint/test_traverse": 0.2953333333333333, "distributed/checkpoint/test_utils": 0.3013888888888889, "distributed/elastic/events/lib_test": 0.3678333333333334, "distributed/elastic/metrics/api_test": 0.30088888888888893, "distributed/elastic/multiprocessing/api_test": 37.07105555555555, "distributed/elastic/test_control_plane": 4.9078333333333335, "distributed/elastic/timer/local_timer_example": 14.971055555555553, "distributed/elastic/timer/local_timer_test": 5.749444444444445, "distributed/elastic/utils/distributed_test": 2.691444444444444, "distributed/elastic/utils/logging_test": 0.3277222222222222, "distributed/elastic/utils/util_test": 0.3638333333333333, "distributed/fsdp/test_checkpoint_wrapper": 6.780666666666666, "distributed/fsdp/test_distributed_checkpoint": 0.28394444444444444, "distributed/fsdp/test_fsdp_apply": 14.011833333333334, "distributed/fsdp/test_fsdp_backward_prefetch": 12.928166666666664, "distributed/fsdp/test_fsdp_checkpoint": 191.84027777777783, "distributed/fsdp/test_fsdp_clip_grad_norm": 59.059, "distributed/fsdp/test_fsdp_comm": 111.81761111111109, "distributed/fsdp/test_fsdp_comm_hooks": 216.2923333333334, "distributed/fsdp/test_fsdp_core": 1251.7152777777776, "distributed/fsdp/test_fsdp_dtensor_state_dict": 163.96994444444445, "distributed/fsdp/test_fsdp_exec_order": 90.0436111111111, "distributed/fsdp/test_fsdp_fine_tune": 51.25994444444444, "distributed/fsdp/test_fsdp_flatten_params": 66.38694444444445, "distributed/fsdp/test_fsdp_freezing_weights": 369.34588888888885, "distributed/fsdp/test_fsdp_fx": 0.3042777777777778, "distributed/fsdp/test_fsdp_grad_acc": 69.72500000000001, "distributed/fsdp/test_fsdp_hybrid_shard": 48.954, "distributed/fsdp/test_fsdp_ignored_modules": 108.97538888888887, "distributed/fsdp/test_fsdp_input": 21.71761111111111, "distributed/fsdp/test_fsdp_memory": 28.62161111111111, "distributed/fsdp/test_fsdp_meta": 75.75077777777778, "distributed/fsdp/test_fsdp_misc": 123.46111111111111, "distributed/fsdp/test_fsdp_mixed_precision": 670.6793888888889, "distributed/fsdp/test_fsdp_multiple_forward": 11.56411111111111, "distributed/fsdp/test_fsdp_multiple_wrapping": 11.373777777777777, "distributed/fsdp/test_fsdp_optim_state": 676.607388888889, "distributed/fsdp/test_fsdp_overlap": 42.42688888888889, "distributed/fsdp/test_fsdp_pure_fp16": 22.66416666666667, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 213.3203888888889, "distributed/fsdp/test_fsdp_state_dict": 966.4012777777779, "distributed/fsdp/test_fsdp_tp_integration": 13.35311111111111, "distributed/fsdp/test_fsdp_traversal": 4.6127777777777785, "distributed/fsdp/test_fsdp_uneven": 11.391166666666665, "distributed/fsdp/test_fsdp_unshard_params": 88.22422222222222, "distributed/fsdp/test_fsdp_use_orig_params": 313.3399444444444, "distributed/fsdp/test_hsdp_dtensor_state_dict": 29.0445, "distributed/fsdp/test_shard_utils": 9.016333333333334, "distributed/fsdp/test_utils": 0.43566666666666665, "distributed/fsdp/test_wrap": 199.984, "distributed/launcher/test_run": 43.455611111111104, "distributed/nn/jit/test_instantiator": 0.3082777777777778, "distributed/optim/test_zero_redundancy_optimizer": 204.78305555555553, "distributed/pipelining/test_backward": 0.31733333333333336, "distributed/pipelining/test_microbatch": 0.7111666666666666, "distributed/pipelining/test_pipe": 1.2026111111111109, "distributed/pipelining/test_schedule": 27.225833333333327, "distributed/pipelining/test_stage": 23.225583333333333, "distributed/pipelining/test_transformer": 1.0212222222222223, "distributed/pipelining/test_unflatten": 0.9515000000000001, "distributed/rpc/cuda/test_tensorpipe_agent": 500.5818333333333, "distributed/rpc/test_faulty_agent": 246.30000000000004, "distributed/rpc/test_share_memory": 3.7123333333333335, "distributed/rpc/test_tensorpipe_agent": 1606.172666666667, "distributed/tensor/parallel/test_ddp_2d_parallel": 3.8578888888888887, "distributed/tensor/parallel/test_fsdp_2d_parallel": 44.235888888888894, "distributed/tensor/parallel/test_micro_pipeline_tp": 11.137500000000001, "distributed/tensor/parallel/test_parallelize_api": 38.60938888888889, "distributed/tensor/parallel/test_tp_examples": 55.794555555555554, "distributed/tensor/parallel/test_tp_random_state": 3.8796666666666666, "distributed/tensor/parallel/test_tp_style": 67.87922222222223, "distributed/test_c10d_common": 93.19654166666666, "distributed/test_c10d_functional_native": 96.36477777777777, "distributed/test_c10d_gloo": 642.9668333333334, "distributed/test_c10d_logger": 16.512666666666664, "distributed/test_c10d_nccl": 1357.041111111111, "distributed/test_c10d_object_collectives": 41.899, "distributed/test_c10d_ops_nccl": 8.399, "distributed/test_c10d_pypg": 351.81766666666664, "distributed/test_c10d_spawn_gloo": 55.66738888888889, "distributed/test_c10d_spawn_nccl": 40.46938888888889, "distributed/test_c10d_spawn_ucc": 7.778166666666667, "distributed/test_c10d_ucc": 257.8016666666667, "distributed/test_compute_comm_reordering": 2.935222222222222, "distributed/test_control_collectives": 0.3472777777777778, "distributed/test_cuda_p2p": 9.246333333333332, "distributed/test_data_parallel": 15.123944444444446, "distributed/test_device_mesh": 156.1362777777778, "distributed/test_distributed_spawn": 5279.935888888899, "distributed/test_dynamo_distributed": 97.23994444444445, "distributed/test_fake_pg": 6.841555555555555, "distributed/test_functional_api": 59.42633333333333, "distributed/test_inductor_collectives": 90.55649999999999, "distributed/test_launcher": 1.5170000000000001, "distributed/test_multi_threaded_pg": 0.6487222222222223, "distributed/test_nccl": 0.5566666666666666, "distributed/test_pg_wrapper": 69.41072222222222, "distributed/test_store": 69.68183333333333, "distributed/test_symmetric_memory": 0.0006666666666666666}, "dynamo": {"backends/xeon/test_launch": 1.9959999999999998, "benchmark_utils/test_benchmark_utils": 2.062, "distributions/test_constraints": 0.08277777777777784, "distributions/test_distributions": 646.3839999999999, "functorch/test_aotdispatch": 95.45999999999997, "functorch/test_control_flow": 395.35566666666665, "functorch/test_dims": 0.0035000000000000005, "functorch/test_eager_transforms": 191.35911111111113, "functorch/test_logging": 0.5722222222222222, "functorch/test_memory_efficient_fusion": 1.9996666666666663, "functorch/test_minifier": 1.5866666666666667, "functorch/test_ops": 38.52222222222576, "functorch/test_parsing": 0.6638333333333334, "functorch/test_rearrange": 4.338166666666667, "functorch/test_vmap": 1329.125, "functorch/test_vmap_registrations": 13.112444444444188, "higher_order_ops/test_with_effects": 7.647333333333333, "lazy/test_debug_util": 0.6444444444444445, "lazy/test_functionalization": 0.7478888888888888, "lazy/test_generator": 0.582, "lazy/test_reuse_ir": 0.7163333333333334, "lazy/test_step_closures": 2.604111111111111, "lazy/test_ts_opinfo": 3.119888888888878, "nn/test_convolution": 198.45722222222207, "nn/test_dropout": 5.701555555555555, "nn/test_embedding": 218.26011111111106, "nn/test_init": 1.660333333333333, "nn/test_lazy_modules": 11.843777777777776, "nn/test_load_state_dict": 3.425777777777777, "nn/test_module_hooks": 16.773666666666667, "nn/test_multihead_attention": 24.878888888888884, "nn/test_packed_sequence": 5.622111111111111, "nn/test_parametrization": 16.30977777777778, "nn/test_pooling": 53.73233333333334, "nn/test_pruning": 6.1258888888888885, "profiler/test_execution_trace": 1.2237777777777776, "profiler/test_memory_profiler": 0.0011111111111111111, "profiler/test_profiler": 62.04055555555555, "profiler/test_profiler_tree": 31.37966666666667, "profiler/test_record_function": 0.7719999999999999, "profiler/test_torch_tidy": 6.342222222222222, "test_ao_sparsity": 72.17077777777779, "test_autocast": 11.163666666666666, "test_autograd": 123.7301111111111, "test_autograd_fallback": 1.9768888888888885, "test_binary_ufuncs": 607.1754444444308, "test_bundled_inputs": 2.324, "test_comparison_utils": 0.5866666666666668, "test_compile_benchmark_util": 0.0004444444444444444, "test_complex": 0.9383333333333334, "test_content_store": 8.138777777777777, "test_cpp_api_parity": 117.13566666666655, "test_cpp_extensions_aot_ninja": 1.3010000000000002, "test_cpp_extensions_aot_no_ninja": 1.3053333333333332, "test_cpp_extensions_jit": 55.28677777777778, "test_cpp_extensions_mtia_backend": 0.8706666666666667, "test_cpp_extensions_open_device_registration": 6.0213333333333345, "test_cpp_extensions_stream_and_event": 0.8623333333333333, "test_custom_ops": 30.529555555555557, "test_dataloader": 253.1262222222222, "test_datapipe": 16.74211111111111, "test_decomp": 15.152000000000015, "test_deploy": 0.458, "test_dispatch": 36.48155555555555, "test_dlpack": 8.086333333333332, "test_dynamic_shapes": 3.288777777777778, "test_expanded_weights": 31.381333333333334, "test_fake_tensor": 6.752888888888889, "test_flop_counter": 0.0021111111111111113, "test_foreach": 30.89688888888919, "test_function_schema": 1.0424444444444445, "test_functional_autograd_benchmark": 34.08866666666666, "test_functional_optim": 1.4342222222222223, "test_functionalization": 0.03377777777777778, "test_functionalization_of_rng_ops": 0.19866666666666666, "test_futures": 3.088777777777777, "test_fx": 219.42899999999995, "test_fx_experimental": 331.86999999999995, "test_fx_passes": 7.698555555555555, "test_fx_reinplace_pass": 2.0864444444444445, "test_import_stats": 3.7464444444444442, "test_indexing": 86.52355555555556, "test_itt": 0.4988888888888889, "test_jit": 312.228888888889, "test_jit_autocast": 0.002777777777777778, "test_jit_disabled": 0.5724444444444444, "test_jit_fuser_te": 335.3612222222244, "test_jit_llga_fuser": 55.76855555555556, "test_legacy_vmap": 133.75988888888892, "test_license": 0.4665555555555556, "test_linalg": 1518.332555555555, "test_logging": 2.4726666666666666, "test_masked": 36.37211111111111, "test_maskedtensor": 44.01166666666666, "test_meta": 72.16611111110944, "test_mkl_verbose": 3.9954444444444444, "test_mkldnn": 128.42744444444443, "test_mkldnn_fusion": 0.0005555555555555556, "test_mkldnn_verbose": 3.8703333333333334, "test_mobile_optimizer": 4.853999999999999, "test_model_dump": 2.851888888888889, "test_model_exports_to_core_aten": 0.3892222222222222, "test_module_tracker": 0.7476666666666666, "test_modules": 32.74133333333372, "test_monitor": 0.5304444444444445, "test_multiprocessing": 25.63177777777778, "test_multiprocessing_spawn": 27.104777777777773, "test_namedtensor": 6.959333333333331, "test_namedtuple_return_api": 2.2025555555555556, "test_native_functions": 1.1541111111111113, "test_native_mha": 20.677, "test_nestedtensor": 66.66333333333334, "test_nn": 649.1091111111114, "test_numba_integration": 0.20666666666666675, "test_numpy_interop": 8.126777777777777, "test_openmp": 7.570555555555555, "test_ops": 52.076000000001535, "test_ops_fwd_gradients": 4.865777777777526, "test_ops_gradients": 8.541444444444373, "test_ops_jit": 1.805666666666639, "test_optim": 364.1464444444444, "test_out_dtype_op": 0.995, "test_overrides": 253.3398888888902, "test_package": 141.15433333333334, "test_per_overload_api": 1.168111111111111, "test_prims": 1.2115555555555557, "test_proxy_tensor": 96.8323333333338, "test_pruning_op": 0.5117777777777778, "test_public_bindings": 1.0725555555555557, "test_python_dispatch": 8.580444444444442, "test_pytree": 8.537333333333331, "test_quantization": 2124.556888888889, "test_reductions": 466.15000000001424, "test_scatter_gather_ops": 131.69255555555551, "test_schema_check": 56.065444444446086, "test_segment_reductions": 25.847222222222225, "test_serialization": 58.748555555555555, "test_set_default_mobile_cpu_allocator": 0.4754444444444445, "test_shape_ops": 14.240222222222222, "test_show_pickle": 0.46288888888888885, "test_sort_and_select": 39.908111111111104, "test_sparse": 907.6268888888885, "test_sparse_csr": 335.2535555555539, "test_sparse_semi_structured": 0.16911111111111113, "test_spectral_ops": 28.069777777777862, "test_stateless": 14.975777777777777, "test_subclass": 3.7504444444444425, "test_sympy_utils": 40.1311111111111, "test_tensor_creation_ops": 192.70433333333335, "test_tensorboard": 35.51644444444445, "test_tensorexpr": 0.002333333333333333, "test_tensorexpr_pybind": 3.5777777777777775, "test_testing": 99.89722222222217, "test_torch": 212.9451111111108, "test_transformers": 812.7186666666663, "test_type_hints": 0.45811111111111114, "test_type_info": 0.8650000000000002, "test_type_promotion": 57.478888888888974, "test_typing": 75.41911111111109, "test_unary_ufuncs": 240.01777777774234, "test_utils": 66.64388888889016, "test_view_ops": 50.14766666666667, "test_vulkan": 0.0007777777777777777, "test_weak": 5.930666666666667, "test_xnnpack_integration": 47.99122222222221, "torch_np/numpy_tests/core/test_dlpack": 0.5784444444444448, "torch_np/numpy_tests/core/test_dtype": 1.266555555555555, "torch_np/numpy_tests/core/test_einsum": 26.489666666666665, "torch_np/numpy_tests/core/test_getlimits": 0.623, "torch_np/numpy_tests/core/test_indexing": 3.231555555555555, "torch_np/numpy_tests/core/test_multiarray": 41.29716666666667, "torch_np/numpy_tests/core/test_numeric": 31.203000000000007, "torch_np/numpy_tests/core/test_numerictypes": 1.0316666666666667, "torch_np/numpy_tests/core/test_scalar_ctors": 1.9656666666666667, "torch_np/numpy_tests/core/test_scalar_methods": 0.5013333333333333, "torch_np/numpy_tests/core/test_scalarinherit": 0.0007777777777777778, "torch_np/numpy_tests/core/test_scalarmath": 6.050111111111111, "torch_np/numpy_tests/core/test_shape_base": 4.838, "torch_np/numpy_tests/fft/test_helper": 1.0636666666666668, "torch_np/numpy_tests/fft/test_pocketfft": 70.24866666666667, "torch_np/numpy_tests/lib/test_arraypad": 0.9414444444444445, "torch_np/numpy_tests/lib/test_arraysetops": 3.834222222222222, "torch_np/numpy_tests/lib/test_function_base": 37.648777777777774, "torch_np/numpy_tests/lib/test_histograms": 6.0648888888888886, "torch_np/numpy_tests/lib/test_index_tricks": 2.0852222222222214, "torch_np/numpy_tests/lib/test_shape_base_": 4.292888888888889, "torch_np/numpy_tests/lib/test_twodim_base": 2.5954444444444444, "torch_np/numpy_tests/lib/test_type_check": 3.2266666666666666, "torch_np/numpy_tests/linalg/test_linalg": 23.17511111111111, "torch_np/test_basic": 10.544222222222205, "torch_np/test_binary_ufuncs": 1.8239999999999992, "torch_np/test_dtype": 1.250333333333333, "torch_np/test_function_base": 0.5347777777777777, "torch_np/test_ndarray_methods": 16.339111111111112, "torch_np/test_nep50_examples": 17.07611111111101, "torch_np/test_random": 1.4233333333333331, "torch_np/test_reductions": 13.196444444444383, "torch_np/test_scalars_0D_arrays": 1.2492222222222225, "torch_np/test_ufuncs_basic": 18.05944444444444, "torch_np/test_unary_ufuncs": 1.9074444444444438}, "force_on_cpu": {"backends/xeon/test_launch": 0.003, "benchmark_utils/test_benchmark_utils": 0.9240000000000002, "distributions/test_distributions": 97.99699999999999, "export/test_converter": 6.628499999999999, "export/test_db": 0.019500000000000007, "export/test_export": 3.031, "export/test_functionalized_assertions": 0.47050000000000003, "export/test_hop": 0.0085, "export/test_lift_unlift": 0.163, "export/test_pass_infra": 1.4255, "export/test_passes": 20.280499999999996, "export/test_schema": 0.552, "export/test_serialize": 2.9475, "export/test_sparse": 115.015, "export/test_tools": 1.3215, "export/test_torchbind": 4.99, "export/test_tree_utils": 0.47750000000000004, "export/test_unflatten": 4.955500000000001, "export/test_verifier": 1.576, "functorch/test_aotdispatch": 47.982, "functorch/test_control_flow": 0.054000000000000034, "functorch/test_dims": 39.937, "functorch/test_eager_transforms": 0.24200000000000005, "functorch/test_logging": 0.542, "functorch/test_memory_efficient_fusion": 1.5364999999999998, "functorch/test_minifier": 0.8300000000000001, "functorch/test_parsing": 0.5465, "functorch/test_rearrange": 0.5815000000000001, "functorch/test_vmap": 5.345499999999992, "functorch/test_vmap_registrations": 6.850999999999748, "higher_order_ops/test_with_effects": 1.2695000000000003, "lazy/test_debug_util": 0.0015, "lazy/test_functionalization": 0.573, "lazy/test_generator": 0.6074999999999999, "lazy/test_reuse_ir": 0.003, "lazy/test_step_closures": 3.4825, "lazy/test_ts_opinfo": 0.652, "nn/test_convolution": 30.475500000000004, "nn/test_dropout": 0.139, "nn/test_embedding": 0.13150000000000006, "nn/test_init": 240.67749999999992, "nn/test_lazy_modules": 0.5900000000000003, "nn/test_load_state_dict": 1.2175000000000002, "nn/test_module_hooks": 0.40750000000000003, "nn/test_multihead_attention": 9.7045, "nn/test_packed_sequence": 0.8315000000000001, "nn/test_parametrization": 1.4895, "nn/test_pooling": 1.1975, "nn/test_pruning": 0.21850000000000008, "profiler/test_execution_trace": 0.41350000000000003, "profiler/test_memory_profiler": 8.167000000000002, "profiler/test_profiler": 31.4925, "profiler/test_profiler_tree": 0.6505000000000001, "profiler/test_record_function": 0.539, "profiler/test_torch_tidy": 5.1754999999999995, "test_ao_sparsity": 13.9255, "test_autocast": 3.2959999999999994, "test_autograd": 65.9525, "test_autograd_fallback": 0.6680000000000001, "test_bundled_inputs": 2.079999999999999, "test_comparison_utils": 0.48350000000000004, "test_compile_benchmark_util": 0.0015, "test_cpp_api_parity": 8.184000000000012, "test_cpp_extensions_aot_ninja": 0.07750000000000001, "test_cpp_extensions_aot_no_ninja": 0.07700000000000001, "test_cpp_extensions_jit": 338.1355, "test_cpp_extensions_mtia_backend": 0.0075, "test_cpp_extensions_open_device_registration": 23.981, "test_cpp_extensions_stream_and_event": 0.0015, "test_custom_backend": 0.15000000000000002, "test_custom_ops": 29.453999999999997, "test_dataloader": 732.5319999999999, "test_datapipe": 17.918499999999998, "test_decomp": 0.314, "test_deploy": 0.4625, "test_dispatch": 79.6875, "test_dynamic_shapes": 11.084999999999992, "test_fake_tensor": 3.7030000000000003, "test_flop_counter": 0.3480000000000001, "test_function_schema": 1.0525, "test_functional_autograd_benchmark": 0.003, "test_functional_optim": 0.6765, "test_functionalization": 7.725999999999999, "test_futures": 1.4480000000000002, "test_fx": 15.730499999999978, "test_fx_experimental": 3.1439999999999992, "test_fx_passes": 1.2350000000000003, "test_fx_reinplace_pass": 0.8065, "test_import_stats": 6.349, "test_itt": 0.477, "test_jit": 156.9160000000001, "test_jit_autocast": 16.252499999999998, "test_jit_disabled": 0.8654999999999999, "test_jit_fuser_te": 486.2980000000001, "test_jit_llga_fuser": 0.053000000000000026, "test_legacy_vmap": 3.6824999999999974, "test_license": 0.003, "test_logging": 3.5700000000000003, "test_maskedtensor": 1.484500000000001, "test_meta": 0.11200000000000004, "test_mkl_verbose": 6.750500000000001, "test_mkldnn_fusion": 294.697, "test_mkldnn_verbose": 6.927, "test_mobile_optimizer": 1.4445, "test_model_dump": 0.7100000000000001, "test_model_exports_to_core_aten": 0.0015, "test_module_tracker": 0.492, "test_monitor": 1.1840000000000002, "test_multiprocessing": 946.8289999999998, "test_multiprocessing_spawn": 47.67550000000001, "test_namedtensor": 0.7150000000000003, "test_namedtuple_return_api": 3.205, "test_native_functions": 0.6880000000000002, "test_nestedtensor": 0.2825000000000002, "test_nn": 79.00550000000004, "test_numba_integration": 0.012, "test_openmp": 6.733499999999999, "test_ops": 0.0075, "test_optim": 2.237999999999998, "test_out_dtype_op": 0.8190000000000001, "test_overrides": 5.136499999999811, "test_package": 1.7100000000000004, "test_per_overload_api": 0.478, "test_prims": 0.024, "test_proxy_tensor": 7.652999999999999, "test_pruning_op": 0.718, "test_public_bindings": 0.489, "test_python_dispatch": 7.803000000000001, "test_pytree": 0.8530000000000002, "test_quantization": 1145.4465000000005, "test_schema_check": 0.27400000000000013, "test_serialization": 75.19749999999999, "test_set_default_mobile_cpu_allocator": 0.46599999999999997, "test_show_pickle": 0.0015, "test_sparse": 6.291500000000001, "test_sparse_csr": 0.8375, "test_sparse_semi_structured": 0.0045000000000000005, "test_stateless": 11.9465, "test_subclass": 0.8105000000000002, "test_sympy_utils": 24.174999999999997, "test_tensorboard": 1.904, "test_tensorexpr": 46.445499999999996, "test_tensorexpr_pybind": 0.524, "test_testing": 9.445999999999998, "test_torch": 6.855999999999981, "test_type_hints": 0.0015, "test_type_info": 0.48450000000000004, "test_typing": 0.008, "test_utils": 74.665, "test_vulkan": 0.0015, "test_weak": 5.885999999999999, "test_xnnpack_integration": 13.2025, "torch_np/numpy_tests/core/test_dlpack": 0.017, "torch_np/numpy_tests/core/test_dtype": 0.7455000000000002, "torch_np/numpy_tests/core/test_einsum": 22.434500000000003, "torch_np/numpy_tests/core/test_getlimits": 0.514, "torch_np/numpy_tests/core/test_indexing": 0.8230000000000002, "torch_np/numpy_tests/core/test_multiarray": 44.8815, "torch_np/numpy_tests/core/test_numeric": 7.895499999999998, "torch_np/numpy_tests/core/test_numerictypes": 0.573, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6665000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.04750000000000001, "torch_np/numpy_tests/core/test_scalarinherit": 0.003, "torch_np/numpy_tests/core/test_scalarmath": 38.07599999999999, "torch_np/numpy_tests/core/test_shape_base": 1.0850000000000004, "torch_np/numpy_tests/fft/test_helper": 8.819999999999999, "torch_np/numpy_tests/fft/test_pocketfft": 6.045999999999999, "torch_np/numpy_tests/lib/test_arraypad": 0.517, "torch_np/numpy_tests/lib/test_arraysetops": 0.7090000000000001, "torch_np/numpy_tests/lib/test_function_base": 3.6784999999999997, "torch_np/numpy_tests/lib/test_histograms": 1.0430000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.649, "torch_np/numpy_tests/lib/test_shape_base_": 1.1685000000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.8570000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.687, "torch_np/numpy_tests/linalg/test_linalg": 13.436500000000002, "torch_np/test_basic": 1.428000000000001, "torch_np/test_binary_ufuncs": 0.6075000000000002, "torch_np/test_dtype": 0.4735000000000001, "torch_np/test_function_base": 0.47250000000000003, "torch_np/test_ndarray_methods": 6.657499999999995, "torch_np/test_nep50_examples": 0.6330000000000005, "torch_np/test_random": 0.6225, "torch_np/test_reductions": 5.0474999999999515, "torch_np/test_scalars_0D_arrays": 0.5805000000000001, "torch_np/test_ufuncs_basic": 2.1770000000000014, "torch_np/test_unary_ufuncs": 0.6730000000000003}, "inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 10.927666666666667, "distributed/_composable/fsdp/test_fully_shard_comm": 134.46283333333335, "distributed/_composable/fsdp/test_fully_shard_frozen": 30.30716666666667, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 20.287166666666668, "distributed/_composable/fsdp/test_fully_shard_training": 155.982, "distributed/_tensor/test_dtensor_compile": 52.461999999999996, "distributed/fsdp/test_fsdp_tp_integration": 25.480833333333333, "distributed/tensor/parallel/test_fsdp_2d_parallel": 77.47200000000002, "distributed/test_c10d_functional_native": 156.1711666666667, "distributed/test_dynamo_distributed": 133.32816666666668, "distributed/test_inductor_collectives": 98.60799999999999, "inductor/test_aot_inductor": 6474.344166666665, "inductor/test_torchinductor": 2967.1668333333328, "inductor/test_torchinductor_opinfo": 16662.409166666712, "test_modules": 1202.723166666666, "test_ops": 2552.169499999795, "test_ops_gradients": 1577.728833333258, "test_torch": 2510.759333333332}, "inductor-halide": {"inductor/test_halide": 1.8415}, "inductor_cpp_wrapper_abi_compatible": {"inductor/test_cpu_cpp_wrapper": 746.8210000000004, "inductor/test_cuda_cpp_wrapper": 885.2804999999998}, "inductor_distributed": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 10.721499999999999, "distributed/_composable/fsdp/test_fully_shard_comm": 130.37599999999998, "distributed/_composable/fsdp/test_fully_shard_frozen": 25.994999999999997, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 17.564, "distributed/_composable/fsdp/test_fully_shard_training": 165.496, "distributed/_tensor/test_dtensor_compile": 32.778, "distributed/fsdp/test_fsdp_tp_integration": 24.756, "distributed/tensor/parallel/test_fsdp_2d_parallel": 66.10549999999999, "distributed/test_c10d_functional_native": 164.6975, "distributed/test_dynamo_distributed": 220.02949999999998, "distributed/test_inductor_collectives": 89.56050000000002, "inductor/test_aot_inductor": 51.736000000000004, "inductor/test_torchinductor": 6.6215}, "jit_legacy": {"test_jit_fuser_legacy": 0.007388888888888889, "test_jit_legacy": 144.67455555555554}, "mps": {"test_metal": 1.1053333333333333, "test_modules": 1139.4930000000015, "test_mps": 2175.6303333333276}, "multigpu": {"distributed/_composable/fsdp/test_fully_shard_training": 32.27, "distributed/_shard/sharded_tensor/test_sharded_tensor": 547.1310000000001, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": 13.440999999999999, "distributed/_shard/sharding_plan/test_sharding_plan": 20.512999999999998, "distributed/_shard/sharding_spec/test_sharding_spec": 24.902500000000003, "distributed/_tensor/test_dtensor_compile": 47.855999999999995, "distributed/_tensor/test_random_ops": 46.36150000000001, "distributed/checkpoint/test_checkpoint": 47.284499999999994, "distributed/checkpoint/test_file_system_checkpoint": 29.399, "distributed/fsdp/test_checkpoint_wrapper": 0.782, "distributed/fsdp/test_distributed_checkpoint": 0.367, "distributed/fsdp/test_fsdp_apply": 18.451499999999996, "distributed/fsdp/test_fsdp_backward_prefetch": 8.887, "distributed/fsdp/test_fsdp_checkpoint": 117.398, "distributed/fsdp/test_fsdp_clip_grad_norm": 44.6565, "distributed/fsdp/test_fsdp_comm": 67.7795, "distributed/fsdp/test_fsdp_comm_hooks": 188.52850000000004, "distributed/fsdp/test_fsdp_core": 1491.1529999999998, "distributed/fsdp/test_fsdp_dtensor_state_dict": 103.25450000000001, "distributed/fsdp/test_fsdp_exec_order": 54.149, "distributed/fsdp/test_fsdp_fine_tune": 33.975, "distributed/fsdp/test_fsdp_flatten_params": 59.13249999999999, "distributed/fsdp/test_fsdp_freezing_weights": 227.06349999999998, "distributed/fsdp/test_fsdp_fx": 0.3845, "distributed/fsdp/test_fsdp_grad_acc": 50.209, "distributed/fsdp/test_fsdp_hybrid_shard": 80.8675, "distributed/fsdp/test_fsdp_ignored_modules": 78.184, "distributed/fsdp/test_fsdp_input": 10.9875, "distributed/fsdp/test_fsdp_memory": 13.384500000000001, "distributed/fsdp/test_fsdp_meta": 47.623000000000005, "distributed/fsdp/test_fsdp_misc": 82.42050000000002, "distributed/fsdp/test_fsdp_mixed_precision": 398.03350000000023, "distributed/fsdp/test_fsdp_multiple_forward": 6.984, "distributed/fsdp/test_fsdp_multiple_wrapping": 7.1305, "distributed/fsdp/test_fsdp_optim_state": 456.76149999999996, "distributed/fsdp/test_fsdp_overlap": 76.116, "distributed/fsdp/test_fsdp_pure_fp16": 14.091999999999999, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 142.83100000000002, "distributed/fsdp/test_fsdp_state_dict": 1047.2489999999998, "distributed/fsdp/test_fsdp_tp_integration": 37.082499999999996, "distributed/fsdp/test_fsdp_traversal": 5.978, "distributed/fsdp/test_fsdp_uneven": 7.0785, "distributed/fsdp/test_fsdp_unshard_params": 89.91000000000001, "distributed/fsdp/test_fsdp_use_orig_params": 299.643, "distributed/fsdp/test_hsdp_dtensor_state_dict": 72.15950000000001, "distributed/fsdp/test_shard_utils": 11.729000000000001, "distributed/fsdp/test_utils": 0.6244999999999999, "distributed/fsdp/test_wrap": 166.453, "distributed/pipelining/test_composability": 32.416000000000004, "distributed/rpc/cuda/test_tensorpipe_agent": 831.5845000000002, "distributed/tensor/parallel/test_ddp_2d_parallel": 8.777, "distributed/tensor/parallel/test_fsdp_2d_parallel": 98.33549999999998, "distributed/tensor/parallel/test_tp_examples": 48.370000000000005, "distributed/tensor/parallel/test_tp_random_state": 8.52, "distributed/test_c10d_common": 118.6005, "distributed/test_c10d_gloo": 618.058, "distributed/test_c10d_nccl": 1098.3979999999997, "distributed/test_c10d_spawn_gloo": 41.1115, "distributed/test_c10d_spawn_nccl": 48.952, "distributed/test_cuda_p2p": 0.0, "distributed/test_device_mesh": 207.38150000000002, "distributed/test_functional_api": 106.84499999999998, "distributed/test_pg_wrapper": 101.9345, "distributed/test_store": 90.8385, "test_cuda_multigpu": 8.5405, "test_cuda_primary_ctx": 1.4955, "test_foreach": 0.709, "test_optim": 13.627499999999998}, "nogpu_AVX512": {"backends/xeon/test_launch": 2.59625, "benchmark_utils/test_benchmark_utils": 0.7645, "distributions/test_distributions": 88.13925, "dynamo/test_activation_checkpointing": 0.7865, "dynamo/test_after_aot": 10.20025, "dynamo/test_aot_autograd": 19.00225, "dynamo/test_aot_autograd_cache": 9.48075, "dynamo/test_autograd_function": 4.085999999999999, "dynamo/test_backends": 21.049, "dynamo/test_backward_higher_order_ops": 18.25925, "dynamo/test_base_output": 0.0032500000000000003, "dynamo/test_bytecode_utils": 9.5155, "dynamo/test_compile": 10.56275, "dynamo/test_comptime": 0.9340000000000002, "dynamo/test_config": 0.8732500000000001, "dynamo/test_ctx_manager": 1.8717500000000007, "dynamo/test_debug_utils": 0.38025, "dynamo/test_decorators": 10.106, "dynamo/test_deviceguard": 0.02375, "dynamo/test_dynamic_shapes": 630.808, "dynamo/test_exc": 2.8385, "dynamo/test_exceptions": 0.82325, "dynamo/test_export": 21.421749999999996, "dynamo/test_export_mutations": 0.8452500000000001, "dynamo/test_frame_init": 0.33075, "dynamo/test_functions": 33.930500000000045, "dynamo/test_fx_passes_pre_grad": 1.678, "dynamo/test_global": 0.8160000000000001, "dynamo/test_guard_manager": 0.38475000000000004, "dynamo/test_higher_order_ops": 27.248499999999996, "dynamo/test_hooks": 36.84600000000002, "dynamo/test_inline_inbuilt_nn_modules": 115.20950000000008, "dynamo/test_input_attr_tracking": 12.1085, "dynamo/test_interop": 0.8684999999999999, "dynamo/test_logging": 24.8575, "dynamo/test_minifier": 1.9852499999999997, "dynamo/test_misc": 80.77350000000011, "dynamo/test_model_output": 0.00625, "dynamo/test_modules": 27.964999999999996, "dynamo/test_nops": 0.46099999999999997, "dynamo/test_optimizers": 0.95725, "dynamo/test_pre_dispatch": 0.74675, "dynamo/test_profiler": 1.8372499999999996, "dynamo/test_python_autograd": 0.9992500000000001, "dynamo/test_recompile_ux": 1.2557500000000004, "dynamo/test_recompiles": 1.2677500000000002, "dynamo/test_reorder_logs": 0.81525, "dynamo/test_repros": 50.12774999999998, "dynamo/test_resume": 0.7015, "dynamo/test_sdpa": 0.7622500000000001, "dynamo/test_skip_non_tensor": 0.857, "dynamo/test_sources": 0.756, "dynamo/test_structured_trace": 17.02975, "dynamo/test_subclasses": 20.783749999999998, "dynamo/test_subgraphs": 3.2194999999999987, "dynamo/test_trace_rules": 1.8855, "dynamo/test_unspec": 19.708749999999995, "dynamo/test_verify_correctness": 0.90825, "dynamo/test_view": 0.96425, "export/test_converter": 7.2675, "export/test_db": 4.39625, "export/test_experimental": 1.414, "export/test_export": 42.443000000000005, "export/test_export_nonstrict": 36.017500000000005, "export/test_functionalized_assertions": 0.3395, "export/test_hop": 0.0045000000000000005, "export/test_lift_unlift": 0.13625, "export/test_pass_infra": 1.3040000000000003, "export/test_passes": 17.464000000000002, "export/test_retraceability": 67.596, "export/test_schema": 0.39375, "export/test_serdes": 43.75199999999999, "export/test_serialize": 13.078000000000003, "export/test_sparse": 82.91174999999986, "export/test_tools": 0.8275, "export/test_torchbind": 3.9859999999999993, "export/test_tree_utils": 0.33899999999999997, "export/test_unflatten": 4.426499999999999, "export/test_verifier": 1.3252500000000003, "functorch/test_aotdispatch": 41.722999999999985, "functorch/test_control_flow": 153.80574999999993, "functorch/test_dims": 41.076, "functorch/test_eager_transforms": 0.16400000000000003, "functorch/test_logging": 0.39725, "functorch/test_memory_efficient_fusion": 0.9714999999999999, "functorch/test_minifier": 0.609, "functorch/test_parsing": 0.35925000000000007, "functorch/test_rearrange": 0.41675000000000006, "functorch/test_vmap": 4.539499999999991, "functorch/test_vmap_registrations": 3.4744999999998423, "higher_order_ops/test_with_effects": 9.384, "inductor/test_benchmark_fusion": 13.177500000000002, "inductor/test_binary_folding": 52.25999999999999, "inductor/test_codecache": 62.04549999999999, "inductor/test_codegen_triton": 0.33575, "inductor/test_compile_worker": 11.309999999999999, "inductor/test_compiled_autograd": 672.8732500000003, "inductor/test_compiled_optimizers": 338.86825000000067, "inductor/test_config": 8.957, "inductor/test_control_flow": 0.11775000000000002, "inductor/test_cpu_repro": 928.5175, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 15.861, "inductor/test_debug_trace": 4.906, "inductor/test_decompose_mem_bound_mm": 0.00175, "inductor/test_distributed_patterns": 52.48275000000001, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 27.06425, "inductor/test_flex_attention": 0.021000000000000008, "inductor/test_foreach": 24.77075000000003, "inductor/test_fused_attention": 213.87075, "inductor/test_fx_fusion": 0.2925, "inductor/test_graph_transform_observer": 0.02075, "inductor/test_group_batch_fusion": 0.30175, "inductor/test_indexing": 0.9085000000000001, "inductor/test_inductor_freezing": 76.24575000000002, "inductor/test_minifier": 34.669000000000004, "inductor/test_minifier_isolate": 67.45949999999999, "inductor/test_mkldnn_pattern_matcher": 993.7310000000002, "inductor/test_standalone_compile": 24.17175, "inductor/test_torchbind": 13.89725, "inductor/test_torchinductor": 2136.2397499999993, "inductor/test_torchinductor_codegen_dynamic_shapes": 2063.800749999998, "inductor/test_torchinductor_dynamic_shapes": 2183.030749999999, "inductor/test_triton_extension_backend": 0.855, "inductor/test_triton_kernels": 0.03725000000000002, "inductor/test_utils": 0.32975, "lazy/test_debug_util": 0.403, "lazy/test_functionalization": 0.41050000000000003, "lazy/test_generator": 0.41275, "lazy/test_reuse_ir": 0.7545, "lazy/test_step_closures": 3.3339999999999996, "lazy/test_ts_opinfo": 0.40149999999999997, "nn/test_convolution": 20.533750000000005, "nn/test_dropout": 0.14800000000000002, "nn/test_embedding": 0.06975000000000003, "nn/test_init": 5.614249999999998, "nn/test_lazy_modules": 0.5217500000000002, "nn/test_load_state_dict": 0.8385, "nn/test_module_hooks": 0.28125, "nn/test_multihead_attention": 6.669499999999999, "nn/test_packed_sequence": 0.5722500000000001, "nn/test_parametrization": 1.1067500000000003, "nn/test_pooling": 0.82225, "nn/test_pruning": 0.13650000000000007, "profiler/test_execution_trace": 0.15749999999999997, "profiler/test_memory_profiler": 6.54875, "profiler/test_profiler": 29.75225, "profiler/test_profiler_tree": 0.44800000000000006, "profiler/test_record_function": 0.39875000000000005, "profiler/test_torch_tidy": 5.520749999999999, "test_ao_sparsity": 9.249499999999998, "test_autocast": 1.534, "test_autograd": 37.82750000000005, "test_autograd_fallback": 0.5077500000000001, "test_bundled_inputs": 1.583, "test_comparison_utils": 0.34775, "test_compile_benchmark_util": 0.00075, "test_cpp_api_parity": 4.8722499999999815, "test_cpp_extensions_aot_ninja": 0.05, "test_cpp_extensions_aot_no_ninja": 0.054000000000000006, "test_cpp_extensions_jit": 60.3125, "test_cpp_extensions_mtia_backend": 1.0594999999999999, "test_cpp_extensions_open_device_registration": 12.003, "test_cpp_extensions_stream_and_event": 1.0785, "test_custom_backend": 0.10974999999999999, "test_custom_ops": 9.186749999999993, "test_dataloader": 253.89600000000007, "test_datapipe": 15.865999999999996, "test_decomp": 0.22424999999999998, "test_deploy": 0.334, "test_dispatch": 41.793749999999996, "test_dynamic_shapes": 6.2459999999999924, "test_fake_tensor": 2.8952500000000003, "test_flop_counter": 0.5760000000000001, "test_function_schema": 0.7244999999999999, "test_functional_autograd_benchmark": 41.853750000000005, "test_functional_optim": 0.48050000000000015, "test_functionalization": 6.627749999999997, "test_futures": 1.29175, "test_fx": 351.84075000000007, "test_fx_experimental": 20.96725, "test_fx_passes": 0.9360000000000004, "test_fx_reinplace_pass": 0.5755000000000001, "test_import_stats": 4.9335, "test_itt": 0.34075, "test_jit": 148.1975, "test_jit_autocast": 22.134999999999998, "test_jit_disabled": 0.46925000000000006, "test_jit_fuser_te": 181.85000000000008, "test_jit_llga_fuser": 3.2097499999999997, "test_legacy_vmap": 2.42375, "test_license": 0.34775, "test_logging": 3.496, "test_maskedtensor": 0.8895000000000006, "test_meta": 0.06950000000000003, "test_mkl_verbose": 5.66875, "test_mkldnn_fusion": 80.519, "test_mkldnn_verbose": 5.0760000000000005, "test_mobile_optimizer": 3.8249999999999997, "test_model_dump": 1.2494999999999998, "test_model_exports_to_core_aten": 0.27825, "test_module_tracker": 0.33875, "test_monitor": 0.5602499999999999, "test_multiprocessing": 67.49025, "test_multiprocessing_spawn": 38.2425, "test_namedtensor": 0.4222500000000001, "test_namedtuple_return_api": 2.389, "test_native_functions": 0.4820000000000001, "test_nestedtensor": 0.1645000000000001, "test_nn": 55.599499999999935, "test_numba_integration": 0.003, "test_openmp": 6.66525, "test_ops": 0.0045000000000000005, "test_optim": 1.7275000000000005, "test_out_dtype_op": 0.40275000000000005, "test_overrides": 2.793999999999892, "test_package": 3.1922499999999983, "test_per_overload_api": 0.34625000000000006, "test_prims": 0.018250000000000002, "test_proxy_tensor": 31.93575, "test_pruning_op": 0.577, "test_public_bindings": 7.68225, "test_python_dispatch": 0.6062500000000002, "test_pytree": 0.6007500000000002, "test_quantization": 2237.80575, "test_schema_check": 0.13900000000000007, "test_serialization": 52.350000000000016, "test_set_default_mobile_cpu_allocator": 0.33625, "test_show_pickle": 0.39, "test_sparse": 4.840499999999999, "test_sparse_csr": 0.6395, "test_sparse_semi_structured": 0.003, "test_stateless": 7.6057500000000005, "test_subclass": 0.5837500000000002, "test_sympy_utils": 19.850749999999998, "test_tensorboard": 37.98675, "test_tensorexpr": 68.25625000000002, "test_tensorexpr_pybind": 1.1477500000000003, "test_testing": 32.94, "test_torch": 7.227499999999989, "test_type_hints": 0.34825, "test_type_info": 0.34975, "test_typing": 102.40950000000007, "test_utils": 16.965249999999997, "test_vulkan": 0.003, "test_weak": 5.517499999999998, "test_xnnpack_integration": 11.919, "torch_np/numpy_tests/core/test_dlpack": 0.00275, "torch_np/numpy_tests/core/test_dtype": 0.50675, "torch_np/numpy_tests/core/test_einsum": 18.878250000000005, "torch_np/numpy_tests/core/test_getlimits": 0.372, "torch_np/numpy_tests/core/test_indexing": 0.5680000000000002, "torch_np/numpy_tests/core/test_multiarray": 36.068250000000006, "torch_np/numpy_tests/core/test_numeric": 5.682499999999999, "torch_np/numpy_tests/core/test_numerictypes": 0.376, "torch_np/numpy_tests/core/test_scalar_ctors": 0.5342500000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.003, "torch_np/numpy_tests/core/test_scalarinherit": 0.0005, "torch_np/numpy_tests/core/test_scalarmath": 30.85875, "torch_np/numpy_tests/core/test_shape_base": 0.6645000000000003, "torch_np/numpy_tests/fft/test_helper": 7.3255, "torch_np/numpy_tests/fft/test_pocketfft": 4.7475000000000005, "torch_np/numpy_tests/lib/test_arraypad": 0.36125, "torch_np/numpy_tests/lib/test_arraysetops": 0.5655, "torch_np/numpy_tests/lib/test_function_base": 2.375, "torch_np/numpy_tests/lib/test_histograms": 0.7080000000000002, "torch_np/numpy_tests/lib/test_index_tricks": 0.4577500000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.8712500000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.6185, "torch_np/numpy_tests/lib/test_type_check": 0.5265, "torch_np/numpy_tests/linalg/test_linalg": 5.893250000000001, "torch_np/test_basic": 0.7415000000000005, "torch_np/test_binary_ufuncs": 0.49025000000000013, "torch_np/test_dtype": 0.41750000000000004, "torch_np/test_function_base": 0.34299999999999997, "torch_np/test_ndarray_methods": 3.354250000000002, "torch_np/test_nep50_examples": 0.0235, "torch_np/test_random": 0.41900000000000004, "torch_np/test_reductions": 3.2184999999999375, "torch_np/test_scalars_0D_arrays": 0.4447500000000001, "torch_np/test_ufuncs_basic": 1.3710000000000004, "torch_np/test_unary_ufuncs": 0.5170000000000001}, "nogpu_NO_AVX2": {"backends/xeon/test_launch": 2.74475, "benchmark_utils/test_benchmark_utils": 0.8327500000000001, "distributions/test_distributions": 92.37525000000001, "dynamo/test_activation_checkpointing": 0.8455000000000001, "dynamo/test_after_aot": 10.341000000000001, "dynamo/test_aot_autograd": 20.148000000000003, "dynamo/test_aot_autograd_cache": 9.444500000000001, "dynamo/test_autograd_function": 4.250749999999998, "dynamo/test_backends": 22.122, "dynamo/test_backward_higher_order_ops": 19.109499999999997, "dynamo/test_base_output": 0.00425, "dynamo/test_bytecode_utils": 10.0465, "dynamo/test_compile": 11.21425, "dynamo/test_comptime": 0.9510000000000002, "dynamo/test_config": 0.9252499999999999, "dynamo/test_ctx_manager": 1.9665000000000004, "dynamo/test_debug_utils": 0.386, "dynamo/test_decorators": 10.795499999999999, "dynamo/test_deviceguard": 0.0245, "dynamo/test_dynamic_shapes": 662.9305000000002, "dynamo/test_exc": 2.9935, "dynamo/test_exceptions": 0.8752500000000001, "dynamo/test_export": 23.21475, "dynamo/test_export_mutations": 0.8905000000000001, "dynamo/test_frame_init": 0.3635, "dynamo/test_functions": 35.9420000000001, "dynamo/test_fx_passes_pre_grad": 1.7584999999999997, "dynamo/test_global": 0.8900000000000001, "dynamo/test_guard_manager": 0.41425, "dynamo/test_higher_order_ops": 29.206249999999997, "dynamo/test_hooks": 38.89625, "dynamo/test_inline_inbuilt_nn_modules": 120.41275000000009, "dynamo/test_input_attr_tracking": 12.75275, "dynamo/test_interop": 0.9205, "dynamo/test_logging": 27.010750000000005, "dynamo/test_minifier": 2.1122499999999995, "dynamo/test_misc": 85.20625000000015, "dynamo/test_model_output": 0.00675, "dynamo/test_modules": 28.80125, "dynamo/test_nops": 0.4895, "dynamo/test_optimizers": 1.024, "dynamo/test_pre_dispatch": 0.7935000000000001, "dynamo/test_profiler": 1.9429999999999998, "dynamo/test_python_autograd": 1.05275, "dynamo/test_recompile_ux": 1.3065000000000002, "dynamo/test_recompiles": 1.4005, "dynamo/test_reorder_logs": 0.8530000000000001, "dynamo/test_repros": 56.42175, "dynamo/test_resume": 0.74675, "dynamo/test_sdpa": 0.7927500000000001, "dynamo/test_skip_non_tensor": 0.88575, "dynamo/test_sources": 0.80525, "dynamo/test_structured_trace": 17.748999999999995, "dynamo/test_subclasses": 22.038999999999998, "dynamo/test_subgraphs": 3.4702499999999983, "dynamo/test_trace_rules": 1.9377499999999999, "dynamo/test_unspec": 20.885499999999993, "dynamo/test_verify_correctness": 0.9730000000000001, "dynamo/test_view": 1.0294999999999999, "export/test_converter": 7.629750000000001, "export/test_db": 4.7205, "export/test_experimental": 1.48075, "export/test_export": 45.518499999999996, "export/test_export_nonstrict": 38.573499999999996, "export/test_functionalized_assertions": 0.362, "export/test_hop": 0.0045000000000000005, "export/test_lift_unlift": 0.14500000000000002, "export/test_pass_infra": 1.3467500000000001, "export/test_passes": 18.716, "export/test_retraceability": 67.96624999999999, "export/test_schema": 0.42200000000000004, "export/test_serdes": 48.1075, "export/test_serialize": 13.770250000000004, "export/test_sparse": 90.36424999999991, "export/test_tools": 0.8745, "export/test_torchbind": 4.25275, "export/test_tree_utils": 0.363, "export/test_unflatten": 4.67175, "export/test_verifier": 1.4217500000000003, "functorch/test_aotdispatch": 44.63799999999999, "functorch/test_control_flow": 164.59199999999998, "functorch/test_dims": 45.78625, "functorch/test_eager_transforms": 0.16275000000000003, "functorch/test_logging": 0.41975, "functorch/test_memory_efficient_fusion": 1.02175, "functorch/test_minifier": 0.6552499999999999, "functorch/test_parsing": 0.38175000000000003, "functorch/test_rearrange": 0.4357500000000001, "functorch/test_vmap": 4.688749999999992, "functorch/test_vmap_registrations": 3.462499999999837, "higher_order_ops/test_with_effects": 9.964500000000001, "inductor/test_benchmark_fusion": 14.2725, "inductor/test_binary_folding": 55.054500000000004, "inductor/test_codecache": 64.99425, "inductor/test_codegen_triton": 0.3565, "inductor/test_compile_worker": 11.95625, "inductor/test_compiled_autograd": 701.1707500000003, "inductor/test_compiled_optimizers": 351.7090000000007, "inductor/test_config": 9.435749999999999, "inductor/test_control_flow": 0.1295, "inductor/test_cpu_repro": 985.1710000000003, "inductor/test_custom_lowering": 0.0035, "inductor/test_custom_post_grad_passes": 16.521250000000002, "inductor/test_debug_trace": 5.0485, "inductor/test_decompose_mem_bound_mm": 0.0025, "inductor/test_distributed_patterns": 54.28, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 28.60625, "inductor/test_flex_attention": 0.021000000000000008, "inductor/test_foreach": 26.02775000000003, "inductor/test_fused_attention": 225.2345, "inductor/test_fx_fusion": 0.29750000000000004, "inductor/test_graph_transform_observer": 0.022, "inductor/test_group_batch_fusion": 0.31025, "inductor/test_indexing": 0.9555, "inductor/test_inductor_freezing": 80.62075000000002, "inductor/test_minifier": 36.98975, "inductor/test_minifier_isolate": 71.78575000000001, "inductor/test_mkldnn_pattern_matcher": 1043.1005, "inductor/test_standalone_compile": 25.41325, "inductor/test_torchbind": 14.6425, "inductor/test_torchinductor": 2237.365749999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 2157.202749999998, "inductor/test_torchinductor_dynamic_shapes": 2283.7172499999997, "inductor/test_triton_extension_backend": 0.90425, "inductor/test_triton_kernels": 0.043250000000000025, "inductor/test_utils": 0.36624999999999996, "lazy/test_debug_util": 0.426, "lazy/test_functionalization": 0.43899999999999995, "lazy/test_generator": 0.43925000000000003, "lazy/test_reuse_ir": 0.8580000000000001, "lazy/test_step_closures": 3.372, "lazy/test_ts_opinfo": 0.382, "nn/test_convolution": 21.277749999999997, "nn/test_dropout": 0.21225000000000002, "nn/test_embedding": 0.07325000000000004, "nn/test_init": 5.821499999999999, "nn/test_lazy_modules": 0.5762500000000003, "nn/test_load_state_dict": 0.8990000000000001, "nn/test_module_hooks": 0.28950000000000004, "nn/test_multihead_attention": 6.84925, "nn/test_packed_sequence": 0.5810000000000002, "nn/test_parametrization": 1.2822500000000003, "nn/test_pooling": 0.84775, "nn/test_pruning": 0.13975000000000007, "profiler/test_execution_trace": 0.17024999999999998, "profiler/test_memory_profiler": 7.05525, "profiler/test_profiler": 32.24249999999999, "profiler/test_profiler_tree": 0.4727500000000001, "profiler/test_record_function": 0.43450000000000005, "profiler/test_torch_tidy": 6.276249999999999, "test_ao_sparsity": 9.77225, "test_autocast": 3.2379999999999995, "test_autograd": 40.15100000000006, "test_autograd_fallback": 0.5280000000000001, "test_bundled_inputs": 2.455999999999999, "test_comparison_utils": 0.3705, "test_compile_benchmark_util": 0.0015, "test_cpp_api_parity": 5.265999999999984, "test_cpp_extensions_aot_ninja": 0.05325000000000001, "test_cpp_extensions_aot_no_ninja": 0.05675000000000001, "test_cpp_extensions_jit": 63.486000000000004, "test_cpp_extensions_mtia_backend": 1.14375, "test_cpp_extensions_open_device_registration": 12.435250000000003, "test_cpp_extensions_stream_and_event": 1.1412499999999999, "test_custom_backend": 0.11424999999999999, "test_custom_ops": 9.730749999999992, "test_dataloader": 244.20075000000006, "test_datapipe": 16.72625, "test_decomp": 0.23199999999999998, "test_deploy": 0.37875000000000003, "test_dispatch": 42.628249999999994, "test_dynamic_shapes": 6.573999999999993, "test_fake_tensor": 4.0272499999999996, "test_flop_counter": 0.7705, "test_function_schema": 0.8615, "test_functional_autograd_benchmark": 45.423, "test_functional_optim": 0.516, "test_functionalization": 7.5647499999999965, "test_futures": 1.3242500000000001, "test_fx": 421.83624999999995, "test_fx_experimental": 25.509750000000004, "test_fx_passes": 1.0372500000000002, "test_fx_reinplace_pass": 0.6137500000000002, "test_import_stats": 5.28025, "test_itt": 0.36375, "test_jit": 154.2255, "test_jit_autocast": 23.098750000000003, "test_jit_disabled": 0.49350000000000005, "test_jit_fuser_te": 190.89775000000003, "test_jit_llga_fuser": 4.107749999999999, "test_legacy_vmap": 2.4295, "test_license": 0.38725, "test_logging": 3.69025, "test_maskedtensor": 0.9140000000000006, "test_meta": 0.07950000000000004, "test_mkl_verbose": 5.8950000000000005, "test_mkldnn_fusion": 93.01225, "test_mkldnn_verbose": 5.3975, "test_mobile_optimizer": 4.0925, "test_model_dump": 1.3940000000000001, "test_model_exports_to_core_aten": 0.30175, "test_module_tracker": 0.37124999999999997, "test_monitor": 0.5742499999999999, "test_multiprocessing": 69.33324999999999, "test_multiprocessing_spawn": 40.628, "test_namedtensor": 0.5117500000000001, "test_namedtuple_return_api": 2.39475, "test_native_functions": 0.5172500000000001, "test_nestedtensor": 0.1875000000000001, "test_nn": 65.48050000000009, "test_numba_integration": 0.006, "test_openmp": 6.188, "test_ops": 0.0045000000000000005, "test_optim": 1.8485000000000007, "test_out_dtype_op": 0.42200000000000004, "test_overrides": 2.8259999999998895, "test_package": 3.758249999999999, "test_per_overload_api": 0.364, "test_prims": 0.02475, "test_proxy_tensor": 34.06075, "test_pruning_op": 0.60375, "test_public_bindings": 7.984499999999999, "test_python_dispatch": 0.6267500000000001, "test_pytree": 0.6155000000000002, "test_quantization": 2475.0242500000004, "test_schema_check": 0.15450000000000008, "test_serialization": 73.30350000000004, "test_set_default_mobile_cpu_allocator": 0.36824999999999997, "test_show_pickle": 0.43, "test_sparse": 5.01875, "test_sparse_csr": 0.64925, "test_sparse_semi_structured": 0.0045000000000000005, "test_stateless": 8.28425, "test_subclass": 0.6122500000000002, "test_sympy_utils": 20.393499999999996, "test_tensorboard": 47.5, "test_tensorexpr": 70.36124999999998, "test_tensorexpr_pybind": 1.2477500000000004, "test_testing": 35.005250000000004, "test_torch": 7.900749999999988, "test_type_hints": 0.35724999999999996, "test_type_info": 0.3835, "test_typing": 107.04975000000005, "test_utils": 18.469499999999996, "test_vulkan": 0.0035, "test_weak": 6.00975, "test_xnnpack_integration": 15.2335, "torch_np/numpy_tests/core/test_dlpack": 0.00275, "torch_np/numpy_tests/core/test_dtype": 0.5367500000000001, "torch_np/numpy_tests/core/test_einsum": 19.394750000000002, "torch_np/numpy_tests/core/test_getlimits": 0.40975, "torch_np/numpy_tests/core/test_indexing": 0.5960000000000002, "torch_np/numpy_tests/core/test_multiarray": 36.88425000000001, "torch_np/numpy_tests/core/test_numeric": 5.823499999999999, "torch_np/numpy_tests/core/test_numerictypes": 0.41350000000000003, "torch_np/numpy_tests/core/test_scalar_ctors": 0.5577500000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.005, "torch_np/numpy_tests/core/test_scalarinherit": 0.00125, "torch_np/numpy_tests/core/test_scalarmath": 31.59, "torch_np/numpy_tests/core/test_shape_base": 0.7285000000000003, "torch_np/numpy_tests/fft/test_helper": 8.17, "torch_np/numpy_tests/fft/test_pocketfft": 4.9565, "torch_np/numpy_tests/lib/test_arraypad": 0.4035, "torch_np/numpy_tests/lib/test_arraysetops": 0.6355000000000001, "torch_np/numpy_tests/lib/test_function_base": 2.52625, "torch_np/numpy_tests/lib/test_histograms": 0.7197500000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.48600000000000004, "torch_np/numpy_tests/lib/test_shape_base_": 0.9487500000000001, "torch_np/numpy_tests/lib/test_twodim_base": 0.6527500000000002, "torch_np/numpy_tests/lib/test_type_check": 0.5752500000000002, "torch_np/numpy_tests/linalg/test_linalg": 6.172500000000001, "torch_np/test_basic": 0.7917500000000005, "torch_np/test_binary_ufuncs": 0.5227500000000002, "torch_np/test_dtype": 0.45625000000000004, "torch_np/test_function_base": 0.36524999999999996, "torch_np/test_ndarray_methods": 3.4737500000000017, "torch_np/test_nep50_examples": 0.022, "torch_np/test_random": 0.45050000000000007, "torch_np/test_reductions": 3.3687499999999386, "torch_np/test_scalars_0D_arrays": 0.43450000000000005, "torch_np/test_ufuncs_basic": 1.5140000000000007, "torch_np/test_unary_ufuncs": 0.5665000000000002}}, "linux-focal-cuda11.8-py3.10-gcc9": {"distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": 16.699, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 11.498, "distributed/_composable/fsdp/test_fully_shard_collectives": 81.51899999999999, "distributed/_composable/fsdp/test_fully_shard_comm": 125.509, "distributed/_composable/fsdp/test_fully_shard_compile": 5.214000000000001, "distributed/_composable/fsdp/test_fully_shard_extensions": 10.987333333333334, "distributed/_composable/fsdp/test_fully_shard_frozen": 19.640333333333334, "distributed/_composable/fsdp/test_fully_shard_init": 6.402333333333334, "distributed/_composable/fsdp/test_fully_shard_memory": 6.178999999999999, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 21.183666666666667, "distributed/_composable/fsdp/test_fully_shard_overlap": 21.275, "distributed/_composable/fsdp/test_fully_shard_state": 0.15533333333333335, "distributed/_composable/fsdp/test_fully_shard_state_dict": 16.855999999999998, "distributed/_composable/fsdp/test_fully_shard_training": 220.80466666666663, "distributed/_composable/fully_shard/test_fully_shard_compile": 0.001, "distributed/_composable/fully_shard/test_fully_shard_init": 27.268999999999995, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 4.903666666666666, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 21.977666666666664, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 9.848666666666666, "distributed/_composable/fully_shard/test_fully_shard_runtime": 12.726666666666667, "distributed/_composable/fully_shard/test_fully_shard_util": 4.705333333333333, "distributed/_composable/test_checkpoint": 0.24433333333333332, "distributed/_composable/test_compose": 42.010666666666665, "distributed/_composable/test_contract": 0.311, "distributed/_composable/test_replicate": 33.89366666666666, "distributed/_composable/test_replicate_with_compiler": 72.45500000000001, "distributed/_shard/sharded_optim/test_sharded_optim": 7.687333333333334, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": 15.212666666666669, "distributed/_shard/sharded_tensor/ops/test_embedding": 7.683333333333333, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": 7.678333333333334, "distributed/_shard/sharded_tensor/ops/test_init": 11.499666666666664, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 18.68766666666667, "distributed/_shard/sharded_tensor/test_logger": 0.302, "distributed/_shard/sharded_tensor/test_sharded_tensor": 232.00366666666665, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": 7.723333333333333, "distributed/_shard/sharding_plan/test_sharding_plan": 11.33, "distributed/_shard/sharding_spec/test_sharding_spec": 12.285000000000002, "distributed/_shard/test_sharder": 7.646333333333334, "distributed/_tensor/debug/test_comm_mode": 0.42266666666666675, "distributed/_tensor/debug/test_op_coverage": 0.4546666666666667, "distributed/_tensor/experimental/test_local_map": 18.352999999999998, "distributed/_tensor/experimental/test_tp_transform": 16.148666666666667, "distributed/_tensor/test_api": 30.302666666666667, "distributed/_tensor/test_attention": 3.834666666666666, "distributed/_tensor/test_basic_strategy": 0.44400000000000006, "distributed/_tensor/test_common_rules": 38.12733333333333, "distributed/_tensor/test_convolution_ops": 35.07533333333334, "distributed/_tensor/test_device_mesh": 64.12399999999998, "distributed/_tensor/test_dtensor": 128.17733333333334, "distributed/_tensor/test_dtensor_compile": 21.301666666666666, "distributed/_tensor/test_embedding_ops": 14.106, "distributed/_tensor/test_experimental_ops": 13.707999999999998, "distributed/_tensor/test_init": 27.188, "distributed/_tensor/test_math_ops": 49.76766666666666, "distributed/_tensor/test_matrix_ops": 40.940999999999995, "distributed/_tensor/test_op_strategy": 0.4366666666666667, "distributed/_tensor/test_optimizers": 53.68233333333333, "distributed/_tensor/test_pointwise_ops": 0.5526666666666668, "distributed/_tensor/test_random_ops": 29.544, "distributed/_tensor/test_redistribute": 43.48133333333334, "distributed/_tensor/test_tensor_ops": 109.23300000000005, "distributed/_tensor/test_utils": 22.082000000000004, "distributed/_tensor/test_view_ops": 24.350666666666665, "distributed/_tensor/test_xla_integration": 0.30033333333333334, "distributed/_tools/test_memory_tracker": 0.334, "distributed/_tools/test_mod_tracker": 0.3213333333333333, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 29.768333333333334, "distributed/algorithms/quantization/test_quantization": 54.63499999999999, "distributed/algorithms/test_join": 40.94166666666667, "distributed/checkpoint/e2e/test_e2e_save_and_load": 47.635999999999996, "distributed/checkpoint/e2e/test_fine_tuning": 3.810333333333333, "distributed/checkpoint/e2e/test_fsdp_ep": 3.779666666666667, "distributed/checkpoint/e2e/test_pipeline": 4.639, "distributed/checkpoint/fsdp/test_fsdp_dsd": 10.054666666666668, "distributed/checkpoint/test_checkpoint": 31.057999999999996, "distributed/checkpoint/test_compatibility": 0.38866666666666666, "distributed/checkpoint/test_dedup_tensors": 0.2936666666666667, "distributed/checkpoint/test_dtensor_checkpoint": 4.8180000000000005, "distributed/checkpoint/test_dtensor_resharding": 27.708, "distributed/checkpoint/test_file_system_checkpoint": 23.39633333333333, "distributed/checkpoint/test_file_system_checkpoint_cpu": 37.763333333333335, "distributed/checkpoint/test_format_utils": 12.131666666666666, "distributed/checkpoint/test_fsdp_model_state": 8.528, "distributed/checkpoint/test_fsdp_optim_state": 9.722999999999999, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 5.081, "distributed/checkpoint/test_fsspec": 9.689666666666666, "distributed/checkpoint/test_hsdp_checkpoint": 14.613666666666667, "distributed/checkpoint/test_nested_dict": 0.29433333333333334, "distributed/checkpoint/test_planner": 0.4176666666666667, "distributed/checkpoint/test_save_load_api": 3.775, "distributed/checkpoint/test_state_dict": 130.32566666666665, "distributed/checkpoint/test_state_dict_utils": 19.221666666666668, "distributed/checkpoint/test_torch_save_to_dcp": 8.446666666666665, "distributed/checkpoint/test_tp_checkpoint": 9.692333333333334, "distributed/checkpoint/test_traverse": 0.30866666666666664, "distributed/checkpoint/test_utils": 0.316, "distributed/elastic/events/lib_test": 0.36633333333333334, "distributed/elastic/metrics/api_test": 0.30833333333333335, "distributed/elastic/multiprocessing/api_test": 36.556666666666665, "distributed/elastic/test_control_plane": 5.404, "distributed/elastic/timer/local_timer_example": 13.307333333333332, "distributed/elastic/timer/local_timer_test": 5.528666666666666, "distributed/elastic/utils/distributed_test": 2.3686666666666665, "distributed/elastic/utils/logging_test": 0.35766666666666663, "distributed/elastic/utils/util_test": 0.3753333333333333, "distributed/fsdp/test_checkpoint_wrapper": 0.521, "distributed/fsdp/test_distributed_checkpoint": 0.29433333333333334, "distributed/fsdp/test_fsdp_apply": 14.396, "distributed/fsdp/test_fsdp_backward_prefetch": 8.107, "distributed/fsdp/test_fsdp_checkpoint": 79.64633333333335, "distributed/fsdp/test_fsdp_clip_grad_norm": 36.36833333333333, "distributed/fsdp/test_fsdp_comm": 46.81433333333333, "distributed/fsdp/test_fsdp_comm_hooks": 126.23266666666667, "distributed/fsdp/test_fsdp_core": 902.0056666666668, "distributed/fsdp/test_fsdp_dtensor_state_dict": 69.58733333333335, "distributed/fsdp/test_fsdp_exec_order": 36.28666666666667, "distributed/fsdp/test_fsdp_fine_tune": 31.09766666666667, "distributed/fsdp/test_fsdp_flatten_params": 47.943666666666665, "distributed/fsdp/test_fsdp_freezing_weights": 151.45399999999998, "distributed/fsdp/test_fsdp_fx": 0.31833333333333336, "distributed/fsdp/test_fsdp_grad_acc": 43.38966666666666, "distributed/fsdp/test_fsdp_hybrid_shard": 46.76933333333333, "distributed/fsdp/test_fsdp_ignored_modules": 60.958999999999996, "distributed/fsdp/test_fsdp_input": 8.881, "distributed/fsdp/test_fsdp_memory": 13.491333333333335, "distributed/fsdp/test_fsdp_meta": 36.966, "distributed/fsdp/test_fsdp_misc": 64.61599999999999, "distributed/fsdp/test_fsdp_mixed_precision": 312.46500000000015, "distributed/fsdp/test_fsdp_multiple_forward": 4.800333333333334, "distributed/fsdp/test_fsdp_multiple_wrapping": 4.839666666666667, "distributed/fsdp/test_fsdp_optim_state": 319.8316666666667, "distributed/fsdp/test_fsdp_overlap": 44.601333333333336, "distributed/fsdp/test_fsdp_pure_fp16": 9.552999999999999, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 113.635, "distributed/fsdp/test_fsdp_state_dict": 813.9576666666668, "distributed/fsdp/test_fsdp_tp_integration": 13.474333333333332, "distributed/fsdp/test_fsdp_traversal": 4.7043333333333335, "distributed/fsdp/test_fsdp_uneven": 4.81, "distributed/fsdp/test_fsdp_unshard_params": 71.069, "distributed/fsdp/test_fsdp_use_orig_params": 188.83533333333332, "distributed/fsdp/test_hsdp_dtensor_state_dict": 28.350666666666665, "distributed/fsdp/test_shard_utils": 9.295333333333334, "distributed/fsdp/test_utils": 0.397, "distributed/fsdp/test_wrap": 115.58066666666666, "distributed/launcher/test_run": 38.56033333333333, "distributed/nn/jit/test_instantiator": 0.32466666666666666, "distributed/optim/test_zero_redundancy_optimizer": 200.74233333333336, "distributed/pipeline/sync/skip/test_api": 0.007, "distributed/pipeline/sync/skip/test_gpipe": 1.381, "distributed/pipeline/sync/skip/test_inspect_skip_layout": 0.009000000000000001, "distributed/pipeline/sync/skip/test_leak": 0.5536666666666666, "distributed/pipeline/sync/skip/test_portal": 0.11933333333333335, "distributed/pipeline/sync/skip/test_stash_pop": 0.012666666666666672, "distributed/pipeline/sync/skip/test_tracker": 0.16766666666666666, "distributed/pipeline/sync/skip/test_verify_skippables": 0.012666666666666668, "distributed/pipeline/sync/test_balance": 5.221333333333333, "distributed/pipeline/sync/test_bugs": 2.302333333333334, "distributed/pipeline/sync/test_checkpoint": 0.5806666666666667, "distributed/pipeline/sync/test_copy": 1.012, "distributed/pipeline/sync/test_deferred_batch_norm": 1.1553333333333333, "distributed/pipeline/sync/test_dependency": 0.112, "distributed/pipeline/sync/test_inplace": 0.11699999999999999, "distributed/pipeline/sync/test_microbatch": 0.013000000000000005, "distributed/pipeline/sync/test_phony": 0.007, "distributed/pipeline/sync/test_pipe": 2.124999999999999, "distributed/pipeline/sync/test_pipeline": 0.0030000000000000005, "distributed/pipeline/sync/test_stream": 1.1586666666666667, "distributed/pipeline/sync/test_transparency": 0.4046666666666667, "distributed/pipeline/sync/test_worker": 0.015, "distributed/pipelining/test_backward": 0.31466666666666665, "distributed/pipelining/test_chunkspec": 0.7903333333333333, "distributed/pipelining/test_microbatch": 0.7799999999999999, "distributed/pipelining/test_pipe": 1.3229999999999997, "distributed/pipelining/test_schedule": 7.700666666666667, "distributed/pipelining/test_stage": 3.844666666666667, "distributed/pipelining/test_stage_backward": 0.3113333333333333, "distributed/pipelining/test_transformer": 1.202, "distributed/pipelining/test_unflatten": 0.944, "distributed/rpc/cuda/test_tensorpipe_agent": 683.1403333333333, "distributed/rpc/test_share_memory": 4.293666666666667, "distributed/tensor/parallel/test_ddp_2d_parallel": 3.748666666666667, "distributed/tensor/parallel/test_fsdp_2d_parallel": 42.69166666666666, "distributed/tensor/parallel/test_micro_pipeline_tp": 0.014000000000000005, "distributed/tensor/parallel/test_parallelize_api": 38.23433333333333, "distributed/tensor/parallel/test_tp_examples": 33.758, "distributed/tensor/parallel/test_tp_random_state": 3.813, "distributed/tensor/parallel/test_tp_style": 40.779333333333334, "distributed/tensor/parallel/test_view_sharding_dim_change": 3.918333333333333, "distributed/test_c10d_common": 90.98866666666667, "distributed/test_c10d_functional_native": 50.14866666666668, "distributed/test_c10d_gloo": 521.6160000000001, "distributed/test_c10d_logger": 17.680666666666667, "distributed/test_c10d_nccl": 917.4966666666669, "distributed/test_c10d_object_collectives": 43.14633333333333, "distributed/test_c10d_ops_nccl": 9.232000000000001, "distributed/test_c10d_pypg": 156.06500000000003, "distributed/test_c10d_spawn_gloo": 34.273, "distributed/test_c10d_spawn_nccl": 44.49666666666667, "distributed/test_c10d_spawn_ucc": 23.312, "distributed/test_c10d_ucc": 257.8016666666667, "distributed/test_compute_comm_reordering": 4.0103333333333335, "distributed/test_control_collectives": 0.3626666666666667, "distributed/test_cuda_p2p": 0.002, "distributed/test_data_parallel": 2.1029999999999998, "distributed/test_device_mesh": 146.24933333333334, "distributed/test_distributed_spawn": 5147.238999999988, "distributed/test_dynamo_distributed": 46.63933333333333, "distributed/test_fake_pg": 0.7840000000000001, "distributed/test_functional_api": 55.65233333333335, "distributed/test_inductor_collectives": 7.123, "distributed/test_launcher": 1.3230000000000002, "distributed/test_multi_threaded_pg": 0.6006666666666668, "distributed/test_nccl": 0.4523333333333333, "distributed/test_pg_wrapper": 80.006, "distributed/test_store": 62.45933333333334, "distributed/test_symmetric_memory": 0.001}}, "linux-focal-cuda11.8-py3.10-gcc9-debug": {"default": {"backends/xeon/test_launch": 3.4989999999999997, "benchmark_utils/test_benchmark_utils": 2.722, "distributions/test_distributions": 120.2995, "dynamo/test_activation_checkpointing": 1.073, "dynamo/test_after_aot": 9.965, "dynamo/test_allow_inline_skip": 0.7210000000000001, "dynamo/test_aot_autograd": 26.40549999999999, "dynamo/test_aot_autograd_cache": 11.809500000000002, "dynamo/test_autograd_function": 5.503, "dynamo/test_backends": 26.304499999999997, "dynamo/test_backward_higher_order_ops": 22.534999999999997, "dynamo/test_base_output": 0.009000000000000001, "dynamo/test_bytecode_hook": 6.434, "dynamo/test_bytecode_utils": 9.6, "dynamo/test_compile": 11.515, "dynamo/test_comptime": 1.2545000000000002, "dynamo/test_config": 1.221, "dynamo/test_cpp_guard_manager": 165.23800000000008, "dynamo/test_ctx_manager": 3.7544999999999984, "dynamo/test_cudagraphs": 6.418, "dynamo/test_debug_utils": 0.48150000000000004, "dynamo/test_decorators": 10.4585, "dynamo/test_deviceguard": 0.0325, "dynamo/test_dynamic_shapes": 830.188, "dynamo/test_exc": 3.8999999999999995, "dynamo/test_exceptions": 1.062, "dynamo/test_export": 30.344499999999996, "dynamo/test_export_mutations": 1.1945000000000001, "dynamo/test_frame_init": 0.405, "dynamo/test_functions": 59.8160000000002, "dynamo/test_fx_passes_pre_grad": 2.2005, "dynamo/test_global": 1.0645000000000002, "dynamo/test_guard_manager": 0.4735000000000001, "dynamo/test_higher_order_ops": 38.669, "dynamo/test_hooks": 49.715000000000025, "dynamo/test_inline_inbuilt_nn_modules": 178.34700000000015, "dynamo/test_input_attr_tracking": 13.4175, "dynamo/test_interop": 1.1840000000000002, "dynamo/test_logging": 30.283500000000004, "dynamo/test_minifier": 4.614500000000001, "dynamo/test_misc": 105.26000000000023, "dynamo/test_model_output": 0.025000000000000012, "dynamo/test_modules": 35.534499999999994, "dynamo/test_nops": 0.5765, "dynamo/test_optimizers": 1.293, "dynamo/test_pre_dispatch": 0.9730000000000001, "dynamo/test_profiler": 2.5324999999999998, "dynamo/test_python_autograd": 1.3130000000000002, "dynamo/test_recompile_ux": 1.8424999999999998, "dynamo/test_recompiles": 1.7409999999999997, "dynamo/test_reorder_logs": 1.0530000000000002, "dynamo/test_replay_record": 1.0566666666666666, "dynamo/test_repros": 82.97400000000005, "dynamo/test_resume": 0.8965, "dynamo/test_sdpa": 1.0055, "dynamo/test_skip_non_tensor": 1.109, "dynamo/test_sources": 0.9905, "dynamo/test_structured_trace": 21.8785, "dynamo/test_subclasses": 25.6635, "dynamo/test_subgraphs": 4.465499999999999, "dynamo/test_trace_rules": 2.537, "dynamo/test_triton_kernels": 0.5555000000000004, "dynamo/test_unspec": 23.767999999999994, "dynamo/test_verify_correctness": 1.1545, "dynamo/test_view": 1.2489999999999999, "export/test_converter": 10.33, "export/test_db": 6.553499999999999, "export/test_experimental": 1.991, "export/test_export": 56.296999999999976, "export/test_export_nonstrict": 48.36449999999999, "export/test_export_predispatch": 35.43100000000001, "export/test_functionalized_assertions": 0.4185, "export/test_funtionalized_assertions": 0.859, "export/test_hop": 5.6345, "export/test_lift_unlift": 0.1905, "export/test_pass_infra": 1.7385000000000002, "export/test_passes": 25.443, "export/test_retraceability": 83.34999999999997, "export/test_safeguard": 1.08, "export/test_schema": 0.49849999999999994, "export/test_serdes": 56.855000000000004, "export/test_serialize": 19.043999999999997, "export/test_sparse": 118.92699999999999, "export/test_tools": 1.1400000000000001, "export/test_torchbind": 5.7010000000000005, "export/test_tree_utils": 0.41200000000000003, "export/test_unflatten": 6.0765, "export/test_upgrade": 0.556, "export/test_verifier": 1.9435, "functorch/test_aotdispatch": 71.90549999999999, "functorch/test_control_flow": 212.47750000000002, "functorch/test_dims": 42.71249999999999, "functorch/test_eager_transforms": 19.643, "functorch/test_logging": 0.48, "functorch/test_memory_efficient_fusion": 15.3305, "functorch/test_minifier": 0.7995000000000001, "functorch/test_ops": 7597.761999999997, "functorch/test_parsing": 0.462, "functorch/test_rearrange": 0.5425000000000001, "functorch/test_vmap": 641.5834999999995, "functorch/test_vmap_registrations": 5.421999999999826, "higher_order_ops/test_with_effects": 9.8755, "inductor/test_benchmark_fusion": 17.936, "inductor/test_binary_folding": 75.2285, "inductor/test_codecache": 83.75899999999994, "inductor/test_codegen_triton": 0.42699999999999994, "inductor/test_compile_worker": 14.6435, "inductor/test_compiled_autograd": 990.5310000000009, "inductor/test_compiled_optimizers": 497.8664999999995, "inductor/test_config": 12.635499999999999, "inductor/test_control_flow": 0.07950000000000004, "inductor/test_cpp_wrapper": 802.3280000000002, "inductor/test_cpu_repro": 1232.3600000000001, "inductor/test_custom_lowering": 0.0045000000000000005, "inductor/test_custom_post_grad_passes": 22.953, "inductor/test_debug_trace": 6.98, "inductor/test_decompose_mem_bound_mm": 0.006500000000000001, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 75.21, "inductor/test_efficient_conv_bn_eval": 0.0035, "inductor/test_extension_backend": 37.279, "inductor/test_flex_attention": 0.1530000000000001, "inductor/test_foreach": 36.15250000000029, "inductor/test_fused_attention": 306.604, "inductor/test_fx_fusion": 0.386, "inductor/test_graph_transform_observer": 0.028499999999999998, "inductor/test_group_batch_fusion": 0.352, "inductor/test_indexing": 1.229, "inductor/test_inductor_freezing": 100.71699999999998, "inductor/test_memory_planning": 0.0023333333333333335, "inductor/test_minifier": 48.996500000000005, "inductor/test_minifier_isolate": 91.1395, "inductor/test_mkldnn_pattern_matcher": 1064.3435, "inductor/test_mmdecomp": 0.033000000000000015, "inductor/test_profiler": 0.005, "inductor/test_standalone_compile": 36.903999999999996, "inductor/test_templated_attention": 0.02900000000000002, "inductor/test_torchbind": 12.9395, "inductor/test_torchinductor": 3109.3230000000003, "inductor/test_torchinductor_codegen_dynamic_shapes": 2995.9390000000003, "inductor/test_torchinductor_dynamic_shapes": 3168.1939999999995, "inductor/test_torchinductor_opinfo": 24.73750000000005, "inductor/test_triton_extension_backend": 1.089, "inductor/test_triton_kernels": 0.25500000000000017, "inductor/test_utils": 0.40850000000000003, "lazy/test_debug_util": 0.5375, "lazy/test_functionalization": 0.5375, "lazy/test_generator": 0.5115000000000001, "lazy/test_reuse_ir": 0.872, "lazy/test_step_closures": 3.4119999999999995, "lazy/test_ts_opinfo": 0.473, "nn/test_convolution": 66.90400000000022, "nn/test_dropout": 1.537, "nn/test_embedding": 28.069499999999973, "nn/test_init": 6.847999999999999, "nn/test_lazy_modules": 0.5820000000000003, "nn/test_load_state_dict": 1.1405, "nn/test_module_hooks": 0.36050000000000004, "nn/test_multihead_attention": 10.465499999999999, "nn/test_packed_sequence": 0.8045, "nn/test_parametrization": 1.6930000000000003, "nn/test_pooling": 16.8915, "nn/test_pruning": 0.1765000000000001, "profiler/test_execution_trace": 0.36, "profiler/test_memory_profiler": 8.034, "profiler/test_profiler": 44.26549999999999, "profiler/test_profiler_tree": 0.6375000000000001, "profiler/test_record_function": 0.5465, "profiler/test_torch_tidy": 5.6579999999999995, "test_ao_sparsity": 17.608000000000004, "test_autocast": 3.9090000000000003, "test_autograd": 60.2234999999999, "test_autograd_fallback": 0.6250000000000001, "test_binary_ufuncs": 236.31150000000173, "test_bundled_inputs": 1.9719999999999995, "test_comparison_utils": 0.42700000000000005, "test_compile_benchmark_util": 0.0015, "test_complex": 0.15850000000000003, "test_content_store": 0.14700000000000002, "test_cpp_api_parity": 17.859999999999914, "test_cpp_extensions_aot_ninja": 0.42600000000000005, "test_cpp_extensions_aot_no_ninja": 0.41000000000000003, "test_cpp_extensions_jit": 128.4565, "test_cpp_extensions_mtia_backend": 0.0075, "test_cpp_extensions_open_device_registration": 12.591000000000008, "test_cpp_extensions_stream_and_event": 0.0015, "test_cuda": 171.84900000000007, "test_cuda_expandable_segments": 188.38100000000014, "test_cuda_multigpu": 1.018, "test_cuda_nvml_based_avail": 0.318, "test_cuda_primary_ctx": 0.0045000000000000005, "test_cuda_sanitizer": 0.5680000000000001, "test_cuda_trace": 1.6269999999999998, "test_custom_backend": 0.1665, "test_custom_ops": 15.342499999999989, "test_dataloader": 328.5675000000001, "test_datapipe": 19.715, "test_decomp": 15290.436999999998, "test_deploy": 0.4105, "test_dispatch": 60.49050000000001, "test_dlpack": 0.5210000000000004, "test_dynamic_shapes": 9.06499999999999, "test_expanded_weights": 24.967999999999996, "test_fake_tensor": 44.85800000000002, "test_flop_counter": 0.743, "test_foreach": 310.30450000001804, "test_function_schema": 1.096, "test_functional_autograd_benchmark": 31.436500000000002, "test_functional_optim": 0.643, "test_functionalization": 7.735999999999998, "test_functionalization_of_rng_ops": 5.0765, "test_futures": 1.4085, "test_fx": 460.0830000000001, "test_fx_experimental": 32.39899999999998, "test_fx_passes": 1.2380000000000004, "test_fx_reinplace_pass": 0.778, "test_import_stats": 6.7505, "test_indexing": 2.7704999999999984, "test_itt": 0.448, "test_jit": 197.13250000000005, "test_jit_autocast": 53.693, "test_jit_cuda_fuser": 280.738, "test_jit_disabled": 0.6204999999999999, "test_jit_fuser_te": 1175.7220000000011, "test_jit_llga_fuser": 0.1395, "test_jiterator": 39.68549999999989, "test_legacy_vmap": 3.8600000000000003, "test_license": 0.4225, "test_linalg": 523.0890000000019, "test_logging": 4.58, "test_masked": 55.64900000000012, "test_maskedtensor": 12.004999999999942, "test_matmul_cuda": 72.81, "test_meta": 4071.2174999999115, "test_mkl_verbose": 7.5794999999999995, "test_mkldnn": 76.86899999999994, "test_mkldnn_fusion": 61.85900000000001, "test_mkldnn_verbose": 6.667999999999999, "test_mobile_optimizer": 4.974500000000001, "test_model_dump": 1.9734999999999998, "test_model_exports_to_core_aten": 0.4195, "test_module_init": 2.0479999999999974, "test_module_tracker": 0.40850000000000003, "test_modules": 858.8549999999881, "test_monitor": 0.694, "test_multiprocessing": 158.38899999999998, "test_multiprocessing_spawn": 49.8905, "test_namedtensor": 1.1935000000000002, "test_namedtuple_return_api": 3.053, "test_native_functions": 0.6405000000000001, "test_native_mha": 1.1095000000000006, "test_nestedtensor": 6.881499999999992, "test_nn": 296.03899999999385, "test_numba_integration": 0.1905, "test_numpy_interop": 0.3120000000000001, "test_nvfuser_frontend": 0.002, "test_openmp": 7.2195, "test_ops": 9279.420499999958, "test_ops_fwd_gradients": 1814.5209999999875, "test_ops_gradients": 2517.927499999999, "test_ops_jit": 1794.3759999999982, "test_optim": 382.25350000000003, "test_out_dtype_op": 0.6935000000000001, "test_overrides": 5.175999999999809, "test_package": 4.243499999999999, "test_per_overload_api": 0.41750000000000004, "test_prims": 0.7390000000000001, "test_proxy_tensor": 44.413, "test_pruning_op": 0.726, "test_public_bindings": 9.804499999999999, "test_python_dispatch": 3.1445, "test_pytree": 0.7305000000000001, "test_quantization": 4712.678500000002, "test_reductions": 203.6894999999931, "test_scatter_gather_ops": 25.062000000000005, "test_schema_check": 494.93799999998953, "test_segment_reductions": 4.6839999999999975, "test_serialization": 58.662000000000006, "test_set_default_mobile_cpu_allocator": 0.44799999999999995, "test_shape_ops": 2.194999999999999, "test_show_pickle": 0.4445, "test_sort_and_select": 8.854499999999991, "test_sparse": 991.2964999999987, "test_sparse_csr": 508.3959999999977, "test_sparse_semi_structured": 0.24750000000000016, "test_spectral_ops": 31.861499999999953, "test_stateless": 9.623999999999999, "test_subclass": 0.7815000000000002, "test_sympy_utils": 28.779, "test_tensor_creation_ops": 142.13599999999946, "test_tensorboard": 47.167500000000004, "test_tensorexpr": 212.12150000000003, "test_tensorexpr_pybind": 1.4230000000000005, "test_testing": 62.574999999999875, "test_torch": 227.9974999999996, "test_transformers": 238.60900000000896, "test_type_hints": 0.42699999999999994, "test_type_info": 0.4465, "test_type_promotion": 15.15949999999996, "test_typing": 131.68949999999995, "test_unary_ufuncs": 882.0534999999168, "test_utils": 51.77450000000074, "test_view_ops": 31.60099999999999, "test_vulkan": 0.0015, "test_weak": 7.014499999999999, "test_xnnpack_integration": 9.2845, "torch_np/numpy_tests/core/test_dlpack": 0.0105, "torch_np/numpy_tests/core/test_dtype": 0.7125000000000001, "torch_np/numpy_tests/core/test_einsum": 28.4315, "torch_np/numpy_tests/core/test_getlimits": 0.48150000000000004, "torch_np/numpy_tests/core/test_indexing": 0.7530000000000002, "torch_np/numpy_tests/core/test_multiarray": 61.32250000000002, "torch_np/numpy_tests/core/test_numeric": 8.4645, "torch_np/numpy_tests/core/test_numerictypes": 0.4620000000000001, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6295000000000002, "torch_np/numpy_tests/core/test_scalar_methods": 0.019000000000000003, "torch_np/numpy_tests/core/test_scalarinherit": 0.0015, "torch_np/numpy_tests/core/test_scalarmath": 53.2485, "torch_np/numpy_tests/core/test_shape_base": 0.9010000000000002, "torch_np/numpy_tests/fft/test_helper": 12.4805, "torch_np/numpy_tests/fft/test_pocketfft": 6.6335, "torch_np/numpy_tests/lib/test_arraypad": 0.47850000000000004, "torch_np/numpy_tests/lib/test_arraysetops": 0.6965, "torch_np/numpy_tests/lib/test_function_base": 3.6734999999999998, "torch_np/numpy_tests/lib/test_histograms": 0.9795000000000003, "torch_np/numpy_tests/lib/test_index_tricks": 0.6280000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 1.3320000000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.8715000000000002, "torch_np/numpy_tests/lib/test_type_check": 0.667, "torch_np/numpy_tests/linalg/test_linalg": 9.5405, "torch_np/test_basic": 1.6440000000000006, "torch_np/test_binary_ufuncs": 0.6495000000000002, "torch_np/test_dtype": 0.5815000000000001, "torch_np/test_function_base": 0.44199999999999995, "torch_np/test_ndarray_methods": 5.026500000000001, "torch_np/test_nep50_examples": 0.12000000000000006, "torch_np/test_random": 0.5845000000000001, "torch_np/test_reductions": 4.457499999999956, "torch_np/test_scalars_0D_arrays": 0.5175000000000001, "torch_np/test_ufuncs_basic": 1.9945000000000008, "torch_np/test_unary_ufuncs": 0.6805000000000002}}, "linux-focal-cuda11.8-py3.9-gcc9": {"multigpu": {"distributed/_composable/fsdp/test_fully_shard_training": 32.27, "distributed/_shard/sharded_tensor/test_sharded_tensor": 547.1310000000001, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": 13.440999999999999, "distributed/_shard/sharding_plan/test_sharding_plan": 20.512999999999998, "distributed/_shard/sharding_spec/test_sharding_spec": 24.902500000000003, "distributed/_tensor/test_device_mesh": 69.701, "distributed/_tensor/test_dtensor_compile": 47.855999999999995, "distributed/_tensor/test_random_ops": 46.36150000000001, "distributed/checkpoint/test_checkpoint": 47.284499999999994, "distributed/checkpoint/test_file_system_checkpoint": 29.399, "distributed/fsdp/test_checkpoint_wrapper": 0.782, "distributed/fsdp/test_distributed_checkpoint": 0.367, "distributed/fsdp/test_fsdp_apply": 18.451499999999996, "distributed/fsdp/test_fsdp_backward_prefetch": 8.887, "distributed/fsdp/test_fsdp_checkpoint": 117.398, "distributed/fsdp/test_fsdp_clip_grad_norm": 44.6565, "distributed/fsdp/test_fsdp_comm": 67.7795, "distributed/fsdp/test_fsdp_comm_hooks": 188.52850000000004, "distributed/fsdp/test_fsdp_core": 1491.1529999999998, "distributed/fsdp/test_fsdp_dtensor_state_dict": 103.25450000000001, "distributed/fsdp/test_fsdp_exec_order": 54.149, "distributed/fsdp/test_fsdp_fine_tune": 33.975, "distributed/fsdp/test_fsdp_flatten_params": 59.13249999999999, "distributed/fsdp/test_fsdp_freezing_weights": 227.06349999999998, "distributed/fsdp/test_fsdp_fx": 0.3845, "distributed/fsdp/test_fsdp_grad_acc": 50.209, "distributed/fsdp/test_fsdp_hybrid_shard": 80.8675, "distributed/fsdp/test_fsdp_ignored_modules": 78.184, "distributed/fsdp/test_fsdp_input": 10.9875, "distributed/fsdp/test_fsdp_memory": 13.384500000000001, "distributed/fsdp/test_fsdp_meta": 47.623000000000005, "distributed/fsdp/test_fsdp_misc": 82.42050000000002, "distributed/fsdp/test_fsdp_mixed_precision": 398.03350000000023, "distributed/fsdp/test_fsdp_multiple_forward": 6.984, "distributed/fsdp/test_fsdp_multiple_wrapping": 7.1305, "distributed/fsdp/test_fsdp_optim_state": 456.76149999999996, "distributed/fsdp/test_fsdp_overlap": 76.116, "distributed/fsdp/test_fsdp_pure_fp16": 14.091999999999999, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 142.83100000000002, "distributed/fsdp/test_fsdp_state_dict": 1047.2489999999998, "distributed/fsdp/test_fsdp_tp_integration": 37.082499999999996, "distributed/fsdp/test_fsdp_traversal": 5.978, "distributed/fsdp/test_fsdp_uneven": 7.0785, "distributed/fsdp/test_fsdp_unshard_params": 89.91000000000001, "distributed/fsdp/test_fsdp_use_orig_params": 299.643, "distributed/fsdp/test_hsdp_dtensor_state_dict": 72.15950000000001, "distributed/fsdp/test_shard_utils": 11.729000000000001, "distributed/fsdp/test_utils": 0.6244999999999999, "distributed/fsdp/test_wrap": 166.453, "distributed/pipelining/test_composability": 32.416000000000004, "distributed/rpc/cuda/test_tensorpipe_agent": 831.5845000000002, "distributed/tensor/parallel/test_ddp_2d_parallel": 8.777, "distributed/tensor/parallel/test_fsdp_2d_parallel": 98.33549999999998, "distributed/tensor/parallel/test_tp_examples": 48.370000000000005, "distributed/tensor/parallel/test_tp_random_state": 8.52, "distributed/test_c10d_common": 118.6005, "distributed/test_c10d_functional_native": 131.88, "distributed/test_c10d_gloo": 618.058, "distributed/test_c10d_nccl": 1098.3979999999997, "distributed/test_c10d_spawn_gloo": 41.1115, "distributed/test_c10d_spawn_nccl": 48.952, "distributed/test_cuda_p2p": 0.0, "distributed/test_device_mesh": 207.38150000000002, "distributed/test_functional_api": 106.84499999999998, "distributed/test_pg_wrapper": 101.9345, "distributed/test_store": 90.8385, "test_cuda_multigpu": 8.5405, "test_cuda_primary_ctx": 1.4955, "test_foreach": 0.709, "test_optim": 13.627499999999998}}, "linux-focal-cuda12.1-py3-gcc9-slow-gradcheck": {"default": {"backends/xeon/test_launch": 1.679, "benchmark_utils/test_benchmark_utils": 1.5759999999999998, "distributions/test_distributions": 73.388, "dynamo/test_activation_checkpointing": 14.322999999999999, "dynamo/test_after_aot": 4.753, "dynamo/test_allow_inline_skip": 0.889, "dynamo/test_aot_autograd": 11.775000000000002, "dynamo/test_aot_autograd_cache": 0.9540000000000001, "dynamo/test_autograd_function": 4.5200000000000005, "dynamo/test_backends": 11.530999999999999, "dynamo/test_backward_higher_order_ops": 10.413, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_hook": 4.562, "dynamo/test_bytecode_utils": 4.655, "dynamo/test_compile": 5.294, "dynamo/test_comptime": 0.5740000000000001, "dynamo/test_config": 0.5569999999999999, "dynamo/test_cpp_guard_manager": 111.9390000000001, "dynamo/test_ctx_manager": 2.8949999999999996, "dynamo/test_cudagraphs": 3.2859999999999996, "dynamo/test_debug_utils": 0.435, "dynamo/test_decorators": 0.6520000000000001, "dynamo/test_deviceguard": 0.026, "dynamo/test_dynamic_shapes": 414.4330000000001, "dynamo/test_exc": 1.768, "dynamo/test_exceptions": 0.53, "dynamo/test_export": 13.564999999999998, "dynamo/test_export_mutations": 0.547, "dynamo/test_frame_init": 0.212, "dynamo/test_functions": 26.639000000000006, "dynamo/test_fx_passes_pre_grad": 1.047, "dynamo/test_global": 0.53, "dynamo/test_guard_manager": 0.24600000000000002, "dynamo/test_higher_order_ops": 22.2, "dynamo/test_hooks": 22.76900000000001, "dynamo/test_inline_inbuilt_nn_modules": 113.4200000000001, "dynamo/test_input_attr_tracking": 6.433999999999999, "dynamo/test_interop": 0.5680000000000001, "dynamo/test_logging": 15.925999999999997, "dynamo/test_minifier": 2.1130000000000004, "dynamo/test_misc": 46.68500000000006, "dynamo/test_model_output": 0.001, "dynamo/test_modules": 15.141999999999998, "dynamo/test_nops": 0.298, "dynamo/test_optimizers": 0.619, "dynamo/test_pre_dispatch": 0.48700000000000004, "dynamo/test_profiler": 1.3119999999999998, "dynamo/test_python_autograd": 0.629, "dynamo/test_recompiles": 0.8070000000000002, "dynamo/test_reorder_logs": 0.517, "dynamo/test_replay_record": 0.7033333333333335, "dynamo/test_repros": 41.45399999999997, "dynamo/test_resume": 0.443, "dynamo/test_sdpa": 0.48300000000000004, "dynamo/test_skip_non_tensor": 0.55, "dynamo/test_sources": 0.484, "dynamo/test_structured_trace": 13.127, "dynamo/test_subclasses": 15.476999999999999, "dynamo/test_subgraphs": 1.956999999999999, "dynamo/test_trace_rules": 1.246, "dynamo/test_triton_kernels": 66.961, "dynamo/test_unspec": 10.123000000000001, "dynamo/test_verify_correctness": 0.5790000000000001, "dynamo/test_view": 0.635, "export/test_converter": 4.515000000000001, "export/test_db": 2.6399999999999992, "export/test_experimental": 0.887, "export/test_export": 24.66199999999998, "export/test_export_nonstrict": 21.944000000000003, "export/test_export_predispatch": 23.048999999999992, "export/test_functionalized_assertions": 0.22, "export/test_funtionalized_assertions": 0.5933333333333333, "export/test_hop": 5.199000000000001, "export/test_lift_unlift": 0.105, "export/test_pass_infra": 0.8330000000000002, "export/test_passes": 10.570999999999998, "export/test_retraceability": 35.52799999999999, "export/test_safeguard": 0.672, "export/test_schema": 0.253, "export/test_serdes": 23.609999999999985, "export/test_serialize": 8.294000000000002, "export/test_sparse": 49.07499999999992, "export/test_tools": 0.543, "export/test_torchbind": 2.4139999999999997, "export/test_tree_utils": 0.217, "export/test_unflatten": 2.6950000000000003, "export/test_upgrade": 0.392, "export/test_verifier": 0.8570000000000001, "functorch/test_ac": 11.712, "functorch/test_aotdispatch": 27.988999999999997, "functorch/test_control_flow": 92.91300000000008, "functorch/test_dims": 25.842999999999996, "functorch/test_eager_transforms": 10.284000000000002, "functorch/test_logging": 0.261, "functorch/test_memory_efficient_fusion": 7.595, "functorch/test_minifier": 0.3930000000000001, "functorch/test_ops": 3680.6069999999836, "functorch/test_parsing": 0.229, "functorch/test_rearrange": 0.257, "functorch/test_vmap": 365.30499999999967, "functorch/test_vmap_registrations": 1.9459999999998994, "higher_order_ops/test_with_effects": 4.584, "inductor/test_aot_inductor": 5990.23, "inductor/test_benchmark_fusion": 95.228, "inductor/test_binary_folding": 35.155, "inductor/test_codecache": 124.50099999999998, "inductor/test_codegen_triton": 0.19, "inductor/test_compile_worker": 5.433, "inductor/test_compiled_autograd": 417.3640000000003, "inductor/test_compiled_optimizers": 1873.813, "inductor/test_config": 5.224000000000001, "inductor/test_control_flow": 117.48899999999999, "inductor/test_coordinate_descent_tuner": 2.847, "inductor/test_cpp_wrapper": 2082.4314999999997, "inductor/test_cpu_repro": 556.1499999999999, "inductor/test_cuda_cpp_wrapper": 1918.1219999999998, "inductor/test_cuda_repro": 88.722, "inductor/test_cudagraph_trees": 67.702, "inductor/test_custom_lowering": 2.8089999999999997, "inductor/test_custom_post_grad_passes": 9.871, "inductor/test_cutlass_backend": 50.878, "inductor/test_debug_trace": 12.391, "inductor/test_decompose_mem_bound_mm": 29.328, "inductor/test_dependencies": 0.18000000000000002, "inductor/test_distributed_patterns": 34.1, "inductor/test_efficient_conv_bn_eval": 0.002, "inductor/test_extension_backend": 16.035, "inductor/test_flex_attention": 499.5060000000001, "inductor/test_foreach": 276.5130000000001, "inductor/test_fp8": 0.008, "inductor/test_fused_attention": 203.584, "inductor/test_fx_fusion": 0.188, "inductor/test_graph_transform_observer": 0.013, "inductor/test_group_batch_fusion": 77.54899999999999, "inductor/test_indexing": 2.518, "inductor/test_inductor_freezing": 74.104, "inductor/test_inplacing_pass": 5.019, "inductor/test_kernel_benchmark": 138.888, "inductor/test_layout_optim": 10.548000000000004, "inductor/test_loop_ordering": 3.356, "inductor/test_max_autotune": 298.43, "inductor/test_memory_planning": 26.956999999999997, "inductor/test_metrics": 3.3350000000000004, "inductor/test_minifier": 27.051, "inductor/test_minifier_isolate": 87.97200000000001, "inductor/test_mkldnn_pattern_matcher": 454.23599999999976, "inductor/test_mmdecomp": 6.119000000000002, "inductor/test_move_constructors_to_cuda": 13.804999999999998, "inductor/test_multi_kernel": 66.75099999999999, "inductor/test_pad_mm": 119.25, "inductor/test_padding": 13.441, "inductor/test_pattern_matcher": 92.932, "inductor/test_perf": 58.42200000000001, "inductor/test_profiler": 5.6739999999999995, "inductor/test_select_algorithm": 105.534, "inductor/test_snode_runtime": 8.695999999999998, "inductor/test_split_cat_fx_passes": 93.015, "inductor/test_standalone_compile": 17.349, "inductor/test_storage_offset": 0.999, "inductor/test_templated_attention": 53.747, "inductor/test_torchbind": 5.978, "inductor/test_torchinductor": 2393.1489999999994, "inductor/test_torchinductor_codegen_dynamic_shapes": 2299.879, "inductor/test_torchinductor_dynamic_shapes": 2905.6769999999997, "inductor/test_torchinductor_opinfo": 1537.9019999999962, "inductor/test_triton_extension_backend": 0.514, "inductor/test_triton_heuristics": 3.934, "inductor/test_triton_kernels": 84.08199999999998, "inductor/test_triton_wrapper": 8.09, "inductor/test_unbacked_symints": 16.360000000000003, "inductor/test_utils": 0.222, "lazy/test_debug_util": 0.27, "lazy/test_functionalization": 0.27, "lazy/test_generator": 0.273, "lazy/test_reuse_ir": 0.42200000000000004, "lazy/test_step_closures": 2.2129999999999996, "lazy/test_ts_opinfo": 0.22200000000000003, "nn/test_convolution": 1659.753999999999, "nn/test_dropout": 0.547, "nn/test_embedding": 10.065000000000008, "nn/test_init": 3.504999999999999, "nn/test_lazy_modules": 0.42800000000000005, "nn/test_load_state_dict": 0.5520000000000002, "nn/test_module_hooks": 0.17200000000000004, "nn/test_multihead_attention": 4.117999999999999, "nn/test_packed_sequence": 0.498, "nn/test_parametrization": 0.9240000000000002, "nn/test_pooling": 5.432999999999998, "nn/test_pruning": 0.07400000000000004, "profiler/test_execution_trace": 2.3310000000000004, "profiler/test_memory_profiler": 4.045000000000001, "profiler/test_profiler": 26.017999999999997, "profiler/test_profiler_tree": 0.43100000000000005, "profiler/test_record_function": 0.278, "profiler/test_torch_tidy": 3.6949999999999985, "test_ao_sparsity": 7.777000000000001, "test_autocast": 1.7419999999999995, "test_autograd": 50.827, "test_autograd_fallback": 0.32000000000000006, "test_binary_ufuncs": 156.17199999999815, "test_bundled_inputs": 0.8880000000000001, "test_comparison_utils": 0.215, "test_compile_benchmark_util": 0.0, "test_complex": 0.08600000000000002, "test_content_store": 2.689, "test_cpp_api_parity": 8.078999999999997, "test_cpp_extensions_aot_ninja": 0.321, "test_cpp_extensions_aot_no_ninja": 0.29600000000000004, "test_cpp_extensions_mtia_backend": 0.001, "test_cpp_extensions_open_device_registration": 6.171000000000001, "test_cpp_extensions_stream_and_event": 0.0, "test_cuda": 83.01600000000003, "test_cuda_expandable_segments": 94.57399999999996, "test_cuda_multigpu": 0.503, "test_cuda_nvml_based_avail": 0.28200000000000003, "test_cuda_primary_ctx": 0.003, "test_cuda_sanitizer": 0.43000000000000005, "test_cuda_trace": 1.7520000000000002, "test_custom_backend": 0.074, "test_custom_ops": 6.9969999999999954, "test_dataloader": 173.786, "test_datapipe": 8.453999999999999, "test_deploy": 0.222, "test_dispatch": 33.57700000000002, "test_dlpack": 0.2880000000000002, "test_dynamic_shapes": 4.207999999999995, "test_expanded_weights": 15.425000000000002, "test_fake_tensor": 16.84300000000001, "test_flop_counter": 1.7510000000000001, "test_foreach": 614.6230000000028, "test_function_schema": 0.478, "test_functional_autograd_benchmark": 15.065, "test_functional_optim": 0.28600000000000003, "test_functionalization": 3.391999999999999, "test_functionalization_of_rng_ops": 2.056, "test_futures": 0.853, "test_fx_experimental": 12.171000000000001, "test_fx_passes": 0.37500000000000017, "test_fx_reinplace_pass": 0.3550000000000001, "test_import_stats": 3.161, "test_indexing": 1.117, "test_itt": 0.219, "test_jit_autocast": 19.253999999999998, "test_jit_cuda_fuser": 997.358000000001, "test_jit_disabled": 0.30800000000000005, "test_jit_fuser_te": 581.1049999999993, "test_jit_llga_fuser": 0.062, "test_jiterator": 18.86900000000002, "test_legacy_vmap": 1.7510000000000003, "test_license": 0.22, "test_linalg": 264.09100000000035, "test_logging": 2.227, "test_masked": 26.584000000000014, "test_maskedtensor": 70.0190000000002, "test_matmul_cuda": 70.338, "test_mkl_verbose": 3.174, "test_mkldnn": 41.928000000000004, "test_mkldnn_fusion": 28.149, "test_mkldnn_verbose": 3.105, "test_mobile_optimizer": 2.6069999999999998, "test_model_dump": 0.8009999999999999, "test_model_exports_to_core_aten": 0.212, "test_module_init": 2.445499999999985, "test_module_tracker": 0.223, "test_modules": 2151.5149999999953, "test_monitor": 0.327, "test_multiprocessing": 92.315, "test_multiprocessing_spawn": 24.24, "test_namedtensor": 0.6890000000000001, "test_namedtuple_return_api": 1.547, "test_native_functions": 0.31600000000000006, "test_native_mha": 0.5440000000000003, "test_nestedtensor": 25.765000000000008, "test_nn": 580.5020000000015, "test_numba_integration": 0.252, "test_numpy_interop": 0.13500000000000006, "test_nvfuser_frontend": 2.7270000000000003, "test_openmp": 3.496, "test_ops_fwd_gradients": 6618.807999999975, "test_ops_gradients": 6792.8069999999325, "test_optim": 175.49999999999957, "test_out_dtype_op": 0.457, "test_overrides": 1.8629999999999265, "test_package": 1.9049999999999991, "test_per_overload_api": 0.222, "test_prims": 0.333, "test_proxy_tensor": 19.559, "test_pruning_op": 0.37, "test_public_bindings": 4.642, "test_python_dispatch": 2.675, "test_pytree": 0.3730000000000001, "test_reductions": 115.89999999999962, "test_scatter_gather_ops": 11.188, "test_schema_check": 830.7209999999952, "test_segment_reductions": 2.7949999999999995, "test_serialization": 21.602999999999994, "test_set_default_mobile_cpu_allocator": 0.221, "test_shape_ops": 1.070999999999999, "test_show_pickle": 0.222, "test_sort_and_select": 3.628999999999996, "test_sparse": 846.080000000001, "test_sparse_csr": 1228.8060000000025, "test_sparse_semi_structured": 27.66999999999999, "test_spectral_ops": 20.510999999999992, "test_stateless": 4.518, "test_subclass": 0.3560000000000001, "test_sympy_utils": 12.222, "test_tensor_creation_ops": 79.15599999999961, "test_tensorboard": 20.07, "test_tensorexpr": 112.88800000000003, "test_tensorexpr_pybind": 0.5560000000000002, "test_testing": 28.631000000000018, "test_torch": 86.73799999999994, "test_transformers": 2557.8439999995103, "test_type_hints": 0.215, "test_type_info": 0.227, "test_type_promotion": 7.240999999999964, "test_typing": 56.766999999999975, "test_unary_ufuncs": 411.3049999998, "test_utils": 24.431000000000633, "test_view_ops": 13.450000000000003, "test_vulkan": 0.0, "test_weak": 3.468999999999999, "test_xnnpack_integration": 7.102999999999999, "torch_np/numpy_tests/core/test_dlpack": 0.001, "torch_np/numpy_tests/core/test_dtype": 0.329, "torch_np/numpy_tests/core/test_einsum": 11.262, "torch_np/numpy_tests/core/test_getlimits": 0.234, "torch_np/numpy_tests/core/test_indexing": 0.3630000000000001, "torch_np/numpy_tests/core/test_multiarray": 25.101000000000006, "torch_np/numpy_tests/core/test_numeric": 3.621, "torch_np/numpy_tests/core/test_numerictypes": 0.24700000000000003, "torch_np/numpy_tests/core/test_scalar_ctors": 0.28200000000000003, "torch_np/numpy_tests/core/test_scalar_methods": 0.001, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 20.199999999999996, "torch_np/numpy_tests/core/test_shape_base": 0.41700000000000015, "torch_np/numpy_tests/fft/test_helper": 5.193999999999999, "torch_np/numpy_tests/fft/test_pocketfft": 2.642, "torch_np/numpy_tests/lib/test_arraypad": 0.23, "torch_np/numpy_tests/lib/test_arraysetops": 0.341, "torch_np/numpy_tests/lib/test_function_base": 1.489, "torch_np/numpy_tests/lib/test_histograms": 0.43700000000000006, "torch_np/numpy_tests/lib/test_index_tricks": 0.29100000000000004, "torch_np/numpy_tests/lib/test_shape_base_": 0.562, "torch_np/numpy_tests/lib/test_twodim_base": 0.40400000000000014, "torch_np/numpy_tests/lib/test_type_check": 0.31000000000000005, "torch_np/numpy_tests/linalg/test_linalg": 3.8530000000000006, "torch_np/test_basic": 0.7720000000000004, "torch_np/test_binary_ufuncs": 0.31600000000000006, "torch_np/test_dtype": 0.261, "torch_np/test_function_base": 0.221, "torch_np/test_ndarray_methods": 2.082000000000001, "torch_np/test_nep50_examples": 0.012, "torch_np/test_random": 0.272, "torch_np/test_reductions": 2.0949999999999607, "torch_np/test_scalars_0D_arrays": 0.266, "torch_np/test_ufuncs_basic": 0.7920000000000004, "torch_np/test_unary_ufuncs": 0.30700000000000005}}, "linux-focal-cuda12.1-py3.10-gcc9": {"default": {"backends/xeon/test_launch": 2.382, "benchmark_utils/test_benchmark_utils": 2.0820000000000003, "distributions/test_distributions": 82.69966666666666, "dynamo/test_activation_checkpointing": 0.5613333333333334, "dynamo/test_after_aot": 6.5569999999999995, "dynamo/test_allow_inline_skip": 0.82, "dynamo/test_aot_autograd": 13.021666666666667, "dynamo/test_aot_autograd_cache": 19.408666666666665, "dynamo/test_autograd_function": 3.5473333333333326, "dynamo/test_backends": 17.215666666666667, "dynamo/test_backward_higher_order_ops": 15.176666666666668, "dynamo/test_base_output": 0.006000000000000001, "dynamo/test_bytecode_hook": 6.466, "dynamo/test_bytecode_utils": 6.5683333333333325, "dynamo/test_compile": 8.189666666666668, "dynamo/test_comptime": 0.6830000000000002, "dynamo/test_config": 0.6723333333333334, "dynamo/test_cpp_guard_manager": 172.3366666666668, "dynamo/test_ctx_manager": 2.5096666666666656, "dynamo/test_cudagraphs": 4.281333333333333, "dynamo/test_debug_utils": 0.30433333333333334, "dynamo/test_decorators": 7.258666666666666, "dynamo/test_deviceguard": 0.023999999999999997, "dynamo/test_dynamic_shapes": 786.218, "dynamo/test_exc": 2.5163333333333333, "dynamo/test_exceptions": 0.6100000000000001, "dynamo/test_export": 20.804666666666662, "dynamo/test_export_mutations": 0.6750000000000002, "dynamo/test_frame_init": 0.2793333333333333, "dynamo/test_functions": 28.975000000000012, "dynamo/test_fx_passes_pre_grad": 1.5756666666666668, "dynamo/test_global": 0.5986666666666668, "dynamo/test_guard_manager": 0.3303333333333334, "dynamo/test_higher_order_ops": 30.723000000000003, "dynamo/test_hooks": 33.40100000000001, "dynamo/test_inline_inbuilt_nn_modules": 151.3580000000002, "dynamo/test_input_attr_tracking": 8.934666666666665, "dynamo/test_interop": 0.6443333333333333, "dynamo/test_logging": 20.643666666666675, "dynamo/test_minifier": 3.1199999999999997, "dynamo/test_misc": 71.45833333333347, "dynamo/test_model_output": 0.016000000000000007, "dynamo/test_modules": 26.665666666666663, "dynamo/test_nops": 0.3746666666666667, "dynamo/test_optimizers": 0.7413333333333334, "dynamo/test_pre_dispatch": 0.5566666666666666, "dynamo/test_profiler": 1.6116666666666666, "dynamo/test_python_autograd": 0.7606666666666668, "dynamo/test_recompile_ux": 1.0786666666666669, "dynamo/test_recompiles": 1.0546666666666666, "dynamo/test_reorder_logs": 0.5996666666666667, "dynamo/test_replay_record": 1.132, "dynamo/test_repros": 65.62100000000005, "dynamo/test_resume": 0.502, "dynamo/test_sdpa": 0.5540000000000002, "dynamo/test_skip_non_tensor": 0.6816666666666666, "dynamo/test_sources": 0.5666666666666667, "dynamo/test_structured_trace": 15.680666666666665, "dynamo/test_subclasses": 19.848333333333333, "dynamo/test_subgraphs": 2.986666666666666, "dynamo/test_trace_rules": 1.5486666666666664, "dynamo/test_triton_kernels": 0.38933333333333353, "dynamo/test_unspec": 15.862999999999998, "dynamo/test_verify_correctness": 0.7220000000000001, "dynamo/test_view": 0.7583333333333333, "export/test_converter": 9.783333333333333, "export/test_db": 4.041333333333333, "export/test_experimental": 1.1876666666666666, "export/test_export": 35.20433333333333, "export/test_export_nonstrict": 32.90566666666667, "export/test_export_predispatch": 35.34466666666666, "export/test_functionalized_assertions": 0.30033333333333334, "export/test_funtionalized_assertions": 0.851, "export/test_hop": 3.706666666666667, "export/test_lift_unlift": 0.12966666666666668, "export/test_pass_infra": 1.1256666666666668, "export/test_passes": 17.684, "export/test_retraceability": 56.76233333333332, "export/test_safeguard": 1.279, "export/test_schema": 0.32566666666666666, "export/test_serdes": 37.01266666666668, "export/test_serialize": 12.589333333333334, "export/test_sparse": 82.2583333333333, "export/test_tools": 0.645, "export/test_torchbind": 4.253666666666666, "export/test_tree_utils": 0.28833333333333333, "export/test_unflatten": 4.162, "export/test_upgrade": 0.5283333333333333, "export/test_verifier": 1.1896666666666667, "functorch/test_aotdispatch": 46.67866666666668, "functorch/test_control_flow": 149.52300000000005, "functorch/test_dims": 31.32100000000001, "functorch/test_eager_transforms": 13.729333333333335, "functorch/test_logging": 0.3466666666666667, "functorch/test_memory_efficient_fusion": 9.980333333333332, "functorch/test_minifier": 0.544, "functorch/test_ops": 5886.814333333343, "functorch/test_parsing": 0.33233333333333337, "functorch/test_rearrange": 0.38500000000000006, "functorch/test_vmap": 432.68466666666495, "functorch/test_vmap_registrations": 2.8023333333331983, "higher_order_ops/test_with_effects": 9.025333333333332, "inductor/test_benchmark_fusion": 12.267666666666665, "inductor/test_binary_folding": 51.99766666666667, "inductor/test_codecache": 56.51966666666663, "inductor/test_codegen_triton": 0.30633333333333335, "inductor/test_compile_worker": 15.548333333333334, "inductor/test_compiled_autograd": 677.9036666666675, "inductor/test_compiled_optimizers": 329.2349999999999, "inductor/test_config": 8.474999999999998, "inductor/test_control_flow": 0.052000000000000025, "inductor/test_cpp_wrapper": 1985.626, "inductor/test_cpu_repro": 876.0816666666666, "inductor/test_custom_lowering": 0.0030000000000000005, "inductor/test_custom_post_grad_passes": 15.346666666666666, "inductor/test_debug_trace": 4.590000000000001, "inductor/test_decompose_mem_bound_mm": 0.005666666666666667, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 51.41400000000001, "inductor/test_efficient_conv_bn_eval": 86.69233333333331, "inductor/test_extension_backend": 24.370666666666665, "inductor/test_flex_attention": 0.10200000000000008, "inductor/test_foreach": 24.368000000000194, "inductor/test_fused_attention": 210.83866666666668, "inductor/test_fx_fusion": 0.279, "inductor/test_graph_transform_observer": 0.01833333333333333, "inductor/test_group_batch_fusion": 0.3633333333333333, "inductor/test_indexing": 0.7309999999999999, "inductor/test_inductor_freezing": 67.52433333333333, "inductor/test_memory_planning": 0.002, "inductor/test_metrics": 0.335, "inductor/test_minifier": 32.75633333333334, "inductor/test_minifier_isolate": 64.902, "inductor/test_mkldnn_pattern_matcher": 733.0130000000003, "inductor/test_mmdecomp": 0.022333333333333344, "inductor/test_profiler": 0.005, "inductor/test_standalone_compile": 24.548666666666666, "inductor/test_templated_attention": 0.048000000000000036, "inductor/test_torchbind": 8.533333333333333, "inductor/test_torchinductor": 2193.9343333333327, "inductor/test_torchinductor_codegen_dynamic_shapes": 2132.7553333333326, "inductor/test_torchinductor_dynamic_shapes": 2233.141666666666, "inductor/test_torchinductor_opinfo": 18.156666666666677, "inductor/test_triton_extension_backend": 2.248666666666667, "inductor/test_triton_kernels": 0.17133333333333345, "inductor/test_utils": 0.2793333333333333, "lazy/test_debug_util": 0.37266666666666665, "lazy/test_functionalization": 0.3713333333333333, "lazy/test_generator": 0.379, "lazy/test_reuse_ir": 0.6266666666666666, "lazy/test_step_closures": 2.294333333333333, "lazy/test_ts_opinfo": 0.38266666666666665, "nn/test_convolution": 47.50600000000005, "nn/test_dropout": 2.0283333333333338, "nn/test_embedding": 18.212999999999983, "nn/test_init": 4.679333333333332, "nn/test_lazy_modules": 0.41566666666666685, "nn/test_load_state_dict": 0.8903333333333333, "nn/test_module_hooks": 0.26566666666666666, "nn/test_multihead_attention": 7.125999999999999, "nn/test_packed_sequence": 0.5543333333333335, "nn/test_parametrization": 1.3253333333333321, "nn/test_pooling": 12.00233333333333, "nn/test_pruning": 0.12400000000000007, "profiler/test_execution_trace": 0.21000000000000005, "profiler/test_memory_profiler": 5.771000000000001, "profiler/test_profiler": 31.011666666666667, "profiler/test_profiler_tree": 0.4753333333333334, "profiler/test_record_function": 0.36866666666666664, "profiler/test_torch_tidy": 3.945666666666666, "test_ao_sparsity": 13.735666666666667, "test_autocast": 2.0653333333333332, "test_autograd": 43.61199999999994, "test_autograd_fallback": 0.4726666666666668, "test_binary_ufuncs": 162.36833333333448, "test_bundled_inputs": 1.338666666666666, "test_comparison_utils": 0.2976666666666667, "test_compile_benchmark_util": 0.001, "test_complex": 0.14800000000000002, "test_content_store": 0.14300000000000002, "test_cpp_api_parity": 12.283666666666614, "test_cpp_extensions_aot_ninja": 0.3206666666666667, "test_cpp_extensions_aot_no_ninja": 0.3106666666666667, "test_cpp_extensions_jit": 140.85466666666665, "test_cpp_extensions_mtia_backend": 0.005, "test_cpp_extensions_open_device_registration": 9.731666666666671, "test_cpp_extensions_stream_and_event": 0.001, "test_cuda": 123.7726666666667, "test_cuda_expandable_segments": 128.84400000000002, "test_cuda_multigpu": 0.6960000000000001, "test_cuda_nvml_based_avail": 0.3273333333333333, "test_cuda_primary_ctx": 0.0030000000000000005, "test_cuda_sanitizer": 0.4040000000000001, "test_cuda_trace": 1.2519999999999998, "test_custom_backend": 0.12466666666666666, "test_custom_ops": 10.911666666666662, "test_dataloader": 282.02366666666666, "test_datapipe": 13.39133333333333, "test_decomp": 13974.792666666683, "test_deploy": 0.29633333333333334, "test_dispatch": 41.50633333333334, "test_dlpack": 0.3900000000000003, "test_dynamic_shapes": 6.566666666666657, "test_expanded_weights": 19.552666666666664, "test_fake_tensor": 30.92466666666668, "test_flop_counter": 0.506, "test_foreach": 255.59233333334103, "test_function_schema": 0.7233333333333333, "test_functional_autograd_benchmark": 21.57133333333333, "test_functional_optim": 0.43, "test_functionalization": 5.4789999999999965, "test_functionalization_of_rng_ops": 3.3049999999999997, "test_futures": 0.9336666666666668, "test_fx": 317.88466666666665, "test_fx_experimental": 19.435666666666638, "test_fx_passes": 0.784666666666667, "test_fx_reinplace_pass": 0.5643333333333335, "test_import_stats": 4.597333333333333, "test_indexing": 2.215333333333332, "test_itt": 0.31033333333333335, "test_jit": 177.12633333333338, "test_jit_autocast": 35.40699999999999, "test_jit_cuda_fuser": 276.24500000000035, "test_jit_disabled": 0.46166666666666667, "test_jit_fuser_te": 962.1170000000008, "test_jit_llga_fuser": 0.09200000000000001, "test_jiterator": 25.751666666666598, "test_legacy_vmap": 3.0066666666666664, "test_license": 0.2913333333333333, "test_linalg": 1031.1063333333313, "test_logging": 3.33, "test_masked": 40.12600000000001, "test_maskedtensor": 8.995666666666622, "test_matmul_cuda": 47.653, "test_meta": 2916.9889999998773, "test_mkl_verbose": 4.9606666666666674, "test_mkldnn": 69.01933333333331, "test_mkldnn_fusion": 42.54, "test_mkldnn_verbose": 4.558333333333334, "test_mobile_optimizer": 3.3656666666666664, "test_model_dump": 1.3096666666666668, "test_model_exports_to_core_aten": 0.18666666666666668, "test_module_init": 2.0239999999999982, "test_module_tracker": 0.30533333333333335, "test_modules": 956.6853333333241, "test_monitor": 0.451, "test_multiprocessing": 116.94333333333333, "test_multiprocessing_spawn": 36.90800000000001, "test_namedtensor": 1.0606666666666669, "test_namedtuple_return_api": 2.225, "test_native_functions": 0.4280000000000001, "test_native_mha": 0.8810000000000006, "test_nestedtensor": 4.947999999999996, "test_nn": 207.82799999999767, "test_numba_integration": 0.19366666666666668, "test_numpy_interop": 0.33200000000000013, "test_nvfuser_frontend": 0.002, "test_openmp": 4.748666666666666, "test_ops": 6519.150333333301, "test_ops_fwd_gradients": 1448.5390000000007, "test_ops_gradients": 2361.109666666712, "test_ops_jit": 1364.3463333333311, "test_optim": 535.4133333333319, "test_out_dtype_op": 0.401, "test_overrides": 3.4533333333332066, "test_package": 2.863333333333332, "test_per_overload_api": 0.313, "test_prims": 0.5340000000000001, "test_proxy_tensor": 33.585, "test_pruning_op": 0.538, "test_public_bindings": 6.504666666666666, "test_python_dispatch": 2.307, "test_pytree": 0.5266666666666668, "test_quantization": 3488.700666666667, "test_reductions": 139.88566666666011, "test_scatter_gather_ops": 19.708000000000002, "test_schema_check": 342.11133333332435, "test_segment_reductions": 3.364999999999998, "test_serialization": 39.56700000000001, "test_set_default_mobile_cpu_allocator": 0.302, "test_shape_ops": 1.6083333333333323, "test_show_pickle": 0.34400000000000003, "test_sort_and_select": 6.543666666666663, "test_sparse": 880.8719999999994, "test_sparse_csr": 377.79866666666686, "test_sparse_semi_structured": 0.16400000000000012, "test_spectral_ops": 25.616999999999994, "test_stateless": 6.5633333333333335, "test_subclass": 0.5136666666666668, "test_sympy_utils": 18.951999999999998, "test_tensor_creation_ops": 111.09799999999963, "test_tensorboard": 32.23566666666667, "test_tensorexpr": 139.249, "test_tensorexpr_pybind": 0.9846666666666669, "test_testing": 43.79399999999989, "test_torch": 149.03233333333336, "test_transformers": 167.04233333333036, "test_type_hints": 0.3076666666666667, "test_type_info": 0.307, "test_type_promotion": 10.206999999999997, "test_typing": 91.05966666666664, "test_unary_ufuncs": 493.33433333331317, "test_utils": 36.04200000000049, "test_view_ops": 22.424333333333333, "test_vulkan": 0.001, "test_weak": 5.071666666666665, "test_xnnpack_integration": 28.305333333333333, "torch_np/numpy_tests/core/test_dlpack": 0.010000000000000002, "torch_np/numpy_tests/core/test_dtype": 0.49433333333333335, "torch_np/numpy_tests/core/test_einsum": 19.94666666666667, "torch_np/numpy_tests/core/test_getlimits": 0.33266666666666667, "torch_np/numpy_tests/core/test_indexing": 0.48900000000000016, "torch_np/numpy_tests/core/test_multiarray": 42.58066666666668, "torch_np/numpy_tests/core/test_numeric": 5.647666666666666, "torch_np/numpy_tests/core/test_numerictypes": 0.39000000000000007, "torch_np/numpy_tests/core/test_scalar_ctors": 0.4396666666666668, "torch_np/numpy_tests/core/test_scalar_methods": 0.017333333333333336, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 35.081, "torch_np/numpy_tests/core/test_shape_base": 0.6090000000000002, "torch_np/numpy_tests/fft/test_helper": 8.689333333333332, "torch_np/numpy_tests/fft/test_pocketfft": 4.381666666666667, "torch_np/numpy_tests/lib/test_arraypad": 0.35500000000000004, "torch_np/numpy_tests/lib/test_arraysetops": 0.541, "torch_np/numpy_tests/lib/test_function_base": 2.449333333333334, "torch_np/numpy_tests/lib/test_histograms": 0.6983333333333336, "torch_np/numpy_tests/lib/test_index_tricks": 0.4123333333333334, "torch_np/numpy_tests/lib/test_shape_base_": 0.9093333333333335, "torch_np/numpy_tests/lib/test_twodim_base": 0.6156666666666668, "torch_np/numpy_tests/lib/test_type_check": 0.4436666666666667, "torch_np/numpy_tests/linalg/test_linalg": 6.610333333333333, "torch_np/test_basic": 1.1193333333333337, "torch_np/test_binary_ufuncs": 0.4353333333333334, "torch_np/test_dtype": 0.3803333333333334, "torch_np/test_function_base": 0.3256666666666667, "torch_np/test_ndarray_methods": 3.539666666666666, "torch_np/test_nep50_examples": 0.07900000000000004, "torch_np/test_random": 0.39100000000000007, "torch_np/test_reductions": 3.2783333333332965, "torch_np/test_scalars_0D_arrays": 0.3783333333333334, "torch_np/test_ufuncs_basic": 1.3196666666666672, "torch_np/test_unary_ufuncs": 0.4926666666666668}, "jit_legacy": {"test_jit_fuser_legacy": 0.0105, "test_jit_legacy": 201.09500000000006}, "nogpu_AVX512": {"backends/xeon/test_launch": 2.6435, "benchmark_utils/test_benchmark_utils": 0.782, "distributions/test_distributions": 89.53600000000002, "dynamo/test_activation_checkpointing": 0.801, "dynamo/test_after_aot": 10.5125, "dynamo/test_allow_inline_skip": 1.132, "dynamo/test_aot_autograd": 19.669, "dynamo/test_aot_autograd_cache": 9.7195, "dynamo/test_autograd_function": 4.137, "dynamo/test_backends": 21.131, "dynamo/test_backward_higher_order_ops": 18.503, "dynamo/test_base_output": 0.0035, "dynamo/test_bytecode_hook": 6.319, "dynamo/test_bytecode_utils": 9.6975, "dynamo/test_compile": 10.7915, "dynamo/test_comptime": 0.9625000000000001, "dynamo/test_config": 0.8940000000000001, "dynamo/test_cpp_guard_manager": 115.22200000000008, "dynamo/test_ctx_manager": 1.9315000000000007, "dynamo/test_debug_utils": 0.382, "dynamo/test_decorators": 10.3265, "dynamo/test_deviceguard": 0.024, "dynamo/test_dynamic_shapes": 637.8115, "dynamo/test_exc": 2.8655, "dynamo/test_exceptions": 0.8390000000000001, "dynamo/test_export": 21.7895, "dynamo/test_export_mutations": 0.8675000000000002, "dynamo/test_frame_init": 0.337, "dynamo/test_functions": 34.52350000000006, "dynamo/test_fx_passes_pre_grad": 1.6885, "dynamo/test_global": 0.8240000000000001, "dynamo/test_guard_manager": 0.391, "dynamo/test_higher_order_ops": 27.708999999999996, "dynamo/test_hooks": 37.256500000000024, "dynamo/test_inline_inbuilt_nn_modules": 116.74500000000006, "dynamo/test_input_attr_tracking": 12.1985, "dynamo/test_interop": 0.8895, "dynamo/test_logging": 25.216500000000003, "dynamo/test_minifier": 2.0459999999999994, "dynamo/test_misc": 84.29250000000012, "dynamo/test_model_output": 0.006500000000000001, "dynamo/test_modules": 28.260999999999996, "dynamo/test_nops": 0.46799999999999997, "dynamo/test_optimizers": 0.9855, "dynamo/test_pre_dispatch": 0.7635000000000001, "dynamo/test_profiler": 1.8639999999999997, "dynamo/test_python_autograd": 0.9970000000000001, "dynamo/test_recompile_ux": 1.2795000000000003, "dynamo/test_recompiles": 1.2825000000000002, "dynamo/test_reorder_logs": 0.8400000000000001, "dynamo/test_replay_record": 0.8130000000000001, "dynamo/test_repros": 50.63799999999999, "dynamo/test_resume": 0.739, "dynamo/test_sdpa": 0.784, "dynamo/test_skip_non_tensor": 0.89, "dynamo/test_sources": 0.7675000000000001, "dynamo/test_structured_trace": 17.290499999999998, "dynamo/test_subclasses": 21.215999999999998, "dynamo/test_subgraphs": 3.2529999999999983, "dynamo/test_trace_rules": 1.9, "dynamo/test_triton_kernels": 0.058333333333333355, "dynamo/test_unspec": 19.787499999999994, "dynamo/test_verify_correctness": 0.9339999999999999, "dynamo/test_view": 0.9885, "export/test_converter": 7.380000000000001, "export/test_db": 4.454499999999999, "export/test_experimental": 1.4244999999999999, "export/test_export": 43.3625, "export/test_export_nonstrict": 36.42150000000001, "export/test_export_predispatch": 26.744666666666664, "export/test_functionalized_assertions": 0.34900000000000003, "export/test_funtionalized_assertions": 0.6623333333333333, "export/test_hop": 0.0045000000000000005, "export/test_lift_unlift": 0.14, "export/test_pass_infra": 1.3285000000000002, "export/test_passes": 17.890000000000004, "export/test_retraceability": 68.069, "export/test_safeguard": 0.9423333333333334, "export/test_schema": 0.4115, "export/test_serdes": 44.617999999999995, "export/test_serialize": 13.343500000000006, "export/test_sparse": 84.51149999999986, "export/test_tools": 0.841, "export/test_torchbind": 4.0535, "export/test_tree_utils": 0.34099999999999997, "export/test_unflatten": 4.5005, "export/test_upgrade": 0.42100000000000004, "export/test_verifier": 1.3520000000000003, "functorch/test_aotdispatch": 42.450499999999984, "functorch/test_control_flow": 157.54199999999994, "functorch/test_dims": 43.4885, "functorch/test_eager_transforms": 0.15950000000000003, "functorch/test_logging": 0.3945, "functorch/test_memory_efficient_fusion": 0.978, "functorch/test_minifier": 0.621, "functorch/test_parsing": 0.36250000000000004, "functorch/test_rearrange": 0.42450000000000004, "functorch/test_vmap": 4.630499999999991, "functorch/test_vmap_registrations": 3.6054999999998336, "higher_order_ops/test_with_effects": 9.517, "inductor/test_benchmark_fusion": 13.252500000000001, "inductor/test_binary_folding": 52.87949999999999, "inductor/test_codecache": 62.741499999999995, "inductor/test_codegen_triton": 0.34, "inductor/test_compile_worker": 11.4375, "inductor/test_compiled_autograd": 681.9950000000003, "inductor/test_compiled_optimizers": 342.64050000000066, "inductor/test_config": 9.113, "inductor/test_control_flow": 0.11900000000000001, "inductor/test_cpp_wrapper": 1195.2479999999998, "inductor/test_cpu_repro": 941.2394999999999, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 15.8995, "inductor/test_debug_trace": 4.942, "inductor/test_decompose_mem_bound_mm": 0.002, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 52.758500000000005, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 27.283, "inductor/test_flex_attention": 0.021000000000000008, "inductor/test_foreach": 25.056000000000026, "inductor/test_fused_attention": 216.56049999999996, "inductor/test_fx_fusion": 0.2885, "inductor/test_graph_transform_observer": 0.0205, "inductor/test_group_batch_fusion": 0.3085, "inductor/test_indexing": 0.9285000000000001, "inductor/test_inductor_freezing": 76.92600000000002, "inductor/test_memory_planning": 0.0, "inductor/test_metrics": 0.214, "inductor/test_minifier": 35.184000000000005, "inductor/test_minifier_isolate": 68.187, "inductor/test_mkldnn_pattern_matcher": 1006.5440000000002, "inductor/test_profiler": 0.0033333333333333335, "inductor/test_standalone_compile": 24.488500000000002, "inductor/test_templated_attention": 0.021333333333333343, "inductor/test_torchbind": 14.026, "inductor/test_torchinductor": 2160.9344999999994, "inductor/test_torchinductor_codegen_dynamic_shapes": 2088.2109999999993, "inductor/test_torchinductor_dynamic_shapes": 2207.2584999999985, "inductor/test_triton_extension_backend": 0.863, "inductor/test_triton_kernels": 0.03850000000000002, "inductor/test_utils": 0.3405, "lazy/test_debug_util": 0.40800000000000003, "lazy/test_functionalization": 0.42800000000000005, "lazy/test_generator": 0.4305, "lazy/test_reuse_ir": 0.776, "lazy/test_step_closures": 3.3375, "lazy/test_ts_opinfo": 0.3575, "nn/test_convolution": 21.135500000000004, "nn/test_dropout": 0.15100000000000002, "nn/test_embedding": 0.06850000000000003, "nn/test_init": 5.604999999999999, "nn/test_lazy_modules": 0.5470000000000002, "nn/test_load_state_dict": 0.8725, "nn/test_module_hooks": 0.2825, "nn/test_multihead_attention": 6.893999999999999, "nn/test_packed_sequence": 0.5955000000000001, "nn/test_parametrization": 1.1240000000000003, "nn/test_pooling": 0.8345, "nn/test_pruning": 0.14000000000000007, "profiler/test_execution_trace": 0.15749999999999997, "profiler/test_memory_profiler": 7.042, "profiler/test_profiler": 27.671, "profiler/test_profiler_tree": 0.4600000000000001, "profiler/test_record_function": 0.4035, "profiler/test_torch_tidy": 5.920499999999999, "test_ao_sparsity": 9.356999999999998, "test_autocast": 1.5675, "test_autograd": 38.613500000000045, "test_autograd_fallback": 0.5140000000000001, "test_bundled_inputs": 1.593, "test_comparison_utils": 0.37350000000000005, "test_compile_benchmark_util": 0.0015, "test_cpp_api_parity": 4.875999999999983, "test_cpp_extensions_aot_ninja": 0.051000000000000004, "test_cpp_extensions_aot_no_ninja": 0.054000000000000006, "test_cpp_extensions_jit": 60.436, "test_cpp_extensions_mtia_backend": 1.056, "test_cpp_extensions_open_device_registration": 12.055, "test_cpp_extensions_stream_and_event": 1.085, "test_custom_backend": 0.10999999999999999, "test_custom_ops": 9.431499999999991, "test_dataloader": 254.77400000000011, "test_datapipe": 16.068999999999996, "test_decomp": 0.22649999999999998, "test_deploy": 0.343, "test_dispatch": 41.884499999999996, "test_dynamic_shapes": 6.299499999999993, "test_fake_tensor": 2.9725, "test_flop_counter": 0.5955, "test_function_schema": 0.7364999999999999, "test_functional_autograd_benchmark": 42.219500000000004, "test_functional_optim": 0.5005000000000002, "test_functionalization": 6.820999999999997, "test_futures": 1.3035, "test_fx": 356.9975000000001, "test_fx_experimental": 21.134000000000004, "test_fx_passes": 0.9625000000000004, "test_fx_reinplace_pass": 0.5895000000000001, "test_import_stats": 5.069, "test_itt": 0.3425, "test_jit": 154.5075, "test_jit_autocast": 23.693499999999997, "test_jit_cuda_fuser": 0.02500000000000001, "test_jit_disabled": 0.4810000000000001, "test_jit_fuser_te": 181.4320000000001, "test_jit_llga_fuser": 3.3224999999999993, "test_legacy_vmap": 2.458, "test_license": 0.369, "test_logging": 3.5650000000000004, "test_maskedtensor": 0.8945000000000006, "test_meta": 0.07000000000000003, "test_mkl_verbose": 6.102, "test_mkldnn": 88.4883333333333, "test_mkldnn_fusion": 82.81550000000001, "test_mkldnn_verbose": 5.204, "test_mobile_optimizer": 3.8644999999999996, "test_model_dump": 1.25, "test_model_exports_to_core_aten": 0.28500000000000003, "test_module_tracker": 0.34500000000000003, "test_monitor": 0.6015, "test_multiprocessing": 68.6405, "test_multiprocessing_spawn": 38.623000000000005, "test_namedtensor": 0.42700000000000016, "test_namedtuple_return_api": 2.5149999999999997, "test_native_functions": 0.4850000000000001, "test_nestedtensor": 0.1725000000000001, "test_nn": 55.82449999999996, "test_numba_integration": 0.0045000000000000005, "test_nvfuser_frontend": 0.0, "test_openmp": 6.71, "test_ops": 0.0045000000000000005, "test_optim": 1.7650000000000006, "test_out_dtype_op": 0.41200000000000003, "test_overrides": 2.808499999999891, "test_package": 3.248499999999998, "test_per_overload_api": 0.35550000000000004, "test_prims": 0.018500000000000003, "test_proxy_tensor": 32.9095, "test_pruning_op": 0.5995, "test_public_bindings": 7.749499999999999, "test_python_dispatch": 0.6180000000000001, "test_pytree": 0.5905000000000002, "test_quantization": 2266.5820000000003, "test_schema_check": 0.14250000000000007, "test_serialization": 52.28250000000001, "test_set_default_mobile_cpu_allocator": 0.348, "test_show_pickle": 0.402, "test_sparse": 4.883499999999998, "test_sparse_csr": 0.65, "test_sparse_semi_structured": 0.0045000000000000005, "test_stateless": 7.7725, "test_subclass": 0.6175000000000002, "test_sympy_utils": 19.820999999999998, "test_tensorboard": 38.601, "test_tensorexpr": 68.87000000000002, "test_tensorexpr_pybind": 1.1855000000000002, "test_testing": 33.7725, "test_torch": 6.570999999999987, "test_type_hints": 0.3775, "test_type_info": 0.35350000000000004, "test_typing": 103.13950000000006, "test_utils": 17.338, "test_vulkan": 0.003, "test_weak": 5.6789999999999985, "test_xnnpack_integration": 12.1115, "torch_np/numpy_tests/core/test_dlpack": 0.003, "torch_np/numpy_tests/core/test_dtype": 0.5145000000000001, "torch_np/numpy_tests/core/test_einsum": 19.171000000000006, "torch_np/numpy_tests/core/test_getlimits": 0.37550000000000006, "torch_np/numpy_tests/core/test_indexing": 0.5700000000000002, "torch_np/numpy_tests/core/test_multiarray": 36.22500000000001, "torch_np/numpy_tests/core/test_numeric": 5.7065, "torch_np/numpy_tests/core/test_numerictypes": 0.385, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6355000000000002, "torch_np/numpy_tests/core/test_scalar_methods": 0.004, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 30.893999999999995, "torch_np/numpy_tests/core/test_shape_base": 0.6860000000000003, "torch_np/numpy_tests/fft/test_helper": 7.3255, "torch_np/numpy_tests/fft/test_pocketfft": 4.847499999999999, "torch_np/numpy_tests/lib/test_arraypad": 0.36850000000000005, "torch_np/numpy_tests/lib/test_arraysetops": 0.5405, "torch_np/numpy_tests/lib/test_function_base": 2.417, "torch_np/numpy_tests/lib/test_histograms": 0.7220000000000002, "torch_np/numpy_tests/lib/test_index_tricks": 0.4585000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.8620000000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.6205, "torch_np/numpy_tests/lib/test_type_check": 0.548, "torch_np/numpy_tests/linalg/test_linalg": 5.920000000000002, "torch_np/test_basic": 0.7400000000000004, "torch_np/test_binary_ufuncs": 0.5045000000000002, "torch_np/test_dtype": 0.43800000000000006, "torch_np/test_function_base": 0.352, "torch_np/test_ndarray_methods": 3.439000000000002, "torch_np/test_nep50_examples": 0.027999999999999997, "torch_np/test_random": 0.42450000000000004, "torch_np/test_reductions": 3.249499999999937, "torch_np/test_scalars_0D_arrays": 0.44100000000000006, "torch_np/test_ufuncs_basic": 1.3800000000000006, "torch_np/test_unary_ufuncs": 0.5455000000000001}, "nogpu_NO_AVX2": {"backends/xeon/test_launch": 2.7584999999999997, "benchmark_utils/test_benchmark_utils": 0.8705, "distributions/test_distributions": 91.53150000000002, "dynamo/test_activation_checkpointing": 0.8280000000000001, "dynamo/test_after_aot": 10.2545, "dynamo/test_allow_inline_skip": 1.1363333333333332, "dynamo/test_aot_autograd": 20.2345, "dynamo/test_aot_autograd_cache": 9.4715, "dynamo/test_autograd_function": 4.224999999999999, "dynamo/test_backends": 21.3205, "dynamo/test_backward_higher_order_ops": 19.131999999999998, "dynamo/test_base_output": 0.0045000000000000005, "dynamo/test_bytecode_hook": 6.724666666666667, "dynamo/test_bytecode_utils": 10.0725, "dynamo/test_compile": 11.244499999999999, "dynamo/test_comptime": 0.9365000000000001, "dynamo/test_config": 0.9305, "dynamo/test_cpp_guard_manager": 118.28933333333337, "dynamo/test_ctx_manager": 1.9945, "dynamo/test_debug_utils": 0.3835, "dynamo/test_decorators": 10.8875, "dynamo/test_deviceguard": 0.0245, "dynamo/test_dynamic_shapes": 665.0815000000002, "dynamo/test_exc": 3.0, "dynamo/test_exceptions": 0.8795000000000002, "dynamo/test_export": 23.098999999999993, "dynamo/test_export_mutations": 0.8885000000000001, "dynamo/test_frame_init": 0.358, "dynamo/test_functions": 36.06600000000007, "dynamo/test_fx_passes_pre_grad": 1.777, "dynamo/test_global": 0.8610000000000001, "dynamo/test_guard_manager": 0.41300000000000003, "dynamo/test_higher_order_ops": 29.184999999999995, "dynamo/test_hooks": 38.929500000000004, "dynamo/test_inline_inbuilt_nn_modules": 120.47100000000009, "dynamo/test_input_attr_tracking": 12.7725, "dynamo/test_interop": 0.9125, "dynamo/test_logging": 27.075500000000005, "dynamo/test_minifier": 2.1134999999999993, "dynamo/test_misc": 82.35650000000014, "dynamo/test_model_output": 0.0075, "dynamo/test_modules": 28.8375, "dynamo/test_nops": 0.48950000000000005, "dynamo/test_optimizers": 1.0225, "dynamo/test_pre_dispatch": 0.794, "dynamo/test_profiler": 1.9209999999999998, "dynamo/test_python_autograd": 1.0395, "dynamo/test_recompile_ux": 1.286, "dynamo/test_recompiles": 1.367, "dynamo/test_reorder_logs": 0.8420000000000001, "dynamo/test_replay_record": 0.7673333333333335, "dynamo/test_repros": 56.55749999999999, "dynamo/test_resume": 0.7665, "dynamo/test_sdpa": 0.8065, "dynamo/test_skip_non_tensor": 0.8755000000000002, "dynamo/test_sources": 0.8160000000000001, "dynamo/test_structured_trace": 17.921499999999995, "dynamo/test_subclasses": 22.070999999999998, "dynamo/test_subgraphs": 3.448999999999998, "dynamo/test_trace_rules": 1.9614999999999998, "dynamo/test_triton_kernels": 0.04866666666666669, "dynamo/test_unspec": 21.370999999999995, "dynamo/test_verify_correctness": 0.9955, "dynamo/test_view": 1.017, "export/test_converter": 7.784500000000001, "export/test_db": 4.785500000000001, "export/test_experimental": 1.484, "export/test_export": 45.6245, "export/test_export_nonstrict": 38.54600000000001, "export/test_export_predispatch": 26.965000000000003, "export/test_functionalized_assertions": 0.3645, "export/test_funtionalized_assertions": 0.6793333333333335, "export/test_hop": 0.0045000000000000005, "export/test_lift_unlift": 0.14200000000000002, "export/test_pass_infra": 1.3470000000000002, "export/test_passes": 18.898500000000002, "export/test_retraceability": 67.59449999999997, "export/test_safeguard": 1.0043333333333333, "export/test_schema": 0.41600000000000004, "export/test_serdes": 49.307500000000005, "export/test_serialize": 13.741500000000004, "export/test_sparse": 90.0944999999999, "export/test_tools": 0.893, "export/test_torchbind": 4.2555, "export/test_tree_utils": 0.361, "export/test_unflatten": 4.6795, "export/test_upgrade": 0.44, "export/test_verifier": 1.4255000000000002, "functorch/test_aotdispatch": 44.832999999999984, "functorch/test_control_flow": 163.77249999999992, "functorch/test_dims": 45.646, "functorch/test_eager_transforms": 0.15950000000000003, "functorch/test_logging": 0.41600000000000004, "functorch/test_memory_efficient_fusion": 1.005, "functorch/test_minifier": 0.6559999999999999, "functorch/test_parsing": 0.379, "functorch/test_rearrange": 0.42900000000000005, "functorch/test_vmap": 4.695999999999992, "functorch/test_vmap_registrations": 3.4314999999998346, "higher_order_ops/test_with_effects": 10.0585, "inductor/test_benchmark_fusion": 14.152, "inductor/test_binary_folding": 55.283500000000004, "inductor/test_codecache": 65.17349999999999, "inductor/test_codegen_triton": 0.3595, "inductor/test_compile_worker": 12.003, "inductor/test_compiled_autograd": 707.3245, "inductor/test_compiled_optimizers": 354.28650000000073, "inductor/test_config": 9.464999999999998, "inductor/test_control_flow": 0.1275, "inductor/test_cpp_wrapper": 1631.14, "inductor/test_cpu_repro": 991.3620000000002, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 16.72, "inductor/test_debug_trace": 5.141, "inductor/test_decompose_mem_bound_mm": 0.003, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 54.140499999999996, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 28.676000000000002, "inductor/test_flex_attention": 0.020500000000000008, "inductor/test_foreach": 26.20300000000003, "inductor/test_fused_attention": 225.45549999999997, "inductor/test_fx_fusion": 0.29900000000000004, "inductor/test_graph_transform_observer": 0.0225, "inductor/test_group_batch_fusion": 0.3065, "inductor/test_indexing": 0.9555, "inductor/test_inductor_freezing": 81.28650000000002, "inductor/test_memory_planning": 0.0006666666666666666, "inductor/test_metrics": 0.217, "inductor/test_minifier": 37.069, "inductor/test_minifier_isolate": 71.77000000000001, "inductor/test_mkldnn_pattern_matcher": 1048.679, "inductor/test_profiler": 0.0023333333333333335, "inductor/test_standalone_compile": 25.5375, "inductor/test_templated_attention": 0.008, "inductor/test_torchbind": 14.697000000000001, "inductor/test_torchinductor": 2251.194999999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 2174.2854999999986, "inductor/test_torchinductor_dynamic_shapes": 2296.0030000000006, "inductor/test_triton_extension_backend": 0.8975, "inductor/test_triton_kernels": 0.03900000000000002, "inductor/test_utils": 0.3595, "lazy/test_debug_util": 0.4245, "lazy/test_functionalization": 0.428, "lazy/test_generator": 0.4325, "lazy/test_reuse_ir": 0.8340000000000001, "lazy/test_step_closures": 3.3804999999999996, "lazy/test_ts_opinfo": 0.3715, "nn/test_convolution": 21.015, "nn/test_dropout": 0.21400000000000002, "nn/test_embedding": 0.07200000000000004, "nn/test_init": 5.859499999999999, "nn/test_lazy_modules": 0.6075000000000003, "nn/test_load_state_dict": 0.9075000000000002, "nn/test_module_hooks": 0.28550000000000003, "nn/test_multihead_attention": 6.622999999999998, "nn/test_packed_sequence": 0.5705000000000001, "nn/test_parametrization": 1.2890000000000004, "nn/test_pooling": 0.8344999999999999, "nn/test_pruning": 0.14000000000000007, "profiler/test_execution_trace": 0.175, "profiler/test_memory_profiler": 6.873000000000001, "profiler/test_profiler": 31.754499999999993, "profiler/test_profiler_tree": 0.4690000000000001, "profiler/test_record_function": 0.44400000000000006, "profiler/test_torch_tidy": 6.384499999999999, "test_ao_sparsity": 9.886499999999998, "test_autocast": 3.2779999999999996, "test_autograd": 39.96150000000006, "test_autograd_fallback": 0.5085000000000002, "test_bundled_inputs": 2.5069999999999992, "test_comparison_utils": 0.371, "test_compile_benchmark_util": 0.0015, "test_cpp_api_parity": 5.065499999999987, "test_cpp_extensions_aot_ninja": 0.05250000000000002, "test_cpp_extensions_aot_no_ninja": 0.05450000000000001, "test_cpp_extensions_jit": 61.857, "test_cpp_extensions_mtia_backend": 1.1480000000000001, "test_cpp_extensions_open_device_registration": 12.199500000000004, "test_cpp_extensions_stream_and_event": 1.093, "test_custom_backend": 0.11449999999999999, "test_custom_ops": 9.732499999999991, "test_dataloader": 243.04350000000005, "test_datapipe": 16.759999999999998, "test_decomp": 0.23249999999999998, "test_deploy": 0.3925, "test_dispatch": 43.21149999999999, "test_dynamic_shapes": 6.690999999999993, "test_fake_tensor": 3.049, "test_flop_counter": 0.766, "test_function_schema": 0.9205000000000001, "test_functional_autograd_benchmark": 45.17400000000001, "test_functional_optim": 0.5115000000000001, "test_functionalization": 7.520499999999997, "test_futures": 1.3130000000000002, "test_fx": 419.2710000000001, "test_fx_experimental": 25.5805, "test_fx_passes": 1.0570000000000004, "test_fx_reinplace_pass": 0.6025000000000003, "test_import_stats": 5.2795, "test_itt": 0.371, "test_jit": 155.7875, "test_jit_autocast": 23.317500000000003, "test_jit_cuda_fuser": 0.02500000000000001, "test_jit_disabled": 0.4855000000000001, "test_jit_fuser_te": 194.88400000000001, "test_jit_llga_fuser": 3.738499999999999, "test_legacy_vmap": 2.4495, "test_license": 0.40549999999999997, "test_logging": 3.695, "test_maskedtensor": 0.9075000000000006, "test_meta": 0.07100000000000004, "test_mkl_verbose": 6.025, "test_mkldnn": 97.45433333333331, "test_mkldnn_fusion": 93.1035, "test_mkldnn_verbose": 5.366, "test_mobile_optimizer": 4.0945, "test_model_dump": 1.484, "test_model_exports_to_core_aten": 0.29800000000000004, "test_module_tracker": 0.3615, "test_monitor": 0.579, "test_multiprocessing": 68.4925, "test_multiprocessing_spawn": 39.637, "test_namedtensor": 0.5375000000000002, "test_namedtuple_return_api": 2.404, "test_native_functions": 0.5195000000000001, "test_nestedtensor": 0.19150000000000011, "test_nn": 65.9890000000001, "test_numba_integration": 0.005, "test_nvfuser_frontend": 0.0, "test_openmp": 6.3225, "test_ops": 0.0045000000000000005, "test_optim": 1.8415000000000008, "test_out_dtype_op": 0.42450000000000004, "test_overrides": 2.82549999999989, "test_package": 3.777499999999999, "test_per_overload_api": 0.3635, "test_prims": 0.019500000000000003, "test_proxy_tensor": 34.0535, "test_pruning_op": 0.6015, "test_public_bindings": 7.982499999999999, "test_python_dispatch": 0.6270000000000002, "test_pytree": 0.6200000000000002, "test_quantization": 2606.290000000001, "test_schema_check": 0.15550000000000008, "test_serialization": 73.88250000000005, "test_set_default_mobile_cpu_allocator": 0.3705, "test_show_pickle": 0.4, "test_sparse": 5.0009999999999994, "test_sparse_csr": 0.6515, "test_sparse_semi_structured": 0.0045000000000000005, "test_stateless": 8.1675, "test_subclass": 0.6255000000000002, "test_sympy_utils": 20.609499999999993, "test_tensorboard": 47.493, "test_tensorexpr": 70.93499999999997, "test_tensorexpr_pybind": 1.2840000000000003, "test_testing": 34.8645, "test_torch": 6.527999999999989, "test_type_hints": 0.3595, "test_type_info": 0.3925, "test_typing": 107.43750000000006, "test_utils": 18.045499999999997, "test_vulkan": 0.003, "test_weak": 5.949, "test_xnnpack_integration": 18.3255, "torch_np/numpy_tests/core/test_dlpack": 0.003, "torch_np/numpy_tests/core/test_dtype": 0.5455000000000001, "torch_np/numpy_tests/core/test_einsum": 19.5445, "torch_np/numpy_tests/core/test_getlimits": 0.419, "torch_np/numpy_tests/core/test_indexing": 0.5970000000000002, "torch_np/numpy_tests/core/test_multiarray": 37.209500000000006, "torch_np/numpy_tests/core/test_numeric": 5.8595, "torch_np/numpy_tests/core/test_numerictypes": 0.41550000000000004, "torch_np/numpy_tests/core/test_scalar_ctors": 0.4805000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.004, "torch_np/numpy_tests/core/test_scalarinherit": 0.0015, "torch_np/numpy_tests/core/test_scalarmath": 32.073, "torch_np/numpy_tests/core/test_shape_base": 0.7435000000000003, "torch_np/numpy_tests/fft/test_helper": 8.898, "torch_np/numpy_tests/fft/test_pocketfft": 4.955, "torch_np/numpy_tests/lib/test_arraypad": 0.3995, "torch_np/numpy_tests/lib/test_arraysetops": 0.6155, "torch_np/numpy_tests/lib/test_function_base": 2.49, "torch_np/numpy_tests/lib/test_histograms": 0.7285000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.48800000000000004, "torch_np/numpy_tests/lib/test_shape_base_": 0.9640000000000002, "torch_np/numpy_tests/lib/test_twodim_base": 0.6395000000000002, "torch_np/numpy_tests/lib/test_type_check": 0.6135000000000002, "torch_np/numpy_tests/linalg/test_linalg": 6.183000000000002, "torch_np/test_basic": 0.8035000000000005, "torch_np/test_binary_ufuncs": 0.5170000000000001, "torch_np/test_dtype": 0.43650000000000005, "torch_np/test_function_base": 0.36, "torch_np/test_ndarray_methods": 3.4715000000000016, "torch_np/test_nep50_examples": 0.024, "torch_np/test_random": 0.45000000000000007, "torch_np/test_reductions": 3.369499999999939, "torch_np/test_scalars_0D_arrays": 0.43750000000000006, "torch_np/test_ufuncs_basic": 1.5835000000000008, "torch_np/test_unary_ufuncs": 0.5485000000000002}}, "linux-focal-cuda12.1-py3.10-gcc9-experimental-split-build": {"default": {"backends/xeon/test_launch": 2.329333333333333, "benchmark_utils/test_benchmark_utils": 2.202, "distributions/test_distributions": 82.96300000000001, "dynamo/test_activation_checkpointing": 0.576, "dynamo/test_after_aot": 6.493333333333332, "dynamo/test_aot_autograd": 15.111666666666666, "dynamo/test_aot_autograd_cache": 19.51366666666667, "dynamo/test_autograd_function": 3.5919999999999987, "dynamo/test_backends": 16.598000000000003, "dynamo/test_backward_higher_order_ops": 14.948666666666663, "dynamo/test_base_output": 0.006000000000000001, "dynamo/test_bytecode_utils": 6.397666666666666, "dynamo/test_compile": 7.400333333333332, "dynamo/test_comptime": 0.6843333333333333, "dynamo/test_config": 0.6473333333333334, "dynamo/test_ctx_manager": 2.4079999999999995, "dynamo/test_cudagraphs": 4.189666666666667, "dynamo/test_debug_utils": 0.3096666666666667, "dynamo/test_decorators": 7.563666666666667, "dynamo/test_deviceguard": 0.023000000000000003, "dynamo/test_dynamic_shapes": 780.0233333333332, "dynamo/test_exc": 2.3480000000000003, "dynamo/test_exceptions": 0.5943333333333334, "dynamo/test_export": 20.092666666666663, "dynamo/test_export_mutations": 0.6536666666666667, "dynamo/test_frame_init": 0.2803333333333333, "dynamo/test_functions": 28.907333333333398, "dynamo/test_fx_passes_pre_grad": 1.5170000000000001, "dynamo/test_global": 0.5986666666666668, "dynamo/test_guard_manager": 0.3500000000000001, "dynamo/test_higher_order_ops": 29.971666666666675, "dynamo/test_hooks": 32.363000000000014, "dynamo/test_inline_inbuilt_nn_modules": 155.17066666666685, "dynamo/test_input_attr_tracking": 9.43, "dynamo/test_interop": 0.6313333333333333, "dynamo/test_logging": 20.117000000000004, "dynamo/test_minifier": 3.090666666666667, "dynamo/test_misc": 70.0176666666668, "dynamo/test_model_output": 0.016000000000000007, "dynamo/test_modules": 25.657999999999998, "dynamo/test_nops": 0.37399999999999994, "dynamo/test_optimizers": 0.7523333333333334, "dynamo/test_pre_dispatch": 0.5363333333333333, "dynamo/test_profiler": 1.5843333333333334, "dynamo/test_python_autograd": 0.7456666666666667, "dynamo/test_recompile_ux": 1.0750000000000002, "dynamo/test_recompiles": 1.0416666666666667, "dynamo/test_reorder_logs": 0.5933333333333334, "dynamo/test_repros": 63.66433333333338, "dynamo/test_resume": 0.4586666666666667, "dynamo/test_sdpa": 0.5420000000000001, "dynamo/test_skip_non_tensor": 0.6286666666666667, "dynamo/test_sources": 0.5343333333333334, "dynamo/test_structured_trace": 15.132333333333333, "dynamo/test_subclasses": 18.666666666666668, "dynamo/test_subgraphs": 2.841999999999999, "dynamo/test_trace_rules": 1.5943333333333332, "dynamo/test_unspec": 16.126666666666665, "dynamo/test_verify_correctness": 0.6680000000000001, "dynamo/test_view": 0.7526666666666667, "export/test_converter": 9.813333333333333, "export/test_db": 3.975333333333333, "export/test_experimental": 1.2116666666666667, "export/test_export": 34.486999999999995, "export/test_export_nonstrict": 32.446000000000005, "export/test_functionalized_assertions": 0.301, "export/test_hop": 3.703333333333333, "export/test_lift_unlift": 0.123, "export/test_pass_infra": 1.021, "export/test_passes": 16.767666666666667, "export/test_retraceability": 54.434666666666665, "export/test_schema": 0.3113333333333333, "export/test_serdes": 35.76566666666667, "export/test_serialize": 12.453666666666669, "export/test_sparse": 78.99733333333336, "export/test_tools": 0.6156666666666667, "export/test_torchbind": 4.282333333333333, "export/test_tree_utils": 0.2836666666666667, "export/test_unflatten": 3.888333333333333, "export/test_verifier": 1.1123333333333332, "functorch/test_aotdispatch": 46.782333333333334, "functorch/test_control_flow": 139.20433333333335, "functorch/test_dims": 29.418000000000003, "functorch/test_eager_transforms": 13.836, "functorch/test_logging": 0.3213333333333333, "functorch/test_memory_efficient_fusion": 9.839, "functorch/test_minifier": 0.5446666666666666, "functorch/test_ops": 5841.288666666663, "functorch/test_parsing": 0.317, "functorch/test_rearrange": 0.36900000000000005, "functorch/test_vmap": 415.94166666666575, "functorch/test_vmap_registrations": 3.03833333333318, "higher_order_ops/test_with_effects": 8.961333333333334, "inductor/test_benchmark_fusion": 11.901666666666669, "inductor/test_binary_folding": 50.53366666666667, "inductor/test_codecache": 56.82966666666664, "inductor/test_codegen_triton": 0.294, "inductor/test_compile_worker": 15.036000000000001, "inductor/test_compiled_autograd": 655.1646666666675, "inductor/test_compiled_optimizers": 333.8273333333339, "inductor/test_config": 8.268666666666666, "inductor/test_control_flow": 0.052000000000000025, "inductor/test_cpu_repro": 841.8276666666667, "inductor/test_custom_lowering": 0.0030000000000000005, "inductor/test_custom_post_grad_passes": 15.490666666666664, "inductor/test_debug_trace": 4.469333333333333, "inductor/test_decompose_mem_bound_mm": 0.004666666666666667, "inductor/test_distributed_patterns": 49.98466666666667, "inductor/test_efficient_conv_bn_eval": 88.17766666666665, "inductor/test_extension_backend": 24.335333333333335, "inductor/test_flex_attention": 0.10200000000000008, "inductor/test_foreach": 23.88366666666686, "inductor/test_fused_attention": 205.63866666666664, "inductor/test_fx_fusion": 0.259, "inductor/test_graph_transform_observer": 0.02266666666666667, "inductor/test_group_batch_fusion": 0.3406666666666667, "inductor/test_indexing": 0.7176666666666666, "inductor/test_inductor_freezing": 66.065, "inductor/test_minifier": 32.35733333333334, "inductor/test_minifier_isolate": 60.15800000000001, "inductor/test_mkldnn_pattern_matcher": 728.7216666666667, "inductor/test_mmdecomp": 0.02200000000000001, "inductor/test_standalone_compile": 24.362666666666666, "inductor/test_torchbind": 8.449333333333334, "inductor/test_torchinductor": 2135.1029999999996, "inductor/test_torchinductor_codegen_dynamic_shapes": 2110.500333333333, "inductor/test_torchinductor_dynamic_shapes": 2245.276, "inductor/test_torchinductor_opinfo": 19.46666666666661, "inductor/test_triton_extension_backend": 2.264, "inductor/test_triton_kernels": 0.17100000000000012, "inductor/test_utils": 0.28200000000000003, "lazy/test_debug_util": 0.4143333333333333, "lazy/test_functionalization": 0.35633333333333334, "lazy/test_generator": 0.35566666666666663, "lazy/test_reuse_ir": 0.5493333333333333, "lazy/test_step_closures": 2.2866666666666666, "lazy/test_ts_opinfo": 0.3086666666666667, "nn/test_convolution": 46.112333333333424, "nn/test_dropout": 2.076, "nn/test_embedding": 17.59233333333331, "nn/test_init": 4.474333333333333, "nn/test_lazy_modules": 0.40966666666666685, "nn/test_load_state_dict": 0.8273333333333334, "nn/test_module_hooks": 0.24933333333333332, "nn/test_multihead_attention": 6.464333333333332, "nn/test_packed_sequence": 0.5796666666666668, "nn/test_parametrization": 1.2556666666666665, "nn/test_pooling": 11.679666666666662, "nn/test_pruning": 0.12033333333333339, "profiler/test_execution_trace": 0.21366666666666667, "profiler/test_memory_profiler": 5.177, "profiler/test_profiler": 30.812333333333328, "profiler/test_profiler_tree": 0.41066666666666674, "profiler/test_record_function": 0.38233333333333336, "profiler/test_torch_tidy": 3.5996666666666663, "test_ao_sparsity": 13.282666666666666, "test_autocast": 2.049, "test_autograd": 41.05099999999995, "test_autograd_fallback": 0.4476666666666668, "test_binary_ufuncs": 170.17733333333672, "test_bundled_inputs": 1.3643333333333327, "test_comparison_utils": 0.30033333333333334, "test_compile_benchmark_util": 0.001, "test_complex": 0.13433333333333333, "test_content_store": 0.121, "test_cpp_api_parity": 12.148333333333284, "test_cpp_extensions_aot_ninja": 0.3013333333333334, "test_cpp_extensions_aot_no_ninja": 0.305, "test_cpp_extensions_jit": 137.01233333333332, "test_cpp_extensions_mtia_backend": 0.005, "test_cpp_extensions_open_device_registration": 9.282000000000005, "test_cpp_extensions_stream_and_event": 0.001, "test_cuda": 120.01533333333337, "test_cuda_expandable_segments": 124.29533333333335, "test_cuda_multigpu": 0.6933333333333334, "test_cuda_nvml_based_avail": 0.3076666666666667, "test_cuda_primary_ctx": 0.0030000000000000005, "test_cuda_sanitizer": 0.4320000000000001, "test_cuda_trace": 1.1743333333333332, "test_custom_backend": 0.11866666666666666, "test_custom_ops": 10.595999999999995, "test_dataloader": 274.66066666666666, "test_datapipe": 13.358333333333329, "test_decomp": 13864.681666666693, "test_deploy": 0.3236666666666667, "test_dispatch": 39.294333333333334, "test_dlpack": 0.3876666666666669, "test_dynamic_shapes": 6.407999999999991, "test_expanded_weights": 18.21433333333333, "test_fake_tensor": 30.300666666666675, "test_flop_counter": 0.49266666666666664, "test_foreach": 220.6070000000113, "test_function_schema": 0.6996666666666668, "test_functional_autograd_benchmark": 22.364666666666665, "test_functional_optim": 0.41133333333333333, "test_functionalization": 5.260333333333331, "test_functionalization_of_rng_ops": 3.3009999999999997, "test_futures": 0.9513333333333334, "test_fx": 314.23033333333325, "test_fx_experimental": 18.845666666666634, "test_fx_passes": 0.7473333333333336, "test_fx_reinplace_pass": 0.529, "test_import_stats": 4.552, "test_indexing": 2.2016666666666618, "test_itt": 0.2816666666666667, "test_jit": 171.35933333333335, "test_jit_autocast": 35.93, "test_jit_disabled": 0.435, "test_jit_fuser_te": 935.506, "test_jit_llga_fuser": 0.08700000000000001, "test_jiterator": 26.319333333333265, "test_legacy_vmap": 3.1366666666666663, "test_license": 0.30133333333333334, "test_linalg": 996.1766666666643, "test_logging": 3.078333333333333, "test_masked": 38.43366666666671, "test_maskedtensor": 8.681999999999936, "test_matmul_cuda": 49.02166666666667, "test_meta": 2858.8979999999187, "test_mkl_verbose": 4.938666666666667, "test_mkldnn_fusion": 43.17600000000001, "test_mkldnn_verbose": 4.502999999999999, "test_mobile_optimizer": 3.3173333333333335, "test_model_dump": 1.3916666666666666, "test_model_exports_to_core_aten": 0.18200000000000002, "test_module_tracker": 0.30000000000000004, "test_modules": 957.9746666666593, "test_monitor": 0.4746666666666666, "test_multiprocessing": 113.008, "test_multiprocessing_spawn": 35.515, "test_namedtensor": 0.9910000000000002, "test_namedtuple_return_api": 2.1486666666666667, "test_native_functions": 0.4190000000000001, "test_native_mha": 0.8393333333333338, "test_nestedtensor": 4.858333333333328, "test_nn": 202.58799999999792, "test_numba_integration": 0.16000000000000003, "test_numpy_interop": 0.19900000000000004, "test_openmp": 4.756, "test_ops": 6207.339333333318, "test_ops_fwd_gradients": 1422.5746666666862, "test_ops_gradients": 2278.344333333347, "test_ops_jit": 1334.9753333333313, "test_optim": 303.9560000000001, "test_out_dtype_op": 0.4096666666666667, "test_overrides": 3.4226666666665424, "test_package": 2.761333333333333, "test_per_overload_api": 0.30833333333333335, "test_prims": 0.4830000000000001, "test_proxy_tensor": 33.023, "test_pruning_op": 0.5303333333333334, "test_public_bindings": 6.2189999999999985, "test_python_dispatch": 2.2366666666666664, "test_pytree": 0.49600000000000005, "test_quantization": 3443.6100000000006, "test_reductions": 135.6783333333284, "test_scatter_gather_ops": 19.833666666666662, "test_schema_check": 349.9566666666586, "test_segment_reductions": 6.346, "test_serialization": 39.10766666666667, "test_set_default_mobile_cpu_allocator": 0.2863333333333334, "test_shape_ops": 1.6366666666666656, "test_show_pickle": 0.31666666666666665, "test_sort_and_select": 6.263333333333329, "test_sparse": 876.3366666666683, "test_sparse_csr": 371.53633333333397, "test_sparse_semi_structured": 0.16400000000000012, "test_spectral_ops": 24.789333333333328, "test_stateless": 6.6323333333333325, "test_subclass": 0.5473333333333334, "test_sympy_utils": 19.102, "test_tensor_creation_ops": 109.69999999999963, "test_tensorboard": 33.00800000000001, "test_tensorexpr": 138.08966666666666, "test_tensorexpr_pybind": 0.9543333333333335, "test_testing": 42.14799999999992, "test_torch": 145.99099999999996, "test_transformers": 165.68833333333305, "test_type_hints": 0.2776666666666667, "test_type_info": 0.2993333333333333, "test_type_promotion": 9.557, "test_typing": 86.69233333333331, "test_unary_ufuncs": 495.8859999999648, "test_utils": 35.65533333333383, "test_view_ops": 21.84099999999999, "test_vulkan": 0.001, "test_weak": 4.7573333333333325, "test_xnnpack_integration": 27.136, "torch_np/numpy_tests/core/test_dlpack": 0.007333333333333333, "torch_np/numpy_tests/core/test_dtype": 0.46766666666666673, "torch_np/numpy_tests/core/test_einsum": 19.38366666666667, "torch_np/numpy_tests/core/test_getlimits": 0.31833333333333336, "torch_np/numpy_tests/core/test_indexing": 0.5086666666666668, "torch_np/numpy_tests/core/test_multiarray": 41.08766666666668, "torch_np/numpy_tests/core/test_numeric": 5.563333333333333, "torch_np/numpy_tests/core/test_numerictypes": 0.3380000000000001, "torch_np/numpy_tests/core/test_scalar_ctors": 0.3950000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.017, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 36.458, "torch_np/numpy_tests/core/test_shape_base": 0.6153333333333335, "torch_np/numpy_tests/fft/test_helper": 8.655333333333333, "torch_np/numpy_tests/fft/test_pocketfft": 4.405333333333332, "torch_np/numpy_tests/lib/test_arraypad": 0.323, "torch_np/numpy_tests/lib/test_arraysetops": 0.4853333333333334, "torch_np/numpy_tests/lib/test_function_base": 2.4016666666666673, "torch_np/numpy_tests/lib/test_histograms": 0.67, "torch_np/numpy_tests/lib/test_index_tricks": 0.40866666666666673, "torch_np/numpy_tests/lib/test_shape_base_": 0.8626666666666668, "torch_np/numpy_tests/lib/test_twodim_base": 0.5913333333333334, "torch_np/numpy_tests/lib/test_type_check": 0.4253333333333334, "torch_np/numpy_tests/linalg/test_linalg": 6.550333333333334, "torch_np/test_basic": 1.1210000000000004, "torch_np/test_binary_ufuncs": 0.4433333333333334, "torch_np/test_dtype": 0.36533333333333334, "torch_np/test_function_base": 0.3273333333333333, "torch_np/test_ndarray_methods": 3.491666666666666, "torch_np/test_nep50_examples": 0.07633333333333338, "torch_np/test_random": 0.36100000000000004, "torch_np/test_reductions": 3.1523333333332997, "torch_np/test_scalars_0D_arrays": 0.3520000000000001, "torch_np/test_ufuncs_basic": 1.318333333333334, "torch_np/test_unary_ufuncs": 0.4483333333333335}}, "linux-focal-cuda12.1-py3.10-gcc9-sm86": {"default": {"backends/xeon/test_launch": 1.7026666666666668, "benchmark_utils/test_benchmark_utils": 1.8359999999999996, "distributions/test_distributions": 68.25766666666668, "dynamo/test_activation_checkpointing": 13.370000000000003, "dynamo/test_after_aot": 4.798333333333333, "dynamo/test_allow_inline_skip": 0.9650000000000002, "dynamo/test_aot_autograd": 10.485000000000001, "dynamo/test_aot_autograd_cache": 14.540000000000001, "dynamo/test_autograd_function": 4.085, "dynamo/test_backends": 12.033333333333333, "dynamo/test_backward_higher_order_ops": 10.564333333333332, "dynamo/test_base_output": 0.0016666666666666668, "dynamo/test_bytecode_hook": 4.674333333333333, "dynamo/test_bytecode_utils": 4.669999999999999, "dynamo/test_compile": 5.405666666666666, "dynamo/test_comptime": 0.48833333333333345, "dynamo/test_config": 0.47800000000000004, "dynamo/test_cpp_guard_manager": 117.34466666666674, "dynamo/test_ctx_manager": 2.782999999999999, "dynamo/test_cudagraphs": 3.353666666666667, "dynamo/test_debug_utils": 0.30833333333333335, "dynamo/test_decorators": 5.243666666666666, "dynamo/test_deviceguard": 0.015333333333333332, "dynamo/test_dynamic_shapes": 427.4930000000001, "dynamo/test_exc": 1.684333333333333, "dynamo/test_exceptions": 0.4403333333333334, "dynamo/test_export": 14.035333333333336, "dynamo/test_export_mutations": 0.458, "dynamo/test_frame_init": 0.21033333333333334, "dynamo/test_functions": 32.35266666666669, "dynamo/test_fx_passes_pre_grad": 1.1283333333333332, "dynamo/test_global": 0.4370000000000001, "dynamo/test_guard_manager": 0.2316666666666667, "dynamo/test_higher_order_ops": 25.423333333333332, "dynamo/test_hooks": 23.842333333333343, "dynamo/test_inline_inbuilt_nn_modules": 97.71266666666673, "dynamo/test_input_attr_tracking": 6.580333333333333, "dynamo/test_interop": 0.47633333333333333, "dynamo/test_logging": 16.740333333333332, "dynamo/test_minifier": 2.0356666666666667, "dynamo/test_misc": 49.93900000000008, "dynamo/test_model_output": 0.0030000000000000005, "dynamo/test_modules": 17.813666666666663, "dynamo/test_nops": 0.2786666666666667, "dynamo/test_optimizers": 0.537, "dynamo/test_pre_dispatch": 0.3913333333333333, "dynamo/test_profiler": 1.1276666666666666, "dynamo/test_python_autograd": 0.5386666666666667, "dynamo/test_recompile_ux": 0.7306666666666669, "dynamo/test_recompiles": 0.7393333333333333, "dynamo/test_reorder_logs": 0.4363333333333334, "dynamo/test_replay_record": 0.7450000000000001, "dynamo/test_repros": 43.382666666666665, "dynamo/test_resume": 0.35200000000000004, "dynamo/test_sdpa": 0.391, "dynamo/test_skip_non_tensor": 0.46433333333333343, "dynamo/test_sources": 0.4716666666666666, "dynamo/test_structured_trace": 14.078000000000001, "dynamo/test_subclasses": 16.797666666666668, "dynamo/test_subgraphs": 1.9409999999999992, "dynamo/test_trace_rules": 1.1579999999999997, "dynamo/test_triton_kernels": 69.466, "dynamo/test_unspec": 10.653333333333334, "dynamo/test_verify_correctness": 0.4773333333333334, "dynamo/test_view": 0.5369999999999999, "export/test_converter": 6.3723333333333345, "export/test_db": 2.858, "export/test_experimental": 0.8220000000000001, "export/test_export": 24.013333333333335, "export/test_export_nonstrict": 22.394333333333332, "export/test_export_predispatch": 23.851, "export/test_functionalized_assertions": 0.211, "export/test_funtionalized_assertions": 0.6066666666666666, "export/test_hop": 2.399666666666666, "export/test_lift_unlift": 0.08533333333333333, "export/test_pass_infra": 0.7193333333333335, "export/test_passes": 10.959333333333332, "export/test_retraceability": 35.937999999999995, "export/test_safeguard": 0.8446666666666668, "export/test_schema": 0.239, "export/test_serdes": 24.78833333333333, "export/test_serialize": 8.58, "export/test_sparse": 54.36533333333322, "export/test_tools": 0.45933333333333337, "export/test_torchbind": 2.731666666666666, "export/test_tree_utils": 0.209, "export/test_unflatten": 2.8176666666666663, "export/test_upgrade": 0.3746666666666667, "export/test_verifier": 0.7516666666666666, "functorch/test_ac": 12.15, "functorch/test_aotdispatch": 29.848333333333333, "functorch/test_control_flow": 99.2166666666667, "functorch/test_dims": 26.994, "functorch/test_eager_transforms": 9.619333333333334, "functorch/test_logging": 0.25366666666666665, "functorch/test_memory_efficient_fusion": 7.568666666666666, "functorch/test_minifier": 0.39133333333333337, "functorch/test_ops": 3917.221666666639, "functorch/test_parsing": 0.22766666666666668, "functorch/test_rearrange": 0.2416666666666667, "functorch/test_vmap": 274.57733333333266, "functorch/test_vmap_registrations": 1.9756666666665625, "higher_order_ops/test_with_effects": 6.456333333333333, "inductor/test_aot_inductor": 6182.006, "inductor/test_benchmark_fusion": 96.178, "inductor/test_binary_folding": 39.77333333333333, "inductor/test_codecache": 127.86166666666668, "inductor/test_codegen_triton": 0.19933333333333333, "inductor/test_compile_worker": 8.744333333333335, "inductor/test_compiled_autograd": 439.13000000000056, "inductor/test_compiled_optimizers": 1986.1213333333333, "inductor/test_config": 5.183000000000001, "inductor/test_control_flow": 123.589, "inductor/test_coordinate_descent_tuner": 3.1663333333333337, "inductor/test_cpp_wrapper": 1557.878, "inductor/test_cpu_repro": 600.3626666666668, "inductor/test_cuda_cpp_wrapper": 2004.6480000000001, "inductor/test_cuda_repro": 92.17333333333333, "inductor/test_cudacodecache": 1.7060000000000002, "inductor/test_cudagraph_trees": 70.20233333333333, "inductor/test_custom_lowering": 2.9033333333333338, "inductor/test_custom_post_grad_passes": 10.291333333333334, "inductor/test_cutlass_backend": 82.967, "inductor/test_debug_trace": 12.658666666666667, "inductor/test_decompose_mem_bound_mm": 30.101000000000003, "inductor/test_dependencies": 0.18766666666666665, "inductor/test_distributed_patterns": 34.06033333333333, "inductor/test_efficient_conv_bn_eval": 99.07033333333334, "inductor/test_extension_backend": 17.320333333333334, "inductor/test_flex_attention": 624.2253333333332, "inductor/test_foreach": 283.99166666666673, "inductor/test_fp8": 0.009666666666666669, "inductor/test_fused_attention": 212.958, "inductor/test_fx_fusion": 0.17833333333333332, "inductor/test_graph_transform_observer": 0.012000000000000002, "inductor/test_group_batch_fusion": 101.79633333333334, "inductor/test_indexing": 2.318333333333334, "inductor/test_inductor_freezing": 79.79899999999999, "inductor/test_inductor_utils": 0.4286666666666667, "inductor/test_inplacing_pass": 5.446666666666666, "inductor/test_kernel_benchmark": 151.855, "inductor/test_layout_optim": 10.937666666666667, "inductor/test_loop_ordering": 3.6346666666666665, "inductor/test_max_autotune": 299.46, "inductor/test_memory_planning": 28.024999999999995, "inductor/test_metrics": 3.6253333333333337, "inductor/test_minifier": 28.727666666666668, "inductor/test_minifier_isolate": 97.15033333333334, "inductor/test_mkldnn_pattern_matcher": 500.3626666666666, "inductor/test_mmdecomp": 6.512000000000003, "inductor/test_move_constructors_to_cuda": 14.723333333333334, "inductor/test_multi_kernel": 69.395, "inductor/test_pad_mm": 124.67866666666667, "inductor/test_padding": 13.122333333333332, "inductor/test_pattern_matcher": 95.68933333333332, "inductor/test_perf": 61.28866666666667, "inductor/test_profiler": 6.137666666666667, "inductor/test_select_algorithm": 110.51566666666668, "inductor/test_smoke": 5.1815, "inductor/test_snode_runtime": 8.632333333333333, "inductor/test_split_cat_fx_passes": 97.88433333333334, "inductor/test_standalone_compile": 17.721333333333334, "inductor/test_storage_offset": 1.0573333333333332, "inductor/test_templated_attention": 92.8336666666667, "inductor/test_torchbind": 6.4110000000000005, "inductor/test_torchinductor": 2525.359999999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 2451.389666666666, "inductor/test_torchinductor_dynamic_shapes": 2982.271, "inductor/test_torchinductor_opinfo": 8858.622333333331, "inductor/test_torchinductor_strided_blocks": 17.930999999999997, "inductor/test_triton_extension_backend": 0.8236666666666667, "inductor/test_triton_heuristics": 19.883, "inductor/test_triton_kernels": 89.12466666666667, "inductor/test_triton_wrapper": 8.627666666666668, "inductor/test_unbacked_symints": 18.181, "inductor/test_utils": 0.206, "lazy/test_debug_util": 0.24666666666666667, "lazy/test_functionalization": 0.264, "lazy/test_generator": 0.26733333333333337, "lazy/test_reuse_ir": 0.43900000000000006, "lazy/test_step_closures": 2.201333333333333, "lazy/test_ts_opinfo": 0.2836666666666667, "nn/test_convolution": 70.78266666666612, "nn/test_dropout": 0.5910000000000001, "nn/test_embedding": 11.568333333333335, "nn/test_init": 3.479333333333333, "nn/test_lazy_modules": 0.28533333333333344, "nn/test_load_state_dict": 0.6789999999999999, "nn/test_module_hooks": 0.16600000000000004, "nn/test_multihead_attention": 4.627666666666667, "nn/test_packed_sequence": 0.4370000000000001, "nn/test_parametrization": 0.8753333333333334, "nn/test_pooling": 5.619666666666664, "nn/test_pruning": 0.08933333333333338, "profiler/test_execution_trace": 2.1636666666666664, "profiler/test_memory_profiler": 4.043, "profiler/test_profiler": 27.269333333333332, "profiler/test_profiler_tree": 0.277, "profiler/test_record_function": 0.26433333333333336, "profiler/test_torch_tidy": 3.6556666666666664, "test_ao_sparsity": 8.943, "test_autocast": 1.4243333333333332, "test_autograd": 27.12166666666667, "test_autograd_fallback": 0.3246666666666667, "test_binary_ufuncs": 119.32700000000223, "test_bundled_inputs": 0.8816666666666668, "test_comparison_utils": 0.20966666666666667, "test_compile_benchmark_util": 0.0, "test_complex": 0.08633333333333333, "test_content_store": 2.732999999999999, "test_cpp_api_parity": 8.517666666666655, "test_cpp_extensions_aot_ninja": 0.3116666666666667, "test_cpp_extensions_aot_no_ninja": 0.29400000000000004, "test_cpp_extensions_jit": 95.65833333333335, "test_cpp_extensions_mtia_backend": 0.001, "test_cpp_extensions_open_device_registration": 6.223666666666667, "test_cpp_extensions_stream_and_event": 0.001, "test_cuda": 78.34633333333335, "test_cuda_expandable_segments": 82.91266666666667, "test_cuda_multigpu": 0.48200000000000004, "test_cuda_nvml_based_avail": 0.2803333333333333, "test_cuda_primary_ctx": 0.0030000000000000005, "test_cuda_sanitizer": 0.3376666666666667, "test_cuda_trace": 1.8223333333333336, "test_custom_backend": 0.073, "test_custom_ops": 7.4666666666666615, "test_dataloader": 239.68566666666663, "test_datapipe": 9.998, "test_decomp": 10426.039666666658, "test_deploy": 0.20166666666666666, "test_dispatch": 32.374666666666684, "test_dlpack": 0.25400000000000017, "test_dynamic_shapes": 4.228666666666661, "test_expanded_weights": 12.661333333333332, "test_fake_tensor": 16.26300000000001, "test_flop_counter": 0.6443333333333334, "test_foreach": 372.74366666667356, "test_function_schema": 0.47433333333333333, "test_functional_autograd_benchmark": 16.470666666666663, "test_functional_optim": 0.3106666666666667, "test_functionalization": 3.750999999999999, "test_functionalization_of_rng_ops": 2.1016666666666666, "test_futures": 0.8403333333333333, "test_fx": 219.23833333333334, "test_fx_experimental": 13.391999999999998, "test_fx_passes": 0.5080000000000001, "test_fx_reinplace_pass": 0.36933333333333346, "test_import_stats": 3.622, "test_indexing": 1.5889999999999986, "test_itt": 0.24100000000000002, "test_jit": 99.99700000000001, "test_jit_autocast": 26.82133333333333, "test_jit_cuda_fuser": 983.3440000000008, "test_jit_disabled": 0.3033333333333334, "test_jit_fuser_te": 739.8846666666676, "test_jit_llga_fuser": 0.06, "test_jiterator": 19.16266666666667, "test_legacy_vmap": 2.2843333333333335, "test_license": 0.208, "test_linalg": 817.7316666666651, "test_logging": 2.553666666666667, "test_masked": 24.791666666666654, "test_maskedtensor": 6.670999999999957, "test_matmul_cuda": 88.93033333333335, "test_meta": 1687.307666666612, "test_mkl_verbose": 3.989666666666666, "test_mkldnn": 46.23766666666666, "test_mkldnn_fusion": 44.072, "test_mkldnn_verbose": 3.299666666666667, "test_mobile_optimizer": 2.6313333333333335, "test_model_dump": 0.8713333333333333, "test_model_exports_to_core_aten": 0.12233333333333334, "test_module_init": 1.209999999999994, "test_module_tracker": 0.209, "test_modules": 636.2243333333196, "test_monitor": 0.3156666666666667, "test_multiprocessing": 97.32600000000001, "test_multiprocessing_spawn": 25.832666666666668, "test_namedtensor": 0.5690000000000001, "test_namedtuple_return_api": 1.6829999999999998, "test_native_functions": 0.3206666666666667, "test_native_mha": 0.5536666666666669, "test_nestedtensor": 8.349333333333325, "test_nn": 171.58833333333766, "test_numba_integration": 0.08866666666666667, "test_numpy_interop": 0.1266666666666667, "test_nvfuser_frontend": 2.73, "test_openmp": 3.542, "test_ops": 4111.294999999981, "test_ops_fwd_gradients": 1009.2639999999795, "test_ops_gradients": 1716.5433333332692, "test_ops_jit": 944.6753333333332, "test_optim": 206.24833333333308, "test_out_dtype_op": 0.2936666666666667, "test_overrides": 1.869333333333259, "test_package": 1.8433333333333326, "test_per_overload_api": 0.21033333333333334, "test_prims": 0.3036666666666667, "test_proxy_tensor": 23.49, "test_pruning_op": 0.3906666666666667, "test_public_bindings": 4.589666666666666, "test_python_dispatch": 1.6676666666666666, "test_pytree": 0.36033333333333345, "test_quantization": 2724.2026666666666, "test_reductions": 132.97900000000175, "test_scatter_gather_ops": 22.374, "test_schema_check": 227.53866666666104, "test_segment_reductions": 2.062, "test_serialization": 22.021999999999995, "test_set_default_mobile_cpu_allocator": 0.207, "test_shape_ops": 1.1976666666666655, "test_show_pickle": 0.22233333333333336, "test_sort_and_select": 3.6976666666666618, "test_sparse": 712.054999999994, "test_sparse_csr": 1346.6529999999996, "test_sparse_semi_structured": 30.172333333333327, "test_spectral_ops": 18.755333333333294, "test_stateless": 4.94, "test_subclass": 0.37733333333333346, "test_sympy_utils": 12.616666666666665, "test_tensor_creation_ops": 86.01900000000016, "test_tensorboard": 22.719333333333335, "test_tensorexpr": 114.21366666666667, "test_tensorexpr_pybind": 0.7773333333333335, "test_testing": 33.41099999999998, "test_torch": 75.8456666666667, "test_transformers": 1471.0036666661563, "test_type_hints": 0.20433333333333334, "test_type_info": 0.224, "test_type_promotion": 7.908333333333316, "test_typing": 60.163333333333306, "test_unary_ufuncs": 327.1479999999513, "test_utils": 25.37433333333392, "test_view_ops": 14.749333333333334, "test_vulkan": 0.0003333333333333333, "test_weak": 3.504333333333333, "test_xnnpack_integration": 37.25266666666666, "torch_np/numpy_tests/core/test_dlpack": 0.0033333333333333335, "torch_np/numpy_tests/core/test_dtype": 0.316, "torch_np/numpy_tests/core/test_einsum": 11.956999999999999, "torch_np/numpy_tests/core/test_getlimits": 0.22133333333333335, "torch_np/numpy_tests/core/test_indexing": 0.35966666666666675, "torch_np/numpy_tests/core/test_multiarray": 25.62366666666668, "torch_np/numpy_tests/core/test_numeric": 4.058333333333333, "torch_np/numpy_tests/core/test_numerictypes": 0.23833333333333337, "torch_np/numpy_tests/core/test_scalar_ctors": 0.2833333333333334, "torch_np/numpy_tests/core/test_scalar_methods": 0.0, "torch_np/numpy_tests/core/test_scalarinherit": 0.0003333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 22.785, "torch_np/numpy_tests/core/test_shape_base": 0.41000000000000014, "torch_np/numpy_tests/fft/test_helper": 5.166666666666667, "torch_np/numpy_tests/fft/test_pocketfft": 2.9276666666666658, "torch_np/numpy_tests/lib/test_arraypad": 0.21933333333333335, "torch_np/numpy_tests/lib/test_arraysetops": 0.3393333333333333, "torch_np/numpy_tests/lib/test_function_base": 1.4303333333333335, "torch_np/numpy_tests/lib/test_histograms": 0.4256666666666667, "torch_np/numpy_tests/lib/test_index_tricks": 0.2726666666666667, "torch_np/numpy_tests/lib/test_shape_base_": 0.5466666666666667, "torch_np/numpy_tests/lib/test_twodim_base": 0.4536666666666667, "torch_np/numpy_tests/lib/test_type_check": 0.2856666666666667, "torch_np/numpy_tests/linalg/test_linalg": 4.235, "torch_np/test_basic": 0.6450000000000004, "torch_np/test_binary_ufuncs": 0.28066666666666673, "torch_np/test_dtype": 0.24833333333333338, "torch_np/test_function_base": 0.20766666666666667, "torch_np/test_ndarray_methods": 2.3430000000000004, "torch_np/test_nep50_examples": 0.012000000000000002, "torch_np/test_random": 0.26566666666666666, "torch_np/test_reductions": 2.28699999999996, "torch_np/test_scalars_0D_arrays": 0.25633333333333336, "torch_np/test_ufuncs_basic": 0.7886666666666672, "torch_np/test_unary_ufuncs": 0.29666666666666675}, "slow": {"backends/xeon/test_launch": 1.75, "benchmark_utils/test_benchmark_utils": 314.2929999999999, "distributions/test_distributions": 0.23400000000000015, "dynamo/test_activation_checkpointing": 0.232, "dynamo/test_after_aot": 0.201, "dynamo/test_allow_inline_skip": 0.188, "dynamo/test_aot_autograd": 0.23000000000000004, "dynamo/test_aot_autograd_cache": 0.20400000000000001, "dynamo/test_autograd_function": 0.22500000000000003, "dynamo/test_backends": 0.21800000000000003, "dynamo/test_backward_higher_order_ops": 0.20800000000000002, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_hook": 0.206, "dynamo/test_bytecode_utils": 0.20500000000000002, "dynamo/test_compile": 0.212, "dynamo/test_comptime": 0.227, "dynamo/test_config": 0.202, "dynamo/test_cpp_guard_manager": 1.1300000000000008, "dynamo/test_ctx_manager": 0.056000000000000036, "dynamo/test_cudagraphs": 0.20400000000000001, "dynamo/test_debug_utils": 0.20400000000000001, "dynamo/test_decorators": 0.21400000000000002, "dynamo/test_deviceguard": 0.014, "dynamo/test_dynamic_shapes": 2561.2289999999985, "dynamo/test_exc": 0.011, "dynamo/test_exceptions": 0.20600000000000002, "dynamo/test_export": 0.18800000000000014, "dynamo/test_export_mutations": 0.208, "dynamo/test_frame_init": 0.196, "dynamo/test_functions": 0.6170000000000003, "dynamo/test_fx_passes_pre_grad": 0.197, "dynamo/test_global": 0.20900000000000002, "dynamo/test_guard_manager": 0.23000000000000004, "dynamo/test_higher_order_ops": 0.3920000000000002, "dynamo/test_hooks": 0.22500000000000003, "dynamo/test_inline_inbuilt_nn_modules": 1.3450000000000009, "dynamo/test_input_attr_tracking": 0.231, "dynamo/test_interop": 0.20400000000000001, "dynamo/test_logging": 0.23600000000000004, "dynamo/test_minifier": 0.224, "dynamo/test_misc": 0.46500000000000036, "dynamo/test_model_output": 0.001, "dynamo/test_modules": 0.3110000000000001, "dynamo/test_nops": 0.203, "dynamo/test_optimizers": 0.207, "dynamo/test_pre_dispatch": 0.20400000000000001, "dynamo/test_profiler": 0.213, "dynamo/test_python_autograd": 0.24200000000000002, "dynamo/test_recompile_ux": 0.20400000000000001, "dynamo/test_recompiles": 0.20400000000000001, "dynamo/test_reorder_logs": 0.20700000000000002, "dynamo/test_replay_record": 0.129, "dynamo/test_repros": 0.23100000000000018, "dynamo/test_resume": 0.202, "dynamo/test_sdpa": 0.198, "dynamo/test_skip_non_tensor": 0.20500000000000002, "dynamo/test_sources": 0.202, "dynamo/test_structured_trace": 0.21100000000000002, "dynamo/test_subclasses": 0.26000000000000006, "dynamo/test_subgraphs": 0.24400000000000005, "dynamo/test_trace_rules": 0.225, "dynamo/test_triton_kernels": 0.5180000000000002, "dynamo/test_unspec": 0.23300000000000004, "dynamo/test_verify_correctness": 0.20400000000000001, "dynamo/test_view": 0.20400000000000001, "export/test_converter": 0.21900000000000003, "export/test_db": 0.23100000000000004, "export/test_experimental": 0.215, "export/test_export": 0.4570000000000002, "export/test_export_nonstrict": 0.1570000000000001, "export/test_export_predispatch": 0.1450000000000001, "export/test_functionalized_assertions": 0.198, "export/test_funtionalized_assertions": 0.5870000000000001, "export/test_hop": 0.02100000000000001, "export/test_lift_unlift": 0.082, "export/test_pass_infra": 0.2, "export/test_passes": 0.21900000000000003, "export/test_retraceability": 0.1580000000000001, "export/test_safeguard": 0.20500000000000002, "export/test_schema": 0.2, "export/test_serdes": 0.1580000000000001, "export/test_serialize": 0.2770000000000001, "export/test_sparse": 0.35400000000000015, "export/test_tools": 0.20400000000000001, "export/test_torchbind": 2.4449999999999994, "export/test_tree_utils": 0.203, "export/test_unflatten": 0.22100000000000003, "export/test_upgrade": 0.20800000000000002, "export/test_verifier": 0.23800000000000002, "functorch/test_ac": 0.20600000000000002, "functorch/test_aotdispatch": 0.2940000000000002, "functorch/test_control_flow": 0.3500000000000002, "functorch/test_dims": 0.2720000000000001, "functorch/test_eager_transforms": 0.3540000000000002, "functorch/test_logging": 0.204, "functorch/test_memory_efficient_fusion": 0.23, "functorch/test_minifier": 0.20400000000000001, "functorch/test_ops": 2000.693999999943, "functorch/test_parsing": 0.21400000000000002, "functorch/test_rearrange": 0.216, "functorch/test_vmap": 6.356000000000076, "functorch/test_vmap_registrations": 1.916999999999901, "higher_order_ops/test_with_effects": 5.718000000000001, "inductor/test_aot_inductor": 64.7240000000005, "inductor/test_benchmark_fusion": 47.768, "inductor/test_binary_folding": 0.004, "inductor/test_codecache": 2.823, "inductor/test_codegen_triton": 0.125, "inductor/test_compile_worker": 0.218, "inductor/test_compiled_autograd": 0.6490000000000005, "inductor/test_compiled_optimizers": 70.75200000000002, "inductor/test_config": 0.23700000000000002, "inductor/test_control_flow": 0.28800000000000003, "inductor/test_coordinate_descent_tuner": 0.21, "inductor/test_cpp_wrapper": 35.681499999999915, "inductor/test_cpu_repro": 917.0179999999992, "inductor/test_cuda_cpp_wrapper": 0.09700000000000007, "inductor/test_cuda_repro": 0.05300000000000004, "inductor/test_cudagraph_trees": 0.08300000000000006, "inductor/test_custom_lowering": 0.124, "inductor/test_custom_post_grad_passes": 0.124, "inductor/test_cutlass_backend": 76.51100000000008, "inductor/test_debug_trace": 0.002, "inductor/test_decompose_mem_bound_mm": 0.21700000000000003, "inductor/test_dependencies": 0.125, "inductor/test_distributed_patterns": 0.23, "inductor/test_efficient_conv_bn_eval": 293.991, "inductor/test_extension_backend": 1.867, "inductor/test_flex_attention": 0.1370000000000001, "inductor/test_foreach": 0.19700000000000015, "inductor/test_fp8": 0.008, "inductor/test_fused_attention": 0.09600000000000004, "inductor/test_fx_fusion": 0.137, "inductor/test_graph_transform_observer": 0.011, "inductor/test_group_batch_fusion": 67.346, "inductor/test_indexing": 0.24000000000000002, "inductor/test_inductor_freezing": 0.04600000000000003, "inductor/test_inplacing_pass": 0.208, "inductor/test_kernel_benchmark": 0.027000000000000007, "inductor/test_layout_optim": 0.023000000000000007, "inductor/test_loop_ordering": 0.198, "inductor/test_max_autotune": 0.17700000000000005, "inductor/test_memory_planning": 0.21, "inductor/test_metrics": 0.006, "inductor/test_minifier": 0.20800000000000002, "inductor/test_minifier_isolate": 0.201, "inductor/test_mkldnn_pattern_matcher": 0.24800000000000008, "inductor/test_mmdecomp": 0.026000000000000016, "inductor/test_move_constructors_to_cuda": 0.019000000000000003, "inductor/test_multi_kernel": 0.225, "inductor/test_pad_mm": 0.14300000000000002, "inductor/test_padding": 0.27, "inductor/test_pattern_matcher": 0.044000000000000025, "inductor/test_perf": 0.19300000000000003, "inductor/test_profiler": 0.20600000000000002, "inductor/test_select_algorithm": 0.14200000000000002, "inductor/test_smoke": 0.225, "inductor/test_snode_runtime": 0.14300000000000002, "inductor/test_split_cat_fx_passes": 0.138, "inductor/test_standalone_compile": 0.24000000000000002, "inductor/test_storage_offset": 0.001, "inductor/test_templated_attention": 0.05100000000000003, "inductor/test_torchbind": 0.203, "inductor/test_torchinductor": 466.73800000000415, "inductor/test_torchinductor_codegen_dynamic_shapes": 400.72300000000376, "inductor/test_torchinductor_dynamic_shapes": 467.38499999999317, "inductor/test_torchinductor_opinfo": 6.74300000000062, "inductor/test_triton_extension_backend": 0.001, "inductor/test_triton_heuristics": 0.214, "inductor/test_triton_kernels": 0.3850000000000001, "inductor/test_triton_wrapper": 0.201, "inductor/test_unbacked_symints": 0.010000000000000002, "inductor/test_utils": 0.208, "lazy/test_debug_util": 0.201, "lazy/test_functionalization": 0.206, "lazy/test_generator": 0.203, "lazy/test_reuse_ir": 0.213, "lazy/test_step_closures": 0.201, "lazy/test_ts_opinfo": 0.005, "nn/test_convolution": 0.6870000000000004, "nn/test_dropout": 0.011, "nn/test_embedding": 0.1500000000000001, "nn/test_init": 0.344, "nn/test_lazy_modules": 0.06600000000000004, "nn/test_load_state_dict": 0.03800000000000002, "nn/test_module_hooks": 0.06500000000000003, "nn/test_multihead_attention": 0.019000000000000003, "nn/test_packed_sequence": 0.20800000000000002, "nn/test_parametrization": 0.059000000000000045, "nn/test_pooling": 23.237000000000076, "nn/test_pruning": 0.044000000000000025, "profiler/test_execution_trace": 0.015000000000000003, "profiler/test_memory_profiler": 0.23600000000000002, "profiler/test_profiler": 0.07100000000000004, "profiler/test_profiler_tree": 0.21, "profiler/test_record_function": 0.20600000000000002, "profiler/test_torch_tidy": 0.22300000000000003, "test_ao_sparsity": 0.21400000000000008, "test_autocast": 0.223, "test_autograd": 4.449000000000037, "test_autograd_fallback": 0.23600000000000002, "test_binary_ufuncs": 18.288999999998584, "test_bundled_inputs": 0.21200000000000002, "test_comparison_utils": 0.215, "test_compile_benchmark_util": 0.0, "test_complex": 0.017000000000000005, "test_content_store": 0.004, "test_cpp_api_parity": 0.4920000000000004, "test_cpp_extensions_aot_ninja": 0.024000000000000007, "test_cpp_extensions_aot_no_ninja": 0.023000000000000003, "test_cpp_extensions_jit": 130.31800000000004, "test_cpp_extensions_mtia_backend": 0.001, "test_cpp_extensions_open_device_registration": 2.0689999999999977, "test_cpp_extensions_stream_and_event": 0.0, "test_cuda": 15.905999999999981, "test_cuda_expandable_segments": 16.29599999999999, "test_cuda_multigpu": 0.04300000000000001, "test_cuda_nvml_based_avail": 0.009000000000000001, "test_cuda_primary_ctx": 0.003, "test_cuda_sanitizer": 0.23200000000000004, "test_cuda_trace": 1.7010000000000003, "test_custom_backend": 0.074, "test_custom_ops": 0.5330000000000003, "test_dataloader": 491.07400000000024, "test_datapipe": 0.30300000000000005, "test_decomp": 5141.338000000732, "test_deploy": 0.201, "test_dispatch": 0.16900000000000004, "test_dlpack": 0.11800000000000009, "test_dynamic_shapes": 0.6540000000000004, "test_expanded_weights": 0.22400000000000014, "test_fake_tensor": 0.21700000000000016, "test_flop_counter": 0.026000000000000013, "test_foreach": 3.4859999999997298, "test_function_schema": 0.21400000000000002, "test_functional_autograd_benchmark": 78.369, "test_functional_optim": 0.228, "test_functionalization": 0.3080000000000001, "test_functionalization_of_rng_ops": 0.010000000000000002, "test_futures": 0.22200000000000003, "test_fx": 210.681, "test_fx_experimental": 0.7140000000000005, "test_fx_passes": 0.24400000000000005, "test_fx_reinplace_pass": 0.20600000000000002, "test_import_stats": 0.207, "test_indexing": 0.08700000000000005, "test_itt": 0.207, "test_jit": 23.670000000000016, "test_jit_autocast": 0.05700000000000003, "test_jit_cuda_fuser": 5265.227000000007, "test_jit_disabled": 0.211, "test_jit_fuser_te": 487.54800000000023, "test_jit_llga_fuser": 0.002, "test_jiterator": 0.2910000000000002, "test_legacy_vmap": 0.12700000000000009, "test_license": 0.201, "test_linalg": 1553.4379999999906, "test_logging": 0.2, "test_masked": 0.1460000000000001, "test_maskedtensor": 0.9480000000000007, "test_matmul_cuda": 0.03100000000000002, "test_meta": 269.2049999997492, "test_mkl_verbose": 0.202, "test_mkldnn": 0.20400000000000007, "test_mkldnn_fusion": 0.215, "test_mkldnn_verbose": 0.208, "test_mobile_optimizer": 0.203, "test_model_dump": 0.213, "test_model_exports_to_core_aten": 0.199, "test_module_init": 0.3880000000000003, "test_module_tracker": 0.203, "test_modules": 455.5439999999491, "test_monitor": 0.30300000000000005, "test_multiprocessing": 31.451000000000032, "test_multiprocessing_spawn": 0.234, "test_namedtensor": 0.08600000000000006, "test_namedtuple_return_api": 0.207, "test_native_functions": 0.226, "test_native_mha": 0.05400000000000004, "test_nestedtensor": 0.4870000000000003, "test_nn": 2.4419999999999544, "test_numba_integration": 0.013000000000000001, "test_numpy_interop": 0.04100000000000003, "test_nvfuser_frontend": 0.199, "test_openmp": 0.19, "test_ops": 1466.5360000000376, "test_ops_fwd_gradients": 95.9220000000137, "test_ops_gradients": 749.3059999999405, "test_ops_jit": 76.87600000000157, "test_optim": 0.8200000000000005, "test_out_dtype_op": 0.02200000000000001, "test_overrides": 1.7029999999999283, "test_package": 0.3250000000000001, "test_per_overload_api": 0.20500000000000002, "test_prims": 0.022000000000000006, "test_proxy_tensor": 0.17400000000000013, "test_pruning_op": 0.20400000000000001, "test_public_bindings": 0.22, "test_python_dispatch": 0.11100000000000007, "test_pytree": 0.2820000000000001, "test_quantization": 1701.2649999999999, "test_reductions": 4.772999999999932, "test_scatter_gather_ops": 0.07300000000000005, "test_schema_check": 7.275000000000889, "test_segment_reductions": 0.07400000000000005, "test_serialization": 0.20500000000000007, "test_set_default_mobile_cpu_allocator": 0.203, "test_shape_ops": 0.09300000000000007, "test_show_pickle": 0.21, "test_sort_and_select": 0.11200000000000009, "test_sparse": 288.62499999997146, "test_sparse_csr": 478.4299999999985, "test_sparse_semi_structured": 20.91, "test_spectral_ops": 0.34800000000000025, "test_stateless": 0.05700000000000004, "test_subclass": 0.2690000000000001, "test_sympy_utils": 0.1580000000000001, "test_tensor_creation_ops": 0.5160000000000003, "test_tensorboard": 0.17600000000000002, "test_tensorexpr": 0.26500000000000007, "test_tensorexpr_pybind": 0.227, "test_testing": 8.01599999999997, "test_torch": 24.46300000000088, "test_transformers": 79.7050000000063, "test_type_hints": 0.225, "test_type_info": 0.21, "test_type_promotion": 0.4260000000000003, "test_typing": 59.177999999999976, "test_unary_ufuncs": 25.78300000000862, "test_utils": 6.084000000000369, "test_view_ops": 0.2790000000000002, "test_vulkan": 0.0, "test_weak": 0.24200000000000005, "test_xnnpack_integration": 295.07000000000005, "torch_np/numpy_tests/core/test_dlpack": 0.001, "torch_np/numpy_tests/core/test_dtype": 0.24900000000000003, "torch_np/numpy_tests/core/test_einsum": 0.24200000000000005, "torch_np/numpy_tests/core/test_getlimits": 0.20500000000000002, "torch_np/numpy_tests/core/test_indexing": 0.26000000000000006, "torch_np/numpy_tests/core/test_multiarray": 641.3939999999998, "torch_np/numpy_tests/core/test_numeric": 0.4500000000000002, "torch_np/numpy_tests/core/test_numerictypes": 0.236, "torch_np/numpy_tests/core/test_scalar_ctors": 0.26700000000000007, "torch_np/numpy_tests/core/test_scalar_methods": 0.002, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 44.83399999999999, "torch_np/numpy_tests/core/test_shape_base": 0.30400000000000005, "torch_np/numpy_tests/fft/test_helper": 0.217, "torch_np/numpy_tests/fft/test_pocketfft": 0.28200000000000003, "torch_np/numpy_tests/lib/test_arraypad": 0.20700000000000002, "torch_np/numpy_tests/lib/test_arraysetops": 0.213, "torch_np/numpy_tests/lib/test_function_base": 0.5700000000000003, "torch_np/numpy_tests/lib/test_histograms": 0.4700000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.249, "torch_np/numpy_tests/lib/test_shape_base_": 0.271, "torch_np/numpy_tests/lib/test_twodim_base": 0.23800000000000002, "torch_np/numpy_tests/lib/test_type_check": 0.24900000000000003, "torch_np/numpy_tests/linalg/test_linalg": 1.779, "torch_np/test_basic": 0.4500000000000003, "torch_np/test_binary_ufuncs": 0.24300000000000002, "torch_np/test_dtype": 0.263, "torch_np/test_function_base": 0.209, "torch_np/test_ndarray_methods": 0.40500000000000014, "torch_np/test_nep50_examples": 0.012, "torch_np/test_random": 0.23500000000000004, "torch_np/test_reductions": 1.1570000000000007, "torch_np/test_scalars_0D_arrays": 0.23700000000000002, "torch_np/test_ufuncs_basic": 0.5500000000000003, "torch_np/test_unary_ufuncs": 0.24200000000000005}}, "linux-focal-cuda12.4-py3.10-gcc9": {"default": {"backends/xeon/test_launch": 3.316, "benchmark_utils/test_benchmark_utils": 2.8884999999999996, "distributions/test_distributions": 126.8265, "dynamo/test_activation_checkpointing": 1.0190000000000001, "dynamo/test_after_aot": 9.982, "dynamo/test_aot_autograd": 26.787000000000003, "dynamo/test_aot_autograd_cache": 11.943499999999998, "dynamo/test_autograd_function": 5.318999999999999, "dynamo/test_backends": 24.668499999999995, "dynamo/test_backward_higher_order_ops": 23.0795, "dynamo/test_base_output": 0.009000000000000001, "dynamo/test_bytecode_hook": 6.342, "dynamo/test_bytecode_utils": 10.078, "dynamo/test_compile": 11.9865, "dynamo/test_comptime": 1.1690000000000003, "dynamo/test_config": 1.1560000000000001, "dynamo/test_ctx_manager": 3.738999999999998, "dynamo/test_cudagraphs": 6.555499999999999, "dynamo/test_debug_utils": 0.47750000000000004, "dynamo/test_decorators": 10.314999999999998, "dynamo/test_deviceguard": 0.0345, "dynamo/test_dynamic_shapes": 1492.3345000000004, "dynamo/test_exc": 3.732, "dynamo/test_exceptions": 1.06, "dynamo/test_export": 29.740999999999993, "dynamo/test_export_mutations": 1.1030000000000002, "dynamo/test_frame_init": 0.4025, "dynamo/test_functions": 59.08550000000022, "dynamo/test_fx_passes_pre_grad": 2.1065, "dynamo/test_global": 1.0665000000000002, "dynamo/test_guard_manager": 0.4660000000000001, "dynamo/test_higher_order_ops": 39.0085, "dynamo/test_hooks": 50.64350000000002, "dynamo/test_inline_inbuilt_nn_modules": 198.5165000000002, "dynamo/test_input_attr_tracking": 13.151999999999997, "dynamo/test_interop": 1.1480000000000001, "dynamo/test_logging": 29.994500000000006, "dynamo/test_minifier": 4.6375, "dynamo/test_misc": 104.12650000000022, "dynamo/test_model_output": 0.02400000000000001, "dynamo/test_modules": 36.806999999999995, "dynamo/test_nops": 0.571, "dynamo/test_optimizers": 1.289, "dynamo/test_pre_dispatch": 0.9855, "dynamo/test_profiler": 2.6825, "dynamo/test_python_autograd": 1.381, "dynamo/test_recompile_ux": 1.8394999999999997, "dynamo/test_recompiles": 1.7715, "dynamo/test_reorder_logs": 1.1215000000000002, "dynamo/test_repros": 87.46100000000007, "dynamo/test_resume": 0.8714999999999999, "dynamo/test_sdpa": 0.978, "dynamo/test_skip_non_tensor": 1.1125, "dynamo/test_sources": 1.0294999999999999, "dynamo/test_structured_trace": 23.4565, "dynamo/test_subclasses": 25.548499999999997, "dynamo/test_subgraphs": 4.435499999999999, "dynamo/test_trace_rules": 2.565, "dynamo/test_unspec": 23.637999999999998, "dynamo/test_verify_correctness": 1.1435000000000002, "dynamo/test_view": 1.26, "export/test_converter": 10.275500000000001, "export/test_db": 6.1695, "export/test_experimental": 1.997, "export/test_export": 54.396, "export/test_export_nonstrict": 46.038499999999985, "export/test_functionalized_assertions": 0.396, "export/test_hop": 5.962, "export/test_lift_unlift": 0.187, "export/test_pass_infra": 1.7715, "export/test_passes": 24.3455, "export/test_retraceability": 83.11200000000001, "export/test_schema": 0.46799999999999997, "export/test_serdes": 55.413000000000025, "export/test_serialize": 18.773, "export/test_sparse": 123.95549999999992, "export/test_tools": 1.073, "export/test_torchbind": 5.6265, "export/test_tree_utils": 0.4055, "export/test_unflatten": 6.305000000000001, "export/test_verifier": 1.9385, "functorch/test_aotdispatch": 67.85849999999999, "functorch/test_control_flow": 212.90850000000003, "functorch/test_dims": 47.80650000000001, "functorch/test_eager_transforms": 20.0315, "functorch/test_logging": 0.511, "functorch/test_memory_efficient_fusion": 11.247, "functorch/test_minifier": 0.8635000000000002, "functorch/test_ops": 7612.255000000001, "functorch/test_parsing": 0.43300000000000005, "functorch/test_rearrange": 0.4935000000000001, "functorch/test_vmap": 620.7265000000007, "functorch/test_vmap_registrations": 4.631499999999825, "higher_order_ops/test_with_effects": 9.958, "inductor/test_benchmark_fusion": 18.3655, "inductor/test_binary_folding": 74.3675, "inductor/test_codecache": 83.32499999999996, "inductor/test_codegen_triton": 0.43499999999999994, "inductor/test_compile_worker": 14.685, "inductor/test_compiled_autograd": 983.2190000000012, "inductor/test_compiled_optimizers": 491.34449999999987, "inductor/test_config": 12.4095, "inductor/test_control_flow": 0.07950000000000004, "inductor/test_cpu_repro": 1219.1635000000003, "inductor/test_custom_lowering": 0.0045000000000000005, "inductor/test_custom_post_grad_passes": 23.211, "inductor/test_debug_trace": 6.9435, "inductor/test_decompose_mem_bound_mm": 0.005, "inductor/test_distributed_patterns": 77.3465, "inductor/test_efficient_conv_bn_eval": 0.0025, "inductor/test_extension_backend": 36.346000000000004, "inductor/test_flex_attention": 0.1540000000000001, "inductor/test_foreach": 36.19800000000029, "inductor/test_fused_attention": 304.479, "inductor/test_fx_fusion": 0.3825, "inductor/test_graph_transform_observer": 0.028999999999999998, "inductor/test_group_batch_fusion": 0.3185, "inductor/test_indexing": 1.2414999999999998, "inductor/test_inductor_freezing": 99.68499999999997, "inductor/test_minifier": 48.599500000000006, "inductor/test_minifier_isolate": 85.66300000000001, "inductor/test_mkldnn_pattern_matcher": 1076.217, "inductor/test_mmdecomp": 0.033000000000000015, "inductor/test_standalone_compile": 36.6035, "inductor/test_torchbind": 12.778, "inductor/test_torchinductor": 3054.9709999999995, "inductor/test_torchinductor_codegen_dynamic_shapes": 2984.9004999999993, "inductor/test_torchinductor_dynamic_shapes": 3155.3719999999994, "inductor/test_torchinductor_opinfo": 25.019999999999918, "inductor/test_triton_extension_backend": 1.081, "inductor/test_triton_kernels": 0.25500000000000017, "inductor/test_utils": 0.396, "lazy/test_debug_util": 0.5445, "lazy/test_functionalization": 0.5855, "lazy/test_generator": 0.585, "lazy/test_reuse_ir": 0.8355, "lazy/test_step_closures": 3.4749999999999996, "lazy/test_ts_opinfo": 0.469, "nn/test_convolution": 67.54800000000019, "nn/test_dropout": 1.4620000000000002, "nn/test_embedding": 27.588999999999988, "nn/test_init": 6.916999999999998, "nn/test_lazy_modules": 0.5875000000000002, "nn/test_load_state_dict": 1.1945000000000001, "nn/test_module_hooks": 0.364, "nn/test_multihead_attention": 10.022499999999999, "nn/test_packed_sequence": 0.7895000000000001, "nn/test_parametrization": 1.8010000000000002, "nn/test_pooling": 17.202499999999993, "nn/test_pruning": 0.1775000000000001, "profiler/test_execution_trace": 0.355, "profiler/test_memory_profiler": 7.703000000000001, "profiler/test_profiler": 44.628, "profiler/test_profiler_tree": 0.5980000000000001, "profiler/test_record_function": 0.542, "profiler/test_torch_tidy": 5.817499999999999, "test_ao_sparsity": 17.5095, "test_autocast": 3.9455000000000005, "test_autograd": 59.04749999999994, "test_autograd_fallback": 0.6910000000000002, "test_binary_ufuncs": 240.79250000000263, "test_bundled_inputs": 1.9404999999999992, "test_comparison_utils": 0.4285, "test_compile_benchmark_util": 0.0015, "test_complex": 0.21650000000000003, "test_content_store": 0.1825, "test_cpp_api_parity": 18.573499999999918, "test_cpp_extensions_aot_ninja": 0.4545, "test_cpp_extensions_aot_no_ninja": 0.45000000000000007, "test_cpp_extensions_jit": 129.18800000000002, "test_cpp_extensions_mtia_backend": 0.0075, "test_cpp_extensions_open_device_registration": 13.178500000000007, "test_cpp_extensions_stream_and_event": 0.0015, "test_cuda": 173.61100000000005, "test_cuda_expandable_segments": 189.11, "test_cuda_multigpu": 1.04, "test_cuda_nvml_based_avail": 0.32099999999999995, "test_cuda_primary_ctx": 0.0045000000000000005, "test_cuda_sanitizer": 0.5945000000000001, "test_cuda_trace": 1.6334999999999997, "test_custom_backend": 0.161, "test_custom_ops": 15.10599999999999, "test_dataloader": 321.059, "test_datapipe": 19.651, "test_decomp": 15401.86350000001, "test_deploy": 0.40950000000000003, "test_dispatch": 61.612000000000016, "test_dlpack": 0.5765000000000003, "test_dynamic_shapes": 9.50749999999999, "test_expanded_weights": 26.032999999999998, "test_fake_tensor": 45.27200000000001, "test_flop_counter": 0.7495, "test_foreach": 311.49600000001755, "test_function_schema": 1.0715000000000001, "test_functional_autograd_benchmark": 32.692, "test_functional_optim": 0.6325, "test_functionalization": 8.175999999999995, "test_functionalization_of_rng_ops": 5.118, "test_futures": 1.3715000000000002, "test_fx": 478.5769999999999, "test_fx_experimental": 27.92999999999995, "test_fx_passes": 1.2035000000000005, "test_fx_reinplace_pass": 0.805, "test_import_stats": 6.5840000000000005, "test_indexing": 3.1269999999999976, "test_itt": 0.4, "test_jit": 196.32500000000013, "test_jit_autocast": 54.001000000000005, "test_jit_disabled": 0.6615, "test_jit_fuser_te": 842.8120000000007, "test_jit_llga_fuser": 0.14150000000000001, "test_jiterator": 29.757999999999925, "test_legacy_vmap": 4.080500000000001, "test_license": 0.4195, "test_linalg": 510.7490000000016, "test_logging": 4.524, "test_masked": 49.517000000000095, "test_maskedtensor": 12.81299999999992, "test_matmul_cuda": 71.45349999999998, "test_meta": 4003.036499999879, "test_mkl_verbose": 7.1165, "test_mkldnn_fusion": 61.941, "test_mkldnn_verbose": 6.4195, "test_mobile_optimizer": 5.0455000000000005, "test_model_dump": 1.7895, "test_model_exports_to_core_aten": 0.4465, "test_module_tracker": 0.4035, "test_modules": 910.3274999999974, "test_monitor": 0.6435, "test_multiprocessing": 167.036, "test_multiprocessing_spawn": 51.6605, "test_namedtensor": 1.4780000000000002, "test_namedtuple_return_api": 3.109, "test_native_functions": 0.6940000000000002, "test_native_mha": 1.2485000000000008, "test_nestedtensor": 6.806499999999993, "test_nn": 279.9589999999939, "test_numba_integration": 0.24250000000000005, "test_numpy_interop": 0.32450000000000007, "test_openmp": 7.446, "test_ops": 8880.980499999947, "test_ops_fwd_gradients": 1832.9239999999893, "test_ops_gradients": 2555.312499999983, "test_ops_jit": 1798.8129999999978, "test_optim": 393.1599999999999, "test_out_dtype_op": 0.7015, "test_overrides": 5.206999999999805, "test_package": 4.259, "test_per_overload_api": 0.48150000000000004, "test_prims": 0.8555000000000003, "test_proxy_tensor": 44.7915, "test_pruning_op": 0.7435, "test_public_bindings": 9.8185, "test_python_dispatch": 2.6069999999999993, "test_pytree": 0.7920000000000003, "test_quantization": 4692.248000000001, "test_reductions": 200.887999999994, "test_scatter_gather_ops": 28.098000000000003, "test_schema_check": 467.5414999999865, "test_segment_reductions": 4.952999999999999, "test_serialization": 58.50099999999998, "test_set_default_mobile_cpu_allocator": 0.483, "test_shape_ops": 2.3914999999999984, "test_show_pickle": 0.47750000000000004, "test_sort_and_select": 8.887499999999987, "test_sparse": 1012.4689999999971, "test_sparse_csr": 531.8489999999995, "test_sparse_semi_structured": 0.24800000000000016, "test_spectral_ops": 37.38099999999997, "test_stateless": 9.4025, "test_subclass": 0.7590000000000002, "test_sympy_utils": 29.455499999999997, "test_tensor_creation_ops": 146.3374999999994, "test_tensorboard": 47.4215, "test_tensorexpr": 181.6815, "test_tensorexpr_pybind": 1.4040000000000004, "test_testing": 59.42999999999989, "test_torch": 226.5464999999994, "test_transformers": 241.6855000000084, "test_type_hints": 0.40650000000000003, "test_type_info": 0.4625, "test_type_promotion": 13.320499999999974, "test_typing": 134.34449999999993, "test_unary_ufuncs": 789.2939999998991, "test_utils": 53.094500000000735, "test_view_ops": 32.66099999999999, "test_vulkan": 0.0015, "test_weak": 6.854999999999999, "test_xnnpack_integration": 9.3115, "torch_np/numpy_tests/core/test_dlpack": 0.0075, "torch_np/numpy_tests/core/test_dtype": 0.7290000000000001, "torch_np/numpy_tests/core/test_einsum": 30.4315, "torch_np/numpy_tests/core/test_getlimits": 0.508, "torch_np/numpy_tests/core/test_indexing": 0.7830000000000001, "torch_np/numpy_tests/core/test_multiarray": 62.30850000000004, "torch_np/numpy_tests/core/test_numeric": 8.3835, "torch_np/numpy_tests/core/test_numerictypes": 0.4770000000000001, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6240000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.018000000000000002, "torch_np/numpy_tests/core/test_scalarinherit": 0.0015, "torch_np/numpy_tests/core/test_scalarmath": 52.980500000000006, "torch_np/numpy_tests/core/test_shape_base": 0.9655000000000004, "torch_np/numpy_tests/fft/test_helper": 12.840999999999998, "torch_np/numpy_tests/fft/test_pocketfft": 6.242000000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.455, "torch_np/numpy_tests/lib/test_arraysetops": 0.7450000000000001, "torch_np/numpy_tests/lib/test_function_base": 3.654, "torch_np/numpy_tests/lib/test_histograms": 1.0240000000000002, "torch_np/numpy_tests/lib/test_index_tricks": 0.6145, "torch_np/numpy_tests/lib/test_shape_base_": 1.3175000000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.8735000000000002, "torch_np/numpy_tests/lib/test_type_check": 0.687, "torch_np/numpy_tests/linalg/test_linalg": 9.684500000000002, "torch_np/test_basic": 1.769500000000001, "torch_np/test_binary_ufuncs": 0.6260000000000002, "torch_np/test_dtype": 0.5025000000000002, "torch_np/test_function_base": 0.42700000000000005, "torch_np/test_ndarray_methods": 5.295499999999999, "torch_np/test_nep50_examples": 0.14650000000000007, "torch_np/test_random": 0.5685000000000001, "torch_np/test_reductions": 4.785999999999959, "torch_np/test_scalars_0D_arrays": 0.5330000000000001, "torch_np/test_ufuncs_basic": 1.953500000000001, "torch_np/test_unary_ufuncs": 0.6290000000000002}, "jit_legacy": {"test_jit_fuser_legacy": 0.01, "test_jit_legacy": 169.76199999999994}, "nogpu_AVX512": {"backends/xeon/test_launch": 2.549, "benchmark_utils/test_benchmark_utils": 0.747, "distributions/test_distributions": 86.7425, "dynamo/test_activation_checkpointing": 0.772, "dynamo/test_after_aot": 9.888, "dynamo/test_aot_autograd": 18.3355, "dynamo/test_aot_autograd_cache": 9.241999999999999, "dynamo/test_autograd_function": 4.034999999999999, "dynamo/test_backends": 20.967, "dynamo/test_backward_higher_order_ops": 18.015500000000003, "dynamo/test_base_output": 0.003, "dynamo/test_bytecode_hook": 6.287999999999999, "dynamo/test_bytecode_utils": 9.333499999999999, "dynamo/test_compile": 10.334, "dynamo/test_comptime": 0.9055000000000002, "dynamo/test_config": 0.8525, "dynamo/test_ctx_manager": 1.8120000000000007, "dynamo/test_debug_utils": 0.3785, "dynamo/test_decorators": 9.8855, "dynamo/test_deviceguard": 0.0235, "dynamo/test_dynamic_shapes": 623.8045000000001, "dynamo/test_exc": 2.8115, "dynamo/test_exceptions": 0.8075000000000001, "dynamo/test_export": 21.053999999999995, "dynamo/test_export_mutations": 0.8230000000000001, "dynamo/test_frame_init": 0.3245, "dynamo/test_functions": 33.33750000000003, "dynamo/test_fx_passes_pre_grad": 1.6675, "dynamo/test_global": 0.808, "dynamo/test_guard_manager": 0.3785, "dynamo/test_higher_order_ops": 26.787999999999997, "dynamo/test_hooks": 36.43550000000002, "dynamo/test_inline_inbuilt_nn_modules": 113.6740000000001, "dynamo/test_input_attr_tracking": 12.0185, "dynamo/test_interop": 0.8474999999999999, "dynamo/test_logging": 24.4985, "dynamo/test_minifier": 1.9245000000000003, "dynamo/test_misc": 77.2545000000001, "dynamo/test_model_output": 0.006, "dynamo/test_modules": 27.668999999999997, "dynamo/test_nops": 0.454, "dynamo/test_optimizers": 0.929, "dynamo/test_pre_dispatch": 0.7300000000000001, "dynamo/test_profiler": 1.8104999999999998, "dynamo/test_python_autograd": 1.0015, "dynamo/test_recompile_ux": 1.2320000000000002, "dynamo/test_recompiles": 1.2530000000000001, "dynamo/test_reorder_logs": 0.7905, "dynamo/test_repros": 49.61749999999997, "dynamo/test_resume": 0.664, "dynamo/test_sdpa": 0.7405, "dynamo/test_skip_non_tensor": 0.8240000000000001, "dynamo/test_sources": 0.7444999999999999, "dynamo/test_structured_trace": 16.769, "dynamo/test_subclasses": 20.351499999999994, "dynamo/test_subgraphs": 3.185999999999999, "dynamo/test_trace_rules": 1.8709999999999998, "dynamo/test_unspec": 19.63, "dynamo/test_verify_correctness": 0.8825000000000001, "dynamo/test_view": 0.9400000000000001, "export/test_converter": 7.155, "export/test_db": 4.338000000000001, "export/test_experimental": 1.4035, "export/test_export": 41.52350000000001, "export/test_export_nonstrict": 35.6135, "export/test_functionalized_assertions": 0.33, "export/test_hop": 0.0045000000000000005, "export/test_lift_unlift": 0.1325, "export/test_pass_infra": 1.2795000000000003, "export/test_passes": 17.038, "export/test_retraceability": 67.12300000000002, "export/test_schema": 0.376, "export/test_serdes": 42.88599999999998, "export/test_serialize": 12.812499999999998, "export/test_sparse": 81.31199999999986, "export/test_tools": 0.8140000000000001, "export/test_torchbind": 3.918499999999999, "export/test_tree_utils": 0.337, "export/test_unflatten": 4.352499999999999, "export/test_verifier": 1.2985000000000002, "functorch/test_aotdispatch": 40.995499999999986, "functorch/test_control_flow": 150.06949999999995, "functorch/test_dims": 38.6635, "functorch/test_eager_transforms": 0.16850000000000004, "functorch/test_logging": 0.4, "functorch/test_memory_efficient_fusion": 0.9649999999999999, "functorch/test_minifier": 0.597, "functorch/test_parsing": 0.35600000000000004, "functorch/test_rearrange": 0.40900000000000003, "functorch/test_vmap": 4.448499999999991, "functorch/test_vmap_registrations": 3.343499999999851, "higher_order_ops/test_with_effects": 9.251, "inductor/test_benchmark_fusion": 13.102500000000001, "inductor/test_binary_folding": 51.640499999999996, "inductor/test_codecache": 61.34949999999999, "inductor/test_codegen_triton": 0.3315, "inductor/test_compile_worker": 11.1825, "inductor/test_compiled_autograd": 663.7515000000002, "inductor/test_compiled_optimizers": 335.09600000000063, "inductor/test_config": 8.801, "inductor/test_control_flow": 0.11650000000000002, "inductor/test_cpu_repro": 915.7955000000002, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 15.8225, "inductor/test_debug_trace": 4.869999999999999, "inductor/test_decompose_mem_bound_mm": 0.0015, "inductor/test_distributed_patterns": 52.20700000000001, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 26.845499999999998, "inductor/test_flex_attention": 0.021000000000000008, "inductor/test_foreach": 24.485500000000037, "inductor/test_fused_attention": 211.18099999999998, "inductor/test_fx_fusion": 0.2965, "inductor/test_graph_transform_observer": 0.021, "inductor/test_group_batch_fusion": 0.29500000000000004, "inductor/test_indexing": 0.8885000000000001, "inductor/test_inductor_freezing": 75.5655, "inductor/test_minifier": 34.154, "inductor/test_minifier_isolate": 66.732, "inductor/test_mkldnn_pattern_matcher": 980.9180000000002, "inductor/test_standalone_compile": 23.854999999999997, "inductor/test_torchbind": 13.7685, "inductor/test_torchinductor": 2111.544999999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 2039.3904999999968, "inductor/test_torchinductor_dynamic_shapes": 2158.803, "inductor/test_triton_extension_backend": 0.847, "inductor/test_triton_kernels": 0.03600000000000002, "inductor/test_utils": 0.319, "lazy/test_debug_util": 0.398, "lazy/test_functionalization": 0.393, "lazy/test_generator": 0.395, "lazy/test_reuse_ir": 0.733, "lazy/test_step_closures": 3.3305, "lazy/test_ts_opinfo": 0.44549999999999995, "nn/test_convolution": 19.932000000000002, "nn/test_dropout": 0.14500000000000002, "nn/test_embedding": 0.07100000000000004, "nn/test_init": 5.623499999999999, "nn/test_lazy_modules": 0.49650000000000016, "nn/test_load_state_dict": 0.8045, "nn/test_module_hooks": 0.28, "nn/test_multihead_attention": 6.444999999999999, "nn/test_packed_sequence": 0.5490000000000002, "nn/test_parametrization": 1.0895000000000001, "nn/test_pooling": 0.81, "nn/test_pruning": 0.13300000000000006, "profiler/test_execution_trace": 0.15749999999999997, "profiler/test_memory_profiler": 6.0555, "profiler/test_profiler": 31.8335, "profiler/test_profiler_tree": 0.43600000000000005, "profiler/test_record_function": 0.394, "profiler/test_torch_tidy": 5.120999999999999, "test_ao_sparsity": 9.142, "test_autocast": 1.5005000000000002, "test_autograd": 37.041500000000056, "test_autograd_fallback": 0.5015000000000001, "test_bundled_inputs": 1.573, "test_comparison_utils": 0.322, "test_compile_benchmark_util": 0.0, "test_cpp_api_parity": 4.868499999999981, "test_cpp_extensions_aot_ninja": 0.049, "test_cpp_extensions_aot_no_ninja": 0.05400000000000001, "test_cpp_extensions_jit": 60.18899999999999, "test_cpp_extensions_mtia_backend": 1.063, "test_cpp_extensions_open_device_registration": 11.951000000000002, "test_cpp_extensions_stream_and_event": 1.072, "test_custom_backend": 0.10949999999999999, "test_custom_ops": 8.941999999999993, "test_dataloader": 253.01800000000006, "test_datapipe": 15.662999999999998, "test_decomp": 0.22199999999999998, "test_deploy": 0.325, "test_dispatch": 41.702999999999996, "test_dynamic_shapes": 6.192499999999992, "test_fake_tensor": 2.8180000000000005, "test_flop_counter": 0.5565000000000001, "test_function_schema": 0.7124999999999999, "test_functional_autograd_benchmark": 41.488, "test_functional_optim": 0.4605000000000001, "test_functionalization": 6.434499999999998, "test_futures": 1.28, "test_fx": 346.68399999999997, "test_fx_experimental": 20.8005, "test_fx_passes": 0.9095000000000003, "test_fx_reinplace_pass": 0.5615000000000001, "test_import_stats": 4.798, "test_itt": 0.33899999999999997, "test_jit": 141.88749999999996, "test_jit_autocast": 20.576500000000003, "test_jit_disabled": 0.4575000000000001, "test_jit_fuser_te": 182.26800000000006, "test_jit_llga_fuser": 3.0969999999999995, "test_legacy_vmap": 2.3895000000000004, "test_license": 0.3265, "test_logging": 3.4269999999999996, "test_maskedtensor": 0.8845000000000005, "test_meta": 0.06900000000000003, "test_mkl_verbose": 5.2355, "test_mkldnn_fusion": 78.22250000000001, "test_mkldnn_verbose": 4.948, "test_mobile_optimizer": 3.7855, "test_model_dump": 1.2489999999999999, "test_model_exports_to_core_aten": 0.27149999999999996, "test_module_tracker": 0.3325, "test_monitor": 0.5189999999999999, "test_multiprocessing": 66.33999999999999, "test_multiprocessing_spawn": 37.861999999999995, "test_namedtensor": 0.4175000000000001, "test_namedtuple_return_api": 2.263, "test_native_functions": 0.4790000000000001, "test_nestedtensor": 0.15650000000000008, "test_nn": 55.37449999999991, "test_numba_integration": 0.0015, "test_openmp": 6.6205, "test_ops": 0.0045000000000000005, "test_optim": 1.6900000000000006, "test_out_dtype_op": 0.3935, "test_overrides": 2.779499999999893, "test_package": 3.1359999999999983, "test_per_overload_api": 0.337, "test_prims": 0.018000000000000002, "test_proxy_tensor": 30.961999999999996, "test_pruning_op": 0.5545, "test_public_bindings": 7.614999999999999, "test_python_dispatch": 0.5945000000000003, "test_pytree": 0.6110000000000002, "test_quantization": 2209.0294999999996, "test_schema_check": 0.13550000000000006, "test_serialization": 52.41750000000002, "test_set_default_mobile_cpu_allocator": 0.3245, "test_show_pickle": 0.378, "test_sparse": 4.797499999999999, "test_sparse_csr": 0.629, "test_sparse_semi_structured": 0.0015, "test_stateless": 7.439, "test_subclass": 0.5500000000000002, "test_sympy_utils": 19.880499999999998, "test_tensorboard": 37.3725, "test_tensorexpr": 67.64250000000001, "test_tensorexpr_pybind": 1.1100000000000003, "test_testing": 32.1075, "test_torch": 7.8839999999999915, "test_type_hints": 0.319, "test_type_info": 0.34600000000000003, "test_typing": 101.67950000000006, "test_utils": 16.592499999999998, "test_vulkan": 0.003, "test_weak": 5.355999999999999, "test_xnnpack_integration": 11.7265, "torch_np/numpy_tests/core/test_dlpack": 0.0025, "torch_np/numpy_tests/core/test_dtype": 0.499, "torch_np/numpy_tests/core/test_einsum": 18.585500000000003, "torch_np/numpy_tests/core/test_getlimits": 0.3685, "torch_np/numpy_tests/core/test_indexing": 0.5660000000000002, "torch_np/numpy_tests/core/test_multiarray": 35.911500000000004, "torch_np/numpy_tests/core/test_numeric": 5.658499999999999, "torch_np/numpy_tests/core/test_numerictypes": 0.367, "torch_np/numpy_tests/core/test_scalar_ctors": 0.43300000000000005, "torch_np/numpy_tests/core/test_scalar_methods": 0.002, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 30.823500000000003, "torch_np/numpy_tests/core/test_shape_base": 0.6430000000000002, "torch_np/numpy_tests/fft/test_helper": 7.325500000000001, "torch_np/numpy_tests/fft/test_pocketfft": 4.647500000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.354, "torch_np/numpy_tests/lib/test_arraysetops": 0.5905, "torch_np/numpy_tests/lib/test_function_base": 2.3330000000000006, "torch_np/numpy_tests/lib/test_histograms": 0.6940000000000002, "torch_np/numpy_tests/lib/test_index_tricks": 0.4570000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.8805000000000002, "torch_np/numpy_tests/lib/test_twodim_base": 0.6165, "torch_np/numpy_tests/lib/test_type_check": 0.505, "torch_np/numpy_tests/linalg/test_linalg": 5.8665, "torch_np/test_basic": 0.7430000000000005, "torch_np/test_binary_ufuncs": 0.4760000000000001, "torch_np/test_dtype": 0.397, "torch_np/test_function_base": 0.334, "torch_np/test_ndarray_methods": 3.269500000000002, "torch_np/test_nep50_examples": 0.019, "torch_np/test_random": 0.41350000000000003, "torch_np/test_reductions": 3.1874999999999383, "torch_np/test_scalars_0D_arrays": 0.44850000000000007, "torch_np/test_ufuncs_basic": 1.3620000000000005, "torch_np/test_unary_ufuncs": 0.4885000000000001}, "nogpu_NO_AVX2": {"backends/xeon/test_launch": 2.731, "benchmark_utils/test_benchmark_utils": 0.795, "distributions/test_distributions": 93.219, "dynamo/test_activation_checkpointing": 0.8630000000000001, "dynamo/test_after_aot": 10.4275, "dynamo/test_aot_autograd": 20.061500000000002, "dynamo/test_aot_autograd_cache": 9.4175, "dynamo/test_autograd_function": 4.276499999999999, "dynamo/test_backends": 22.923499999999997, "dynamo/test_backward_higher_order_ops": 19.087, "dynamo/test_base_output": 0.004, "dynamo/test_bytecode_hook": 6.616333333333333, "dynamo/test_bytecode_utils": 10.0205, "dynamo/test_compile": 11.184, "dynamo/test_comptime": 0.9655000000000002, "dynamo/test_config": 0.9199999999999999, "dynamo/test_ctx_manager": 1.9385000000000008, "dynamo/test_debug_utils": 0.3885, "dynamo/test_decorators": 10.703499999999998, "dynamo/test_deviceguard": 0.0245, "dynamo/test_dynamic_shapes": 660.7795000000001, "dynamo/test_exc": 2.9869999999999997, "dynamo/test_exceptions": 0.8710000000000001, "dynamo/test_export": 23.330500000000004, "dynamo/test_export_mutations": 0.8925000000000001, "dynamo/test_frame_init": 0.369, "dynamo/test_functions": 35.81800000000013, "dynamo/test_fx_passes_pre_grad": 1.7399999999999998, "dynamo/test_global": 0.9190000000000002, "dynamo/test_guard_manager": 0.41550000000000004, "dynamo/test_higher_order_ops": 29.227499999999996, "dynamo/test_hooks": 38.863, "dynamo/test_inline_inbuilt_nn_modules": 120.35450000000009, "dynamo/test_input_attr_tracking": 12.733, "dynamo/test_interop": 0.9285, "dynamo/test_logging": 26.946000000000005, "dynamo/test_minifier": 2.1109999999999993, "dynamo/test_misc": 88.05600000000015, "dynamo/test_model_output": 0.006, "dynamo/test_modules": 28.765, "dynamo/test_nops": 0.48949999999999994, "dynamo/test_optimizers": 1.0255, "dynamo/test_pre_dispatch": 0.793, "dynamo/test_profiler": 1.9649999999999999, "dynamo/test_python_autograd": 1.066, "dynamo/test_recompile_ux": 1.3270000000000002, "dynamo/test_recompiles": 1.4340000000000002, "dynamo/test_reorder_logs": 0.8640000000000001, "dynamo/test_repros": 56.286000000000016, "dynamo/test_resume": 0.727, "dynamo/test_sdpa": 0.779, "dynamo/test_skip_non_tensor": 0.896, "dynamo/test_sources": 0.7945, "dynamo/test_structured_trace": 17.5765, "dynamo/test_subclasses": 22.006999999999998, "dynamo/test_subgraphs": 3.4914999999999985, "dynamo/test_trace_rules": 1.9139999999999997, "dynamo/test_unspec": 20.399999999999995, "dynamo/test_verify_correctness": 0.9505, "dynamo/test_view": 1.0419999999999998, "export/test_converter": 7.475000000000001, "export/test_db": 4.6555, "export/test_experimental": 1.4775, "export/test_export": 45.412499999999994, "export/test_export_nonstrict": 38.600999999999985, "export/test_functionalized_assertions": 0.3595, "export/test_hop": 0.0045000000000000005, "export/test_lift_unlift": 0.14800000000000002, "export/test_pass_infra": 1.3465000000000003, "export/test_passes": 18.533499999999997, "export/test_retraceability": 68.33800000000001, "export/test_schema": 0.42800000000000005, "export/test_serdes": 46.90749999999999, "export/test_serialize": 13.799000000000003, "export/test_sparse": 90.63399999999994, "export/test_tools": 0.856, "export/test_torchbind": 4.25, "export/test_tree_utils": 0.365, "export/test_unflatten": 4.664000000000001, "export/test_verifier": 1.4180000000000001, "functorch/test_aotdispatch": 44.44299999999999, "functorch/test_control_flow": 165.41150000000005, "functorch/test_dims": 45.926500000000004, "functorch/test_eager_transforms": 0.16600000000000004, "functorch/test_logging": 0.4235, "functorch/test_memory_efficient_fusion": 1.0385, "functorch/test_minifier": 0.6545, "functorch/test_parsing": 0.3845, "functorch/test_rearrange": 0.44250000000000006, "functorch/test_vmap": 4.681499999999991, "functorch/test_vmap_registrations": 3.493499999999839, "higher_order_ops/test_with_effects": 9.8705, "inductor/test_benchmark_fusion": 14.393, "inductor/test_binary_folding": 54.825500000000005, "inductor/test_codecache": 64.81499999999998, "inductor/test_codegen_triton": 0.3535, "inductor/test_compile_worker": 11.909500000000001, "inductor/test_compiled_autograd": 695.0170000000007, "inductor/test_compiled_optimizers": 349.13150000000064, "inductor/test_config": 9.4065, "inductor/test_control_flow": 0.1315, "inductor/test_cpu_repro": 978.9800000000004, "inductor/test_custom_lowering": 0.004, "inductor/test_custom_post_grad_passes": 16.3225, "inductor/test_debug_trace": 4.9559999999999995, "inductor/test_decompose_mem_bound_mm": 0.002, "inductor/test_distributed_patterns": 54.4195, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 28.536499999999997, "inductor/test_flex_attention": 0.02150000000000001, "inductor/test_foreach": 25.852500000000028, "inductor/test_fused_attention": 225.01350000000002, "inductor/test_fx_fusion": 0.29600000000000004, "inductor/test_graph_transform_observer": 0.0215, "inductor/test_group_batch_fusion": 0.314, "inductor/test_indexing": 0.9555, "inductor/test_inductor_freezing": 79.955, "inductor/test_minifier": 36.910500000000006, "inductor/test_minifier_isolate": 71.8015, "inductor/test_mkldnn_pattern_matcher": 1037.522, "inductor/test_standalone_compile": 25.289, "inductor/test_torchbind": 14.588, "inductor/test_torchinductor": 2223.536499999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 2140.1199999999976, "inductor/test_torchinductor_dynamic_shapes": 2271.431499999999, "inductor/test_triton_extension_backend": 0.911, "inductor/test_triton_kernels": 0.04750000000000002, "inductor/test_utils": 0.373, "lazy/test_debug_util": 0.4275, "lazy/test_functionalization": 0.44999999999999996, "lazy/test_generator": 0.446, "lazy/test_reuse_ir": 0.882, "lazy/test_step_closures": 3.3635, "lazy/test_ts_opinfo": 0.3925, "nn/test_convolution": 21.540499999999998, "nn/test_dropout": 0.21050000000000002, "nn/test_embedding": 0.07450000000000004, "nn/test_init": 5.783499999999998, "nn/test_lazy_modules": 0.5450000000000003, "nn/test_load_state_dict": 0.8905000000000001, "nn/test_module_hooks": 0.29350000000000004, "nn/test_multihead_attention": 7.0755, "nn/test_packed_sequence": 0.5915000000000001, "nn/test_parametrization": 1.2755000000000003, "nn/test_pooling": 0.861, "nn/test_pruning": 0.13950000000000007, "profiler/test_execution_trace": 0.16549999999999998, "profiler/test_memory_profiler": 7.237499999999999, "profiler/test_profiler": 32.7305, "profiler/test_profiler_tree": 0.4765000000000001, "profiler/test_record_function": 0.42500000000000004, "profiler/test_torch_tidy": 6.167999999999999, "test_ao_sparsity": 9.658000000000001, "test_autocast": 3.198, "test_autograd": 40.34050000000006, "test_autograd_fallback": 0.5475000000000001, "test_bundled_inputs": 2.404999999999999, "test_comparison_utils": 0.37, "test_compile_benchmark_util": 0.0015, "test_cpp_api_parity": 5.466499999999981, "test_cpp_extensions_aot_ninja": 0.054000000000000006, "test_cpp_extensions_aot_no_ninja": 0.05900000000000001, "test_cpp_extensions_jit": 65.11500000000001, "test_cpp_extensions_mtia_backend": 1.1395, "test_cpp_extensions_open_device_registration": 12.671000000000003, "test_cpp_extensions_stream_and_event": 1.1895, "test_custom_backend": 0.11399999999999999, "test_custom_ops": 9.728999999999992, "test_dataloader": 245.35800000000006, "test_datapipe": 16.6925, "test_decomp": 0.23149999999999998, "test_deploy": 0.365, "test_dispatch": 42.045, "test_dynamic_shapes": 6.456999999999993, "test_fake_tensor": 5.0055, "test_flop_counter": 0.775, "test_function_schema": 0.8025, "test_functional_autograd_benchmark": 45.672000000000004, "test_functional_optim": 0.5205, "test_functionalization": 7.608999999999997, "test_futures": 1.3355000000000001, "test_fx": 424.4014999999998, "test_fx_experimental": 25.439000000000007, "test_fx_passes": 1.0175, "test_fx_reinplace_pass": 0.6250000000000002, "test_import_stats": 5.281, "test_itt": 0.3565, "test_jit": 152.6635, "test_jit_autocast": 22.880000000000003, "test_jit_disabled": 0.5015000000000001, "test_jit_fuser_te": 186.91150000000005, "test_jit_llga_fuser": 4.477, "test_legacy_vmap": 2.4095000000000004, "test_license": 0.369, "test_logging": 3.6855, "test_maskedtensor": 0.9205000000000005, "test_meta": 0.08800000000000005, "test_mkl_verbose": 5.765000000000001, "test_mkldnn_fusion": 92.921, "test_mkldnn_verbose": 5.429, "test_mobile_optimizer": 4.0905000000000005, "test_model_dump": 1.304, "test_model_exports_to_core_aten": 0.3055, "test_module_tracker": 0.381, "test_monitor": 0.5695, "test_multiprocessing": 70.17399999999999, "test_multiprocessing_spawn": 41.619, "test_namedtensor": 0.4860000000000002, "test_namedtuple_return_api": 2.3855000000000004, "test_native_functions": 0.5150000000000001, "test_nestedtensor": 0.1835000000000001, "test_nn": 64.9720000000001, "test_numba_integration": 0.007, "test_openmp": 6.0535, "test_ops": 0.0045000000000000005, "test_optim": 1.8555000000000006, "test_out_dtype_op": 0.41950000000000004, "test_overrides": 2.826499999999889, "test_package": 3.738999999999999, "test_per_overload_api": 0.3645, "test_prims": 0.03, "test_proxy_tensor": 34.068, "test_pruning_op": 0.6060000000000001, "test_public_bindings": 7.9864999999999995, "test_python_dispatch": 0.6265000000000002, "test_pytree": 0.6110000000000002, "test_quantization": 2343.7585000000004, "test_schema_check": 0.15350000000000008, "test_serialization": 72.72450000000003, "test_set_default_mobile_cpu_allocator": 0.366, "test_show_pickle": 0.45999999999999996, "test_sparse": 5.0365, "test_sparse_csr": 0.647, "test_sparse_semi_structured": 0.0045000000000000005, "test_stateless": 8.401, "test_subclass": 0.5990000000000002, "test_sympy_utils": 20.177499999999995, "test_tensorboard": 47.507000000000005, "test_tensorexpr": 69.7875, "test_tensorexpr_pybind": 1.2115000000000005, "test_testing": 35.146, "test_torch": 9.273499999999986, "test_type_hints": 0.355, "test_type_info": 0.3745, "test_typing": 106.66200000000003, "test_utils": 18.893499999999996, "test_vulkan": 0.004, "test_weak": 6.0705, "test_xnnpack_integration": 12.141499999999999, "torch_np/numpy_tests/core/test_dlpack": 0.0025, "torch_np/numpy_tests/core/test_dtype": 0.528, "torch_np/numpy_tests/core/test_einsum": 19.245000000000005, "torch_np/numpy_tests/core/test_getlimits": 0.4005, "torch_np/numpy_tests/core/test_indexing": 0.5950000000000002, "torch_np/numpy_tests/core/test_multiarray": 36.55900000000001, "torch_np/numpy_tests/core/test_numeric": 5.7875, "torch_np/numpy_tests/core/test_numerictypes": 0.41150000000000003, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6350000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.006, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 31.107, "torch_np/numpy_tests/core/test_shape_base": 0.7135000000000002, "torch_np/numpy_tests/fft/test_helper": 7.442000000000001, "torch_np/numpy_tests/fft/test_pocketfft": 4.958, "torch_np/numpy_tests/lib/test_arraypad": 0.40750000000000003, "torch_np/numpy_tests/lib/test_arraysetops": 0.6555000000000001, "torch_np/numpy_tests/lib/test_function_base": 2.5625000000000004, "torch_np/numpy_tests/lib/test_histograms": 0.7110000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.48400000000000004, "torch_np/numpy_tests/lib/test_shape_base_": 0.9335, "torch_np/numpy_tests/lib/test_twodim_base": 0.6660000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.5370000000000001, "torch_np/numpy_tests/linalg/test_linalg": 6.162, "torch_np/test_basic": 0.7800000000000005, "torch_np/test_binary_ufuncs": 0.5285000000000002, "torch_np/test_dtype": 0.47600000000000003, "torch_np/test_function_base": 0.3705, "torch_np/test_ndarray_methods": 3.4760000000000013, "torch_np/test_nep50_examples": 0.02, "torch_np/test_random": 0.45100000000000007, "torch_np/test_reductions": 3.367999999999938, "torch_np/test_scalars_0D_arrays": 0.43150000000000005, "torch_np/test_ufuncs_basic": 1.4445000000000006, "torch_np/test_unary_ufuncs": 0.5845000000000002}}, "linux-focal-cuda12.4-py3.10-gcc9-sm86": {"default": {"backends/xeon/test_launch": 1.7133333333333336, "benchmark_utils/test_benchmark_utils": 1.8816666666666666, "distributions/test_distributions": 66.991, "dynamo/test_activation_checkpointing": 13.244333333333335, "dynamo/test_after_aot": 4.709666666666667, "dynamo/test_aot_autograd": 8.834333333333333, "dynamo/test_aot_autograd_cache": 14.499333333333334, "dynamo/test_autograd_function": 4.238333333333332, "dynamo/test_backends": 11.77833333333333, "dynamo/test_backward_higher_order_ops": 10.447666666666667, "dynamo/test_base_output": 0.0013333333333333333, "dynamo/test_bytecode_hook": 4.626, "dynamo/test_bytecode_utils": 4.618666666666666, "dynamo/test_compile": 5.328, "dynamo/test_comptime": 0.48766666666666675, "dynamo/test_config": 0.46666666666666673, "dynamo/test_ctx_manager": 2.936999999999999, "dynamo/test_cudagraphs": 3.1779999999999995, "dynamo/test_debug_utils": 0.3583333333333334, "dynamo/test_decorators": 4.976, "dynamo/test_deviceguard": 0.016, "dynamo/test_dynamic_shapes": 427.9600000000001, "dynamo/test_exc": 1.6979999999999997, "dynamo/test_exceptions": 0.4323333333333334, "dynamo/test_export": 13.943666666666664, "dynamo/test_export_mutations": 0.46000000000000013, "dynamo/test_frame_init": 0.20433333333333334, "dynamo/test_functions": 20.785666666666675, "dynamo/test_fx_passes_pre_grad": 1.2443333333333335, "dynamo/test_global": 0.4370000000000001, "dynamo/test_guard_manager": 0.2636666666666667, "dynamo/test_higher_order_ops": 25.294, "dynamo/test_hooks": 23.327333333333343, "dynamo/test_inline_inbuilt_nn_modules": 108.93466666666671, "dynamo/test_input_attr_tracking": 6.458666666666666, "dynamo/test_interop": 0.474, "dynamo/test_logging": 16.680999999999997, "dynamo/test_minifier": 2.0976666666666666, "dynamo/test_misc": 49.79266666666672, "dynamo/test_model_output": 0.0030000000000000005, "dynamo/test_modules": 17.230333333333334, "dynamo/test_nops": 0.27566666666666667, "dynamo/test_optimizers": 0.5256666666666666, "dynamo/test_pre_dispatch": 0.39399999999999996, "dynamo/test_profiler": 1.0953333333333333, "dynamo/test_python_autograd": 0.5333333333333333, "dynamo/test_recompile_ux": 0.7270000000000002, "dynamo/test_recompiles": 0.7220000000000001, "dynamo/test_reorder_logs": 0.4236666666666667, "dynamo/test_repros": 42.77966666666666, "dynamo/test_resume": 0.336, "dynamo/test_sdpa": 0.387, "dynamo/test_skip_non_tensor": 0.4456666666666667, "dynamo/test_sources": 0.39200000000000007, "dynamo/test_structured_trace": 13.931333333333335, "dynamo/test_subclasses": 16.626666666666665, "dynamo/test_subgraphs": 1.966666666666666, "dynamo/test_trace_rules": 1.1503333333333332, "dynamo/test_unspec": 10.443666666666667, "dynamo/test_verify_correctness": 0.484, "dynamo/test_view": 0.5283333333333333, "export/test_converter": 6.241333333333333, "export/test_db": 2.6793333333333336, "export/test_experimental": 0.797, "export/test_export": 24.126666666666665, "export/test_export_nonstrict": 21.541666666666668, "export/test_functionalized_assertions": 0.20866666666666667, "export/test_hop": 2.4339999999999997, "export/test_lift_unlift": 0.08600000000000001, "export/test_pass_infra": 0.7236666666666669, "export/test_passes": 10.96566666666667, "export/test_retraceability": 35.527666666666654, "export/test_schema": 0.24, "export/test_serdes": 25.52566666666667, "export/test_serialize": 8.458, "export/test_sparse": 52.99733333333322, "export/test_tools": 0.4426666666666666, "export/test_torchbind": 2.772, "export/test_tree_utils": 0.20933333333333334, "export/test_unflatten": 2.7453333333333334, "export/test_verifier": 0.7526666666666665, "functorch/test_ac": 12.021666666666668, "functorch/test_aotdispatch": 29.787999999999993, "functorch/test_control_flow": 94.84133333333334, "functorch/test_dims": 26.603333333333335, "functorch/test_eager_transforms": 9.543, "functorch/test_logging": 0.24133333333333332, "functorch/test_memory_efficient_fusion": 5.2876666666666665, "functorch/test_minifier": 0.3840000000000001, "functorch/test_ops": 3948.7606666666375, "functorch/test_parsing": 0.211, "functorch/test_rearrange": 0.24100000000000002, "functorch/test_vmap": 265.3663333333329, "functorch/test_vmap_registrations": 1.9829999999998966, "higher_order_ops/test_with_effects": 6.350666666666666, "inductor/test_aot_inductor": 6181.671333333333, "inductor/test_benchmark_fusion": 95.98899999999999, "inductor/test_binary_folding": 36.623333333333335, "inductor/test_codecache": 127.206, "inductor/test_codegen_triton": 0.19533333333333336, "inductor/test_compile_worker": 8.811333333333332, "inductor/test_compiled_autograd": 431.3640000000005, "inductor/test_compiled_optimizers": 1981.5629999999999, "inductor/test_config": 5.2076666666666656, "inductor/test_control_flow": 122.84700000000002, "inductor/test_coordinate_descent_tuner": 3.0853333333333333, "inductor/test_cpu_repro": 593.6649999999998, "inductor/test_cuda_cpp_wrapper": 1985.7903333333334, "inductor/test_cuda_repro": 91.779, "inductor/test_cudagraph_trees": 70.73099999999998, "inductor/test_custom_lowering": 2.725, "inductor/test_custom_post_grad_passes": 10.093666666666666, "inductor/test_cutlass_backend": 82.69433333333335, "inductor/test_debug_trace": 12.617666666666667, "inductor/test_decompose_mem_bound_mm": 30.544, "inductor/test_dependencies": 0.18633333333333332, "inductor/test_distributed_patterns": 34.010666666666665, "inductor/test_efficient_conv_bn_eval": 97.81400000000001, "inductor/test_extension_backend": 16.487333333333336, "inductor/test_flex_attention": 625.9829999999998, "inductor/test_foreach": 284.6766666666669, "inductor/test_fp8": 0.013333333333333338, "inductor/test_fused_attention": 213.07533333333333, "inductor/test_fx_fusion": 0.18833333333333332, "inductor/test_graph_transform_observer": 0.012000000000000002, "inductor/test_group_batch_fusion": 101.64633333333335, "inductor/test_indexing": 2.299, "inductor/test_inductor_freezing": 78.24033333333333, "inductor/test_inplacing_pass": 5.451333333333333, "inductor/test_kernel_benchmark": 152.20933333333335, "inductor/test_layout_optim": 10.903999999999998, "inductor/test_loop_ordering": 3.5976666666666666, "inductor/test_max_autotune": 298.5849999999999, "inductor/test_memory_planning": 27.886666666666667, "inductor/test_metrics": 3.5876666666666672, "inductor/test_minifier": 27.242333333333335, "inductor/test_minifier_isolate": 95.48899999999999, "inductor/test_mkldnn_pattern_matcher": 496.1829999999998, "inductor/test_mmdecomp": 6.434, "inductor/test_move_constructors_to_cuda": 14.190666666666667, "inductor/test_multi_kernel": 69.41066666666667, "inductor/test_pad_mm": 122.63966666666666, "inductor/test_padding": 13.099333333333332, "inductor/test_pattern_matcher": 95.22466666666668, "inductor/test_perf": 61.133, "inductor/test_profiler": 6.1129999999999995, "inductor/test_select_algorithm": 109.42533333333334, "inductor/test_smoke": 5.418666666666667, "inductor/test_snode_runtime": 8.714666666666668, "inductor/test_split_cat_fx_passes": 95.69233333333334, "inductor/test_standalone_compile": 18.621333333333336, "inductor/test_torchbind": 6.133, "inductor/test_torchinductor": 2518.2973333333325, "inductor/test_torchinductor_codegen_dynamic_shapes": 2439.612666666666, "inductor/test_torchinductor_dynamic_shapes": 2966.2306666666664, "inductor/test_torchinductor_opinfo": 8802.64833333333, "inductor/test_torchinductor_strided_blocks": 17.596, "inductor/test_triton_extension_backend": 0.8173333333333334, "inductor/test_triton_heuristics": 20.036, "inductor/test_triton_kernels": 87.69333333333334, "inductor/test_triton_wrapper": 8.636666666666665, "inductor/test_unbacked_symints": 18.116333333333337, "inductor/test_utils": 0.20833333333333334, "lazy/test_debug_util": 0.25166666666666665, "lazy/test_functionalization": 0.257, "lazy/test_generator": 0.267, "lazy/test_reuse_ir": 0.39566666666666667, "lazy/test_step_closures": 2.2189999999999994, "lazy/test_ts_opinfo": 0.236, "nn/test_convolution": 71.04766666666613, "nn/test_dropout": 0.6646666666666667, "nn/test_embedding": 14.413000000000004, "nn/test_init": 3.446333333333332, "nn/test_lazy_modules": 0.2710000000000001, "nn/test_load_state_dict": 0.6946666666666669, "nn/test_module_hooks": 0.17533333333333337, "nn/test_multihead_attention": 4.941666666666666, "nn/test_packed_sequence": 0.3803333333333334, "nn/test_parametrization": 0.9053333333333334, "nn/test_pooling": 5.562333333333331, "nn/test_pruning": 0.0776666666666667, "profiler/test_execution_trace": 2.077666666666667, "profiler/test_memory_profiler": 3.9706666666666663, "profiler/test_profiler": 27.597333333333335, "profiler/test_profiler_tree": 0.2763333333333334, "profiler/test_record_function": 0.259, "profiler/test_torch_tidy": 3.601333333333333, "test_ao_sparsity": 8.887333333333332, "test_autocast": 1.4853333333333334, "test_autograd": 27.396000000000004, "test_autograd_fallback": 0.32300000000000006, "test_binary_ufuncs": 121.23300000000148, "test_bundled_inputs": 0.8736666666666668, "test_comparison_utils": 0.21566666666666667, "test_compile_benchmark_util": 0.0, "test_complex": 0.08533333333333336, "test_content_store": 2.7793333333333323, "test_cpp_api_parity": 8.69033333333332, "test_cpp_extensions_aot_ninja": 0.308, "test_cpp_extensions_aot_no_ninja": 0.28, "test_cpp_extensions_jit": 92.81566666666667, "test_cpp_extensions_mtia_backend": 0.001, "test_cpp_extensions_open_device_registration": 6.274333333333335, "test_cpp_extensions_stream_and_event": 0.001, "test_cuda": 77.17466666666667, "test_cuda_expandable_segments": 82.70733333333334, "test_cuda_multigpu": 0.49500000000000005, "test_cuda_nvml_based_avail": 0.28200000000000003, "test_cuda_primary_ctx": 0.0030000000000000005, "test_cuda_sanitizer": 0.278, "test_cuda_trace": 1.7686666666666664, "test_custom_backend": 0.07366666666666666, "test_custom_ops": 7.525666666666662, "test_dataloader": 237.6016666666667, "test_datapipe": 9.635333333333334, "test_decomp": 10414.725333333328, "test_deploy": 0.20533333333333334, "test_dispatch": 32.551000000000016, "test_dlpack": 0.2583333333333335, "test_dynamic_shapes": 4.164999999999995, "test_expanded_weights": 12.943666666666665, "test_fake_tensor": 17.663333333333348, "test_flop_counter": 0.66, "test_foreach": 378.3100000000068, "test_function_schema": 0.49766666666666665, "test_functional_autograd_benchmark": 17.002, "test_functional_optim": 0.29500000000000004, "test_functionalization": 3.5806666666666644, "test_functionalization_of_rng_ops": 2.0283333333333333, "test_futures": 0.835, "test_fx": 218.21400000000003, "test_fx_experimental": 12.980333333333334, "test_fx_passes": 0.5176666666666669, "test_fx_reinplace_pass": 0.35466666666666674, "test_import_stats": 3.317, "test_indexing": 1.6976666666666633, "test_itt": 0.20666666666666667, "test_jit": 97.197, "test_jit_autocast": 26.709000000000003, "test_jit_disabled": 0.3006666666666667, "test_jit_fuser_te": 509.0413333333343, "test_jit_llga_fuser": 0.06366666666666666, "test_jiterator": 13.616333333333365, "test_legacy_vmap": 2.125666666666667, "test_license": 0.21033333333333334, "test_linalg": 796.7983333333315, "test_logging": 2.3216666666666668, "test_masked": 25.264999999999997, "test_maskedtensor": 6.013333333333257, "test_matmul_cuda": 88.71033333333332, "test_meta": 1697.4323333333007, "test_mkl_verbose": 3.5406666666666666, "test_mkldnn_fusion": 39.56033333333333, "test_mkldnn_verbose": 3.385333333333333, "test_mobile_optimizer": 2.6, "test_model_dump": 0.915, "test_model_exports_to_core_aten": 0.12266666666666666, "test_module_tracker": 0.22766666666666666, "test_modules": 666.0156666666497, "test_monitor": 0.327, "test_multiprocessing": 97.39533333333333, "test_multiprocessing_spawn": 25.941000000000003, "test_namedtensor": 0.673, "test_namedtuple_return_api": 1.6740000000000002, "test_native_functions": 0.31600000000000006, "test_native_mha": 0.6470000000000002, "test_nestedtensor": 8.337333333333326, "test_nn": 162.21633333333762, "test_numba_integration": 0.09366666666666668, "test_numpy_interop": 0.1373333333333334, "test_openmp": 3.517666666666667, "test_ops": 4050.472666666639, "test_ops_fwd_gradients": 968.2469999999997, "test_ops_gradients": 1697.7003333332843, "test_ops_jit": 926.656, "test_optim": 220.696333333333, "test_out_dtype_op": 0.2803333333333334, "test_overrides": 1.867333333333259, "test_package": 1.885999999999999, "test_per_overload_api": 0.21, "test_prims": 0.337, "test_proxy_tensor": 22.717, "test_pruning_op": 0.393, "test_public_bindings": 4.592, "test_python_dispatch": 1.3050000000000004, "test_pytree": 0.3640000000000001, "test_quantization": 2725.9313333333334, "test_reductions": 129.9406666666671, "test_scatter_gather_ops": 28.136, "test_schema_check": 235.00066666665978, "test_segment_reductions": 2.3466666666666653, "test_serialization": 21.906999999999993, "test_set_default_mobile_cpu_allocator": 0.20333333333333334, "test_shape_ops": 1.3353333333333322, "test_show_pickle": 0.221, "test_sort_and_select": 3.6166666666666636, "test_sparse": 731.4183333333334, "test_sparse_csr": 1631.3883333333335, "test_sparse_semi_structured": 31.594999999999995, "test_spectral_ops": 18.445999999999966, "test_stateless": 4.875000000000001, "test_subclass": 0.3503333333333334, "test_sympy_utils": 12.645333333333332, "test_tensor_creation_ops": 85.25766666666686, "test_tensorboard": 22.376, "test_tensorexpr": 97.68599999999999, "test_tensorexpr_pybind": 0.7663333333333334, "test_testing": 30.758333333333354, "test_torch": 74.61933333333339, "test_transformers": 1373.8526666660257, "test_type_hints": 0.20099999999999998, "test_type_info": 0.21766666666666667, "test_type_promotion": 7.0793333333333015, "test_typing": 59.24699999999998, "test_unary_ufuncs": 332.5299999999432, "test_utils": 25.83066666666726, "test_view_ops": 15.524666666666668, "test_vulkan": 0.0, "test_weak": 3.5453333333333323, "test_xnnpack_integration": 38.964000000000006, "torch_np/numpy_tests/core/test_dlpack": 0.0033333333333333335, "torch_np/numpy_tests/core/test_dtype": 0.3196666666666667, "torch_np/numpy_tests/core/test_einsum": 12.092333333333334, "torch_np/numpy_tests/core/test_getlimits": 0.22, "torch_np/numpy_tests/core/test_indexing": 0.34266666666666684, "torch_np/numpy_tests/core/test_multiarray": 26.453333333333337, "torch_np/numpy_tests/core/test_numeric": 3.723333333333333, "torch_np/numpy_tests/core/test_numerictypes": 0.24, "torch_np/numpy_tests/core/test_scalar_ctors": 0.2716666666666667, "torch_np/numpy_tests/core/test_scalar_methods": 0.0, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 22.644000000000002, "torch_np/numpy_tests/core/test_shape_base": 0.4190000000000002, "torch_np/numpy_tests/fft/test_helper": 5.278666666666667, "torch_np/numpy_tests/fft/test_pocketfft": 2.869000000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.22, "torch_np/numpy_tests/lib/test_arraysetops": 0.34366666666666673, "torch_np/numpy_tests/lib/test_function_base": 1.4553333333333338, "torch_np/numpy_tests/lib/test_histograms": 0.4376666666666667, "torch_np/numpy_tests/lib/test_index_tricks": 0.2816666666666667, "torch_np/numpy_tests/lib/test_shape_base_": 0.5516666666666667, "torch_np/numpy_tests/lib/test_twodim_base": 0.41100000000000003, "torch_np/numpy_tests/lib/test_type_check": 0.28800000000000003, "torch_np/numpy_tests/linalg/test_linalg": 4.226666666666667, "torch_np/test_basic": 0.7046666666666671, "torch_np/test_binary_ufuncs": 0.2986666666666667, "torch_np/test_dtype": 0.2436666666666667, "torch_np/test_function_base": 0.209, "torch_np/test_ndarray_methods": 2.376000000000001, "torch_np/test_nep50_examples": 0.011666666666666667, "torch_np/test_random": 0.2566666666666667, "torch_np/test_reductions": 2.1333333333332942, "torch_np/test_scalars_0D_arrays": 0.25266666666666665, "torch_np/test_ufuncs_basic": 0.8390000000000004, "torch_np/test_unary_ufuncs": 0.30400000000000005}}, "linux-focal-py3.11-clang10": {"crossref": {"backends/xeon/test_launch": 1.8153333333333332, "benchmark_utils/test_benchmark_utils": 1.5139999999999996, "distributions/test_constraints": 0.09766666666666672, "distributions/test_distributions": 45.28000000000001, "export/test_converter": 7.726, "export/test_db": 3.0063333333333326, "export/test_export": 35.17833333333334, "export/test_functionalized_assertions": 0.018666666666666668, "export/test_funtionalized_assertions": 0.5196666666666667, "export/test_hop": 2.8850000000000002, "export/test_lift_unlift": 0.09333333333333334, "export/test_pass_infra": 0.7616666666666667, "export/test_passes": 12.876333333333335, "export/test_safeguard": 0.642, "export/test_schema": 0.05566666666666666, "export/test_serialize": 8.901333333333332, "export/test_sparse": 88.09766666666667, "export/test_tools": 0.3419999999999999, "export/test_torchbind": 3.528333333333333, "export/test_tree_utils": 0.023333333333333334, "export/test_unflatten": 3.3706666666666667, "export/test_upgrade": 0.2272, "export/test_verifier": 0.798, "functorch/test_aotdispatch": 3387.8616666666676, "functorch/test_control_flow": 124.48833333333334, "functorch/test_dims": 27.721666666666668, "functorch/test_eager_transforms": 18.673666666666662, "functorch/test_logging": 0.056, "functorch/test_memory_efficient_fusion": 0.41933333333333334, "functorch/test_minifier": 0.20033333333333334, "functorch/test_ops": 3437.7126666666663, "functorch/test_parsing": 0.033999999999999996, "functorch/test_rearrange": 0.08700000000000001, "functorch/test_vmap": 659.913333333333, "functorch/test_vmap_registrations": 3.065666666666555, "higher_order_ops/test_with_effects": 10.741666666666667, "inductor/test_fx_fusion": 0.06166666666666667, "inductor/test_mmdecomp": 0.03266666666666668, "lazy/test_debug_util": 0.075, "lazy/test_functionalization": 0.066, "lazy/test_generator": 0.05966666666666667, "lazy/test_reuse_ir": 0.2883333333333334, "lazy/test_step_closures": 2.0113333333333334, "lazy/test_ts_opinfo": 10.09266666666665, "nn/test_convolution": 19.936333333333284, "nn/test_dropout": 0.5413333333333333, "nn/test_embedding": 10.75866666666667, "nn/test_init": 3.4909999999999997, "nn/test_lazy_modules": 0.5450000000000003, "nn/test_load_state_dict": 0.9343333333333333, "nn/test_module_hooks": 0.2986666666666667, "nn/test_multihead_attention": 8.021333333333333, "nn/test_packed_sequence": 0.28400000000000003, "nn/test_parametrization": 1.2276666666666662, "nn/test_pooling": 31.319333333333333, "nn/test_pruning": 0.12066666666666674, "profiler/test_execution_trace": 0.15466666666666667, "profiler/test_memory_profiler": 5.066, "profiler/test_profiler": 22.943, "profiler/test_profiler_tree": 0.05033333333333334, "profiler/test_record_function": 0.09866666666666668, "profiler/test_torch_tidy": 4.0073333333333325, "test_ao_sparsity": 9.938, "test_autocast": 0.6003333333333334, "test_autograd": 28.631000000000014, "test_autograd_fallback": 0.1266666666666667, "test_binary_ufuncs": 138.20000000000098, "test_bundled_inputs": 1.0250000000000001, "test_comparison_utils": 0.019000000000000003, "test_compile_benchmark_util": 0.0003333333333333333, "test_complex": 0.05766666666666668, "test_content_store": 6.859666666666667, "test_cpp_api_parity": 3.413666666666655, "test_cpp_extensions_aot_ninja": 0.05400000000000001, "test_cpp_extensions_aot_no_ninja": 0.053666666666666675, "test_cpp_extensions_jit": 28.386000000000006, "test_cpp_extensions_mtia_backend": 0.4669999999999999, "test_cpp_extensions_open_device_registration": 8.549000000000001, "test_cpp_extensions_stream_and_event": 0.45766666666666667, "test_custom_backend": 0.07133333333333332, "test_custom_ops": 10.595333333333329, "test_dataloader": 129.15466666666666, "test_datapipe": 12.88433333333333, "test_decomp": 255.92266666666742, "test_deploy": 0.012333333333333333, "test_dispatch": 24.808999999999997, "test_dlpack": 0.2243333333333335, "test_dynamic_shapes": 4.55433333333333, "test_expanded_weights": 8.431666666666667, "test_fake_tensor": 1.8543333333333336, "test_flop_counter": 0.6113333333333334, "test_foreach": 70.67266666666703, "test_function_schema": 0.317, "test_functional_autograd_benchmark": 36.188, "test_functional_optim": 0.233, "test_functionalization": 4.489666666666665, "test_functionalization_of_rng_ops": 0.026333333333333334, "test_futures": 0.6886666666666666, "test_fx": 228.0203333333333, "test_fx_experimental": 72.4466666666667, "test_fx_passes": 0.5666666666666669, "test_fx_reinplace_pass": 0.20800000000000005, "test_import_stats": 3.357666666666667, "test_indexing": 2.0719999999999974, "test_itt": 0.014666666666666666, "test_jit": 129.67066666666676, "test_jit_autocast": 16.954333333333334, "test_jit_cuda_fuser": 0.009000000000000001, "test_jit_disabled": 0.113, "test_jit_fuser_te": 244.0806666666672, "test_jit_llga_fuser": 55.20066666666668, "test_legacy_vmap": 2.1343333333333336, "test_license": 0.013999999999999999, "test_linalg": 163.72100000000094, "test_logging": 2.376666666666667, "test_masked": 21.453666666666674, "test_maskedtensor": 8.52899999999998, "test_meta": 177.02299999995466, "test_mkl_verbose": 3.9716666666666662, "test_mkldnn": 117.02299999999998, "test_mkldnn_fusion": 62.35999999999999, "test_mkldnn_verbose": 3.641, "test_mobile_optimizer": 2.7449999999999997, "test_model_dump": 1.2089999999999999, "test_model_exports_to_core_aten": 0.014333333333333332, "test_module_init": 2.0139999999999927, "test_module_tracker": 0.024000000000000004, "test_modules": 539.1729999999843, "test_monitor": 0.8036666666666666, "test_multiprocessing": 44.64666666666667, "test_multiprocessing_spawn": 25.255666666666666, "test_namedtensor": 0.3953333333333335, "test_namedtuple_return_api": 1.051, "test_native_functions": 0.14, "test_native_mha": 0.2110000000000001, "test_nestedtensor": 19.719000000000015, "test_nn": 147.5380000000003, "test_numba_integration": 0.004666666666666667, "test_numpy_interop": 0.2533333333333334, "test_nvfuser_frontend": 0.0, "test_openmp": 6.233333333333333, "test_ops": 2590.7106666666564, "test_ops_fwd_gradients": 704.1233333333294, "test_ops_gradients": 1227.891666666665, "test_ops_jit": 1066.9666666666649, "test_optim": 49.25266666666669, "test_out_dtype_op": 0.337, "test_overrides": 1.6146666666666167, "test_package": 2.757333333333333, "test_per_overload_api": 0.02033333333333333, "test_prims": 0.14933333333333335, "test_proxy_tensor": 751.2393333333351, "test_pruning_op": 0.3516666666666666, "test_public_bindings": 5.301333333333333, "test_python_dispatch": 0.5270000000000001, "test_pytree": 0.2140000000000001, "test_quantization": 2198.823, "test_reductions": 197.7653333333212, "test_scatter_gather_ops": 6.734000000000001, "test_schema_check": 191.98899999999614, "test_segment_reductions": 1.4666666666666668, "test_serialization": 35.596, "test_set_default_mobile_cpu_allocator": 0.014333333333333332, "test_shape_ops": 1.2926666666666655, "test_show_pickle": 0.019, "test_sort_and_select": 2.132666666666663, "test_sparse": 892.9219999999995, "test_sparse_csr": 209.347666666667, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 6.207333333333323, "test_stateless": 5.119, "test_subclass": 0.21733333333333346, "test_sympy_utils": 13.626666666666665, "test_tensor_creation_ops": 27.554000000000055, "test_tensorboard": 0.09633333333333334, "test_tensorexpr": 46.45433333333333, "test_tensorexpr_pybind": 0.6283333333333334, "test_testing": 38.600999999999964, "test_torch": 20.927999999999983, "test_transformers": 309.2373333333323, "test_type_hints": 0.013666666666666666, "test_type_info": 0.026333333333333337, "test_type_promotion": 3.7876666666666616, "test_typing": 73.20100000000001, "test_unary_ufuncs": 456.16466666655225, "test_utils": 47.30600000000039, "test_view_ops": 18.33933333333333, "test_vulkan": 0.0006666666666666666, "test_weak": 4.750333333333333, "test_xnnpack_integration": 44.65, "torch_np/numpy_tests/core/test_dlpack": 0.19033333333333347, "torch_np/numpy_tests/core/test_dtype": 0.3033333333333334, "torch_np/numpy_tests/core/test_einsum": 14.891, "torch_np/numpy_tests/core/test_getlimits": 0.06166666666666667, "torch_np/numpy_tests/core/test_indexing": 0.2203333333333334, "torch_np/numpy_tests/core/test_multiarray": 37.06333333333333, "torch_np/numpy_tests/core/test_numeric": 5.024666666666667, "torch_np/numpy_tests/core/test_numerictypes": 0.08100000000000003, "torch_np/numpy_tests/core/test_scalar_ctors": 0.15366666666666673, "torch_np/numpy_tests/core/test_scalar_methods": 0.008, "torch_np/numpy_tests/core/test_scalarinherit": 0.0003333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 25.482, "torch_np/numpy_tests/core/test_shape_base": 0.5046666666666669, "torch_np/numpy_tests/fft/test_helper": 5.523000000000001, "torch_np/numpy_tests/fft/test_pocketfft": 5.5106666666666655, "torch_np/numpy_tests/lib/test_arraypad": 0.09100000000000001, "torch_np/numpy_tests/lib/test_arraysetops": 0.22333333333333338, "torch_np/numpy_tests/lib/test_function_base": 2.3426666666666676, "torch_np/numpy_tests/lib/test_histograms": 0.3746666666666667, "torch_np/numpy_tests/lib/test_index_tricks": 0.11533333333333334, "torch_np/numpy_tests/lib/test_shape_base_": 0.44266666666666676, "torch_np/numpy_tests/lib/test_twodim_base": 0.23233333333333336, "torch_np/numpy_tests/lib/test_type_check": 0.26699999999999996, "torch_np/numpy_tests/linalg/test_linalg": 10.729000000000001, "torch_np/test_basic": 0.5913333333333338, "torch_np/test_binary_ufuncs": 0.13333333333333341, "torch_np/test_dtype": 0.07433333333333338, "torch_np/test_function_base": 0.025666666666666667, "torch_np/test_ndarray_methods": 5.304999999999997, "torch_np/test_nep50_examples": 3.4576666666665457, "torch_np/test_random": 0.07400000000000004, "torch_np/test_reductions": 2.9353333333332934, "torch_np/test_scalars_0D_arrays": 0.06933333333333336, "torch_np/test_ufuncs_basic": 1.197, "torch_np/test_unary_ufuncs": 0.1400000000000001}, "default": {"backends/xeon/test_launch": 1.7436666666666667, "benchmark_utils/test_benchmark_utils": 1.1376666666666668, "distributions/test_constraints": 0.08700000000000006, "distributions/test_distributions": 42.175999999999995, "dynamo/test_activation_checkpointing": 0.35133333333333333, "dynamo/test_after_aot": 5.8500000000000005, "dynamo/test_allow_inline_skip": 0.319, "dynamo/test_aot_autograd": 13.870999999999997, "dynamo/test_aot_autograd_cache": 18.339000000000002, "dynamo/test_autograd_function": 2.947333333333333, "dynamo/test_backends": 13.621, "dynamo/test_backward_higher_order_ops": 12.419000000000002, "dynamo/test_base_output": 0.0026666666666666666, "dynamo/test_bytecode_hook": 5.659249999999999, "dynamo/test_bytecode_utils": 6.603333333333333, "dynamo/test_compile": 7.539999999999999, "dynamo/test_comptime": 0.47233333333333344, "dynamo/test_config": 0.2863333333333334, "dynamo/test_cpp_guard_manager": 175.39975000000007, "dynamo/test_ctx_manager": 1.6719999999999995, "dynamo/test_debug_utils": 0.037000000000000005, "dynamo/test_decorators": 7.450333333333333, "dynamo/test_deviceguard": 0.015666666666666666, "dynamo/test_dynamic_shapes": 664.0706666666667, "dynamo/test_exc": 1.6673333333333333, "dynamo/test_exceptions": 0.26433333333333336, "dynamo/test_export": 17.884666666666664, "dynamo/test_export_mutations": 0.2963333333333334, "dynamo/test_frame_init": 0.015333333333333332, "dynamo/test_functions": 18.16366666666667, "dynamo/test_fx_passes_pre_grad": 0.9786666666666667, "dynamo/test_global": 0.3153333333333334, "dynamo/test_guard_manager": 0.053333333333333365, "dynamo/test_higher_order_ops": 27.252, "dynamo/test_hooks": 26.399, "dynamo/test_inline_inbuilt_nn_modules": 117.97866666666674, "dynamo/test_input_attr_tracking": 8.805, "dynamo/test_interop": 0.4046666666666667, "dynamo/test_logging": 15.845666666666666, "dynamo/test_minifier": 1.4163333333333332, "dynamo/test_misc": 56.2330000000001, "dynamo/test_model_output": 0.003666666666666667, "dynamo/test_modules": 25.272000000000002, "dynamo/test_nops": 0.13166666666666668, "dynamo/test_optimizers": 0.6536666666666667, "dynamo/test_pre_dispatch": 0.19133333333333333, "dynamo/test_profiler": 1.0086666666666666, "dynamo/test_python_autograd": 0.532, "dynamo/test_recompile_ux": 0.6033333333333334, "dynamo/test_recompiles": 0.7770000000000001, "dynamo/test_reorder_logs": 0.24533333333333332, "dynamo/test_replay_record": 0.714, "dynamo/test_repros": 58.23700000000002, "dynamo/test_resume": 0.1366666666666667, "dynamo/test_sdpa": 0.19400000000000003, "dynamo/test_skip_non_tensor": 0.27166666666666667, "dynamo/test_sources": 0.19533333333333336, "dynamo/test_structured_trace": 15.597666666666663, "dynamo/test_subclasses": 16.54733333333333, "dynamo/test_subgraphs": 2.290333333333333, "dynamo/test_trace_rules": 0.8223333333333334, "dynamo/test_triton_kernels": 0.015333333333333332, "dynamo/test_unspec": 13.120666666666667, "dynamo/test_verify_correctness": 0.29233333333333333, "dynamo/test_view": 0.4386666666666667, "export/test_converter": 6.300666666666667, "export/test_db": 3.280333333333333, "export/test_experimental": 0.8113333333333334, "export/test_export": 31.746333333333336, "export/test_export_nonstrict": 28.98533333333333, "export/test_export_predispatch": 32.14833333333334, "export/test_functionalized_assertions": 0.017666666666666667, "export/test_funtionalized_assertions": 0.5246666666666667, "export/test_hop": 2.789666666666667, "export/test_lift_unlift": 0.09999999999999999, "export/test_pass_infra": 0.6643333333333334, "export/test_passes": 13.072333333333333, "export/test_retraceability": 44.967666666666666, "export/test_safeguard": 0.6583333333333333, "export/test_schema": 0.05266666666666667, "export/test_serdes": 31.213999999999995, "export/test_serialize": 9.008333333333335, "export/test_sparse": 75.27199999999995, "export/test_tools": 0.33899999999999997, "export/test_torchbind": 3.209666666666666, "export/test_tree_utils": 0.013666666666666666, "export/test_unflatten": 2.9600000000000004, "export/test_upgrade": 0.2305, "export/test_verifier": 0.8416666666666667, "functorch/test_aotdispatch": 3131.8236666666685, "functorch/test_control_flow": 113.27866666666667, "functorch/test_dims": 26.329666666666668, "functorch/test_eager_transforms": 18.255666666666666, "functorch/test_logging": 0.057999999999999996, "functorch/test_memory_efficient_fusion": 0.4086666666666667, "functorch/test_minifier": 0.19999999999999998, "functorch/test_ops": 2911.142, "functorch/test_parsing": 0.031, "functorch/test_rearrange": 0.065, "functorch/test_vmap": 523.7993333333328, "functorch/test_vmap_registrations": 2.515333333333246, "higher_order_ops/test_with_effects": 8.768, "inductor/test_benchmark_fusion": 8.568333333333333, "inductor/test_binary_folding": 38.68333333333334, "inductor/test_codecache": 43.141999999999996, "inductor/test_codegen_triton": 0.08466666666666667, "inductor/test_compile_worker": 15.952666666666667, "inductor/test_compiled_autograd": 474.12133333333367, "inductor/test_compiled_optimizers": 756.5766666666668, "inductor/test_config": 5.9786666666666655, "inductor/test_control_flow": 0.008, "inductor/test_cpp_wrapper": 1015.7799999999999, "inductor/test_cpu_cpp_wrapper": 3030.1986666666667, "inductor/test_cpu_repro": 718.54, "inductor/test_cpu_select_algorithm": 3315.6306666666665, "inductor/test_custom_lowering": 0.002, "inductor/test_custom_post_grad_passes": 11.235333333333335, "inductor/test_debug_trace": 3.361, "inductor/test_decompose_mem_bound_mm": 0.0006666666666666666, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 34.98266666666668, "inductor/test_efficient_conv_bn_eval": 76.66033333333334, "inductor/test_extension_backend": 18.24866666666667, "inductor/test_flex_attention": 0.005666666666666667, "inductor/test_foreach": 18.55466666666676, "inductor/test_fused_attention": 175.13766666666666, "inductor/test_fx_fusion": 0.07433333333333335, "inductor/test_graph_transform_observer": 0.021, "inductor/test_group_batch_fusion": 0.03766666666666666, "inductor/test_indexing": 0.41100000000000003, "inductor/test_inductor_freezing": 57.518, "inductor/test_memory_planning": 0.0, "inductor/test_metrics": 0.015000000000000003, "inductor/test_minifier": 25.602000000000004, "inductor/test_mkldnn_pattern_matcher": 788.4483333333334, "inductor/test_mmdecomp": 0.010333333333333335, "inductor/test_profiler": 0.0026666666666666666, "inductor/test_standalone_compile": 17.201333333333334, "inductor/test_templated_attention": 0.004, "inductor/test_torchbind": 10.205666666666666, "inductor/test_torchinductor": 1604.6169999999993, "inductor/test_torchinductor_codegen_dynamic_shapes": 1525.3919999999998, "inductor/test_torchinductor_dynamic_shapes": 1676.2479999999998, "inductor/test_torchinductor_opinfo": 26106.449333333367, "inductor/test_triton_extension_backend": 2.0733333333333333, "inductor/test_triton_kernels": 0.033666666666666685, "inductor/test_utils": 0.016333333333333335, "lazy/test_debug_util": 0.057333333333333326, "lazy/test_functionalization": 0.06333333333333334, "lazy/test_generator": 0.09366666666666668, "lazy/test_reuse_ir": 0.4026666666666667, "lazy/test_step_closures": 2.01, "lazy/test_ts_opinfo": 9.26033333333333, "nn/test_convolution": 18.177666666666635, "nn/test_dropout": 0.3263333333333333, "nn/test_embedding": 6.147999999999993, "nn/test_init": 2.7703333333333333, "nn/test_lazy_modules": 0.5206666666666669, "nn/test_load_state_dict": 0.8420000000000001, "nn/test_module_hooks": 0.2106666666666667, "nn/test_multihead_attention": 6.586333333333333, "nn/test_packed_sequence": 0.2726666666666667, "nn/test_parametrization": 0.8570000000000002, "nn/test_pooling": 29.63566666666667, "nn/test_pruning": 0.08633333333333337, "profiler/test_execution_trace": 0.10933333333333334, "profiler/test_memory_profiler": 4.2876666666666665, "profiler/test_profiler": 22.561000000000003, "profiler/test_profiler_tree": 0.12000000000000001, "profiler/test_record_function": 0.07933333333333333, "profiler/test_torch_tidy": 3.8453333333333326, "test_ao_sparsity": 6.499666666666665, "test_autocast": 0.5850000000000001, "test_autograd": 25.86800000000001, "test_autograd_fallback": 0.11633333333333336, "test_binary_ufuncs": 129.98733333333647, "test_bundled_inputs": 0.9366666666666666, "test_comparison_utils": 0.017333333333333336, "test_compile_benchmark_util": 0.0003333333333333333, "test_complex": 0.04766666666666667, "test_content_store": 6.751333333333334, "test_cpp_api_parity": 3.153999999999987, "test_cpp_extensions_aot_ninja": 0.05133333333333334, "test_cpp_extensions_aot_no_ninja": 0.05166666666666667, "test_cpp_extensions_jit": 27.954333333333334, "test_cpp_extensions_mtia_backend": 0.44566666666666666, "test_cpp_extensions_open_device_registration": 7.685333333333333, "test_cpp_extensions_stream_and_event": 0.4643333333333333, "test_custom_backend": 0.07133333333333332, "test_custom_ops": 7.292333333333331, "test_dataloader": 128.82533333333333, "test_datapipe": 11.186, "test_decomp": 4865.728000000009, "test_deploy": 0.012666666666666666, "test_dispatch": 24.029666666666667, "test_dlpack": 0.18466666666666678, "test_dynamic_shapes": 3.8109999999999964, "test_expanded_weights": 7.157333333333331, "test_fake_tensor": 1.8396666666666668, "test_flop_counter": 0.5736666666666667, "test_foreach": 47.86500000000018, "test_function_schema": 0.36966666666666664, "test_functional_autograd_benchmark": 34.98566666666667, "test_functional_optim": 0.09500000000000001, "test_functionalization": 4.588999999999998, "test_functionalization_of_rng_ops": 0.015333333333333332, "test_futures": 0.6763333333333333, "test_fx": 222.5653333333333, "test_fx_experimental": 61.754000000000026, "test_fx_passes": 0.49100000000000016, "test_fx_reinplace_pass": 0.21633333333333338, "test_import_stats": 3.023, "test_indexing": 1.9876666666666634, "test_itt": 0.013999999999999999, "test_jit": 117.87333333333339, "test_jit_autocast": 15.859000000000002, "test_jit_cuda_fuser": 0.009000000000000001, "test_jit_disabled": 0.109, "test_jit_fuser_te": 213.69099999999972, "test_jit_llga_fuser": 53.368000000000016, "test_legacy_vmap": 2.0786666666666664, "test_license": 0.015, "test_linalg": 143.0176666666661, "test_logging": 2.4006666666666665, "test_masked": 13.853666666666667, "test_maskedtensor": 8.004999999999988, "test_meta": 1424.6096666665824, "test_mkl_verbose": 3.656, "test_mkldnn": 105.342, "test_mkldnn_fusion": 63.059, "test_mkldnn_verbose": 3.022, "test_mobile_optimizer": 2.4603333333333333, "test_model_dump": 0.867, "test_model_exports_to_core_aten": 0.01, "test_module_init": 2.0079999999999965, "test_module_tracker": 0.021333333333333333, "test_modules": 403.65933333332237, "test_monitor": 0.48700000000000004, "test_multiprocessing": 43.95733333333334, "test_multiprocessing_spawn": 24.900666666666666, "test_namedtensor": 0.38100000000000017, "test_namedtuple_return_api": 1.0273333333333332, "test_native_functions": 0.1376666666666667, "test_native_mha": 0.17800000000000005, "test_nestedtensor": 19.68600000000001, "test_nn": 134.46300000000073, "test_numba_integration": 0.004333333333333334, "test_numpy_interop": 0.14600000000000007, "test_nvfuser_frontend": 0.0, "test_openmp": 5.719333333333334, "test_ops": 2245.089333333291, "test_ops_fwd_gradients": 517.7120000000069, "test_ops_gradients": 943.1946666666714, "test_ops_jit": 845.7063333333323, "test_optim": 36.25300000000008, "test_out_dtype_op": 0.3146666666666667, "test_overrides": 1.6256666666666175, "test_package": 2.028999999999999, "test_per_overload_api": 0.02, "test_prims": 0.26533333333333337, "test_proxy_tensor": 670.2623333333282, "test_pruning_op": 0.218, "test_public_bindings": 6.495333333333334, "test_python_dispatch": 0.4603333333333335, "test_pytree": 0.23100000000000012, "test_quantization": 1925.872, "test_reductions": 187.9946666666549, "test_scatter_gather_ops": 3.560333333333334, "test_schema_check": 167.1593333333295, "test_segment_reductions": 0.9670000000000002, "test_serialization": 36.68233333333333, "test_set_default_mobile_cpu_allocator": 0.014, "test_shape_ops": 1.0603333333333327, "test_show_pickle": 0.01833333333333333, "test_sort_and_select": 1.8023333333333291, "test_sparse": 363.4369999999997, "test_sparse_csr": 150.88866666666755, "test_sparse_semi_structured": 0.002, "test_spectral_ops": 5.379666666666657, "test_stateless": 5.677666666666667, "test_subclass": 0.1550000000000001, "test_sympy_utils": 13.491666666666665, "test_tensor_creation_ops": 20.83566666666669, "test_tensorboard": 29.838333333333335, "test_tensorexpr": 44.602666666666664, "test_tensorexpr_pybind": 0.5953333333333334, "test_testing": 36.48633333333327, "test_torch": 15.256666666666723, "test_transformers": 306.0876666666658, "test_type_hints": 0.014, "test_type_info": 0.024000000000000004, "test_type_promotion": 3.325333333333319, "test_typing": 71.0816666666667, "test_unary_ufuncs": 327.5759999998295, "test_utils": 43.785666666665634, "test_view_ops": 12.516000000000007, "test_vulkan": 0.0006666666666666666, "test_weak": 3.9056666666666655, "test_xnnpack_integration": 42.38166666666667, "torch_np/numpy_tests/core/test_dlpack": 0.1193333333333334, "torch_np/numpy_tests/core/test_dtype": 0.16766666666666674, "torch_np/numpy_tests/core/test_einsum": 11.482666666666667, "torch_np/numpy_tests/core/test_getlimits": 0.03933333333333333, "torch_np/numpy_tests/core/test_indexing": 0.24266666666666678, "torch_np/numpy_tests/core/test_multiarray": 23.915333333333336, "torch_np/numpy_tests/core/test_numeric": 4.964666666666665, "torch_np/numpy_tests/core/test_numerictypes": 0.07233333333333336, "torch_np/numpy_tests/core/test_scalar_ctors": 0.09733333333333338, "torch_np/numpy_tests/core/test_scalar_methods": 0.007333333333333333, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 19.10666666666667, "torch_np/numpy_tests/core/test_shape_base": 0.46566666666666684, "torch_np/numpy_tests/fft/test_helper": 4.244666666666666, "torch_np/numpy_tests/fft/test_pocketfft": 3.6793333333333327, "torch_np/numpy_tests/lib/test_arraypad": 0.056333333333333326, "torch_np/numpy_tests/lib/test_arraysetops": 0.17900000000000005, "torch_np/numpy_tests/lib/test_function_base": 1.5930000000000002, "torch_np/numpy_tests/lib/test_histograms": 0.4050000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.10866666666666669, "torch_np/numpy_tests/lib/test_shape_base_": 0.4173333333333334, "torch_np/numpy_tests/lib/test_twodim_base": 0.216, "torch_np/numpy_tests/lib/test_type_check": 0.157, "torch_np/numpy_tests/linalg/test_linalg": 10.722000000000001, "torch_np/test_basic": 0.5566666666666671, "torch_np/test_binary_ufuncs": 0.11666666666666674, "torch_np/test_dtype": 0.07566666666666672, "torch_np/test_function_base": 0.016333333333333335, "torch_np/test_ndarray_methods": 3.4766666666666652, "torch_np/test_nep50_examples": 2.9883333333332005, "torch_np/test_random": 0.0696666666666667, "torch_np/test_reductions": 2.3163333333332994, "torch_np/test_scalars_0D_arrays": 0.058000000000000024, "torch_np/test_ufuncs_basic": 0.711666666666667, "torch_np/test_unary_ufuncs": 0.11600000000000006}, "dynamo": {"backends/xeon/test_launch": 2.0396666666666667, "benchmark_utils/test_benchmark_utils": 1.8613333333333333, "distributions/test_constraints": 0.07766666666666672, "distributions/test_distributions": 788.5459999999999, "dynamo/test_after_aot": 8.8575, "dynamo/test_aot_autograd": 14.994500000000002, "dynamo/test_autograd_function": 1.6446666666666665, "dynamo/test_backends": 13.984, "dynamo/test_backward_higher_order_ops": 14.862000000000002, "dynamo/test_base_output": 0.0035, "dynamo/test_bytecode_hook": 7.258666666666667, "dynamo/test_comptime": 0.30600000000000005, "dynamo/test_config": 0.3175, "dynamo/test_ctx_manager": 1.3945, "dynamo/test_debug_utils": 0.024, "dynamo/test_decorators": 0.4220000000000001, "dynamo/test_exc": 1.275, "dynamo/test_export_mutations": 0.247, "dynamo/test_frame_init": 0.013000000000000001, "dynamo/test_functions": 19.80266666666664, "dynamo/test_global": 0.3450000000000001, "dynamo/test_higher_order_ops": 9.114, "dynamo/test_hooks": 21.376, "dynamo/test_input_attr_tracking": 8.848999999999998, "dynamo/test_interop": 0.36033333333333334, "dynamo/test_logging": 12.320000000000002, "dynamo/test_minifier": 1.2663333333333335, "dynamo/test_misc": 34.35200000000004, "dynamo/test_model_output": 0.004, "dynamo/test_nops": 0.229, "dynamo/test_optimizers": 2.0645000000000002, "dynamo/test_pre_dispatch": 0.272, "dynamo/test_profiler": 0.7496666666666668, "dynamo/test_python_autograd": 0.535, "dynamo/test_recompile_ux": 0.742, "dynamo/test_recompiles": 0.6063333333333335, "dynamo/test_replay_record": 0.004, "dynamo/test_repros": 35.38300000000001, "dynamo/test_skip_non_tensor": 0.23266666666666666, "dynamo/test_subclasses": 3.0084999999999997, "dynamo/test_subgraphs": 2.394499999999999, "dynamo/test_unspec": 9.636333333333333, "dynamo/test_verify_correctness": 0.358, "export/test_db": 4.917333333333333, "export/test_export": 26.910333333333337, "export/test_functionalized_assertions": 0.5670000000000001, "export/test_funtionalized_assertions": 1.1693333333333333, "export/test_pass_infra": 0.9399999999999998, "export/test_passes": 5.087, "export/test_safeguard": 1.2633333333333334, "export/test_serialize": 14.720999999999998, "export/test_torchbind": 0.002, "export/test_unflatten": 2.3540000000000005, "export/test_upgrade": 0.6666666666666666, "export/test_verifier": 1.1003333333333334, "functorch/test_aotdispatch": 103.40666666666668, "functorch/test_control_flow": 409.48100000000005, "functorch/test_dims": 0.0030000000000000005, "functorch/test_eager_transforms": 190.69733333333332, "functorch/test_logging": 0.2973333333333333, "functorch/test_memory_efficient_fusion": 1.7603333333333333, "functorch/test_minifier": 1.342666666666667, "functorch/test_ops": 38.754333333337954, "functorch/test_parsing": 0.26, "functorch/test_rearrange": 4.022666666666667, "functorch/test_vmap": 1400.0423333333338, "functorch/test_vmap_registrations": 13.202999999999685, "higher_order_ops/test_with_effects": 7.158666666666666, "inductor/test_benchmark_fusion": 18.93766666666667, "inductor/test_binary_folding": 20.526, "inductor/test_codecache": 19.50266666666667, "inductor/test_codegen_triton": 0.1725, "inductor/test_compiled_autograd": 211.7345000000003, "inductor/test_compiled_optimizers": 162.66466666666676, "inductor/test_config": 3.524499999999999, "inductor/test_cpu_cpp_wrapper": 360.337, "inductor/test_cpu_repro": 330.3435000000002, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 3.981666666666667, "inductor/test_debug_trace": 1.7309999999999999, "inductor/test_dependencies": 0.001, "inductor/test_efficient_conv_bn_eval": 0.001, "inductor/test_extension_backend": 2.9415, "inductor/test_foreach": 12.055499999999988, "inductor/test_fused_attention": 39.119, "inductor/test_fx_fusion": 0.6626666666666666, "inductor/test_group_batch_fusion": 0.0, "inductor/test_indexing": 0.33799999999999997, "inductor/test_inductor_freezing": 34.34933333333333, "inductor/test_memory_planning": 0.0, "inductor/test_minifier": 20.727000000000004, "inductor/test_mkldnn_pattern_matcher": 622.8133333333334, "inductor/test_mmdecomp": 27.10766666666667, "inductor/test_profiler": 0.0025, "inductor/test_standalone_compile": 6.8069999999999995, "inductor/test_torchinductor": 918.9704999999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 759.1099999999989, "inductor/test_torchinductor_dynamic_shapes": 882.8869999999996, "inductor/test_torchinductor_opinfo": 2732.8823333333326, "lazy/test_debug_util": 0.49933333333333335, "lazy/test_functionalization": 0.5093333333333333, "lazy/test_generator": 0.305, "lazy/test_reuse_ir": 0.224, "lazy/test_step_closures": 2.422333333333333, "lazy/test_ts_opinfo": 3.1276666666666544, "nn/test_convolution": 230.30899999999988, "nn/test_dropout": 6.437333333333332, "nn/test_embedding": 239.4979999999999, "nn/test_init": 1.7409999999999997, "nn/test_lazy_modules": 12.811, "nn/test_load_state_dict": 3.5656666666666657, "nn/test_module_hooks": 18.285, "nn/test_multihead_attention": 25.971666666666668, "nn/test_packed_sequence": 6.8643333333333345, "nn/test_parametrization": 17.462999999999997, "nn/test_pooling": 58.86433333333334, "nn/test_pruning": 6.614, "profiler/test_execution_trace": 1.3743333333333332, "profiler/test_memory_profiler": 0.001, "profiler/test_profiler": 89.94433333333332, "profiler/test_profiler_tree": 46.87733333333333, "profiler/test_record_function": 0.49433333333333335, "profiler/test_torch_tidy": 5.957000000000001, "test_ao_sparsity": 78.12666666666667, "test_autocast": 12.941999999999998, "test_autograd": 133.274, "test_autograd_fallback": 1.9103333333333332, "test_binary_ufuncs": 660.438666666665, "test_bundled_inputs": 2.316333333333333, "test_comparison_utils": 0.24833333333333332, "test_compile_benchmark_util": 0.0, "test_complex": 1.0919999999999999, "test_content_store": 8.699333333333334, "test_cpp_api_parity": 129.89199999999968, "test_cpp_extensions_aot_ninja": 1.5363333333333333, "test_cpp_extensions_aot_no_ninja": 1.5473333333333332, "test_cpp_extensions_jit": 30.721, "test_cpp_extensions_mtia_backend": 0.629, "test_cpp_extensions_open_device_registration": 4.3726666666666665, "test_cpp_extensions_stream_and_event": 0.6283333333333334, "test_custom_ops": 29.404999999999998, "test_dataloader": 278.29266666666666, "test_datapipe": 17.479000000000003, "test_decomp": 14.049666666666164, "test_deploy": 0.19733333333333336, "test_dispatch": 37.472, "test_dlpack": 9.380666666666665, "test_dynamic_shapes": 3.286, "test_expanded_weights": 33.87766666666666, "test_fake_tensor": 7.280666666666669, "test_flop_counter": 0.0, "test_foreach": 32.26266666666681, "test_function_schema": 0.7416666666666667, "test_functional_autograd_benchmark": 33.822, "test_functional_optim": 1.1986666666666663, "test_functionalization": 0.005666666666666667, "test_functionalization_of_rng_ops": 0.17366666666666664, "test_futures": 3.016666666666667, "test_fx": 247.9416666666667, "test_fx_experimental": 375.6219999999999, "test_fx_passes": 9.350000000000001, "test_fx_reinplace_pass": 2.031333333333333, "test_import_stats": 3.264, "test_indexing": 102.44233333333335, "test_itt": 0.18299999999999997, "test_jit": 341.0716666666669, "test_jit_autocast": 0.0016666666666666668, "test_jit_disabled": 0.2856666666666667, "test_jit_fuser_te": 321.17566666666875, "test_jit_llga_fuser": 56.266999999999996, "test_legacy_vmap": 145.773, "test_license": 0.169, "test_linalg": 1807.9679999999998, "test_logging": 2.254, "test_masked": 36.584666666666635, "test_maskedtensor": 44.57066666666668, "test_meta": 71.3613333333397, "test_mkl_verbose": 3.426, "test_mkldnn": 135.724, "test_mkldnn_fusion": 0.0, "test_mkldnn_verbose": 3.1973333333333334, "test_mobile_optimizer": 5.019666666666666, "test_model_dump": 2.5796666666666663, "test_model_exports_to_core_aten": 0.11599999999999999, "test_module_init": 150.69100000000023, "test_module_tracker": 0.49933333333333324, "test_modules": 33.06466666666646, "test_monitor": 0.18933333333333335, "test_multiprocessing": 26.26466666666667, "test_multiprocessing_spawn": 29.557666666666666, "test_namedtensor": 7.540333333333332, "test_namedtuple_return_api": 1.8993333333333335, "test_native_functions": 0.7306666666666669, "test_native_mha": 23.313666666666666, "test_nestedtensor": 73.60366666666668, "test_nn": 701.7383333333336, "test_numba_integration": 0.17466666666666672, "test_numpy_interop": 8.590000000000002, "test_nvfuser_frontend": 0.0, "test_openmp": 6.639, "test_ops": 48.511333333332026, "test_ops_fwd_gradients": 4.05166666666645, "test_ops_gradients": 7.247333333333319, "test_ops_jit": 1.783333333333306, "test_optim": 364.06866666666684, "test_out_dtype_op": 1.1216666666666666, "test_overrides": 254.6436666666707, "test_package": 172.48600000000002, "test_per_overload_api": 1.062, "test_prims": 1.3156666666666668, "test_proxy_tensor": 99.73866666666756, "test_pruning_op": 0.21566666666666667, "test_public_bindings": 0.7396666666666668, "test_python_dispatch": 9.424333333333331, "test_pytree": 8.152666666666665, "test_quantization": 2166.2549999999997, "test_reductions": 487.57533333331986, "test_scatter_gather_ops": 138.31966666666665, "test_schema_check": 56.844666666668495, "test_segment_reductions": 28.87966666666667, "test_serialization": 59.874666666666656, "test_set_default_mobile_cpu_allocator": 0.21, "test_shape_ops": 15.162666666666667, "test_show_pickle": 0.19633333333333333, "test_sort_and_select": 46.399333333333324, "test_sparse": 907.3843333333319, "test_sparse_csr": 361.93733333333324, "test_sparse_semi_structured": 0.1376666666666667, "test_spectral_ops": 29.062333333333356, "test_stateless": 15.542666666666667, "test_subclass": 3.824999999999998, "test_sympy_utils": 41.13066666666666, "test_tensor_creation_ops": 222.92633333333345, "test_tensorboard": 36.969666666666676, "test_tensorexpr": 0.0023333333333333335, "test_tensorexpr_pybind": 3.524666666666666, "test_testing": 99.70900000000002, "test_torch": 228.86433333333275, "test_transformers": 916.4943333333331, "test_type_hints": 0.16866666666666666, "test_type_info": 0.7256666666666668, "test_type_promotion": 63.32900000000023, "test_typing": 71.09766666666667, "test_unary_ufuncs": 249.30499999997835, "test_utils": 69.87566666666866, "test_view_ops": 53.859000000000016, "test_vulkan": 0.0006666666666666666, "test_weak": 5.209, "test_xnnpack_integration": 49.75066666666667, "torch_np/numpy_tests/core/test_dlpack": 0.8546666666666671, "torch_np/numpy_tests/core/test_dtype": 1.0413333333333339, "torch_np/numpy_tests/core/test_einsum": 28.15533333333333, "torch_np/numpy_tests/core/test_getlimits": 0.33899999999999997, "torch_np/numpy_tests/core/test_indexing": 3.120333333333333, "torch_np/numpy_tests/core/test_multiarray": 53.13033333333335, "torch_np/numpy_tests/core/test_numeric": 32.65066666666667, "torch_np/numpy_tests/core/test_numerictypes": 0.7203333333333335, "torch_np/numpy_tests/core/test_scalar_ctors": 1.728, "torch_np/numpy_tests/core/test_scalar_methods": 0.1456666666666667, "torch_np/numpy_tests/core/test_scalarinherit": 0.0003333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 6.0873333333333335, "torch_np/numpy_tests/core/test_shape_base": 5.285333333333333, "torch_np/numpy_tests/fft/test_helper": 0.8320000000000002, "torch_np/numpy_tests/fft/test_pocketfft": 80.319, "torch_np/numpy_tests/lib/test_arraypad": 0.6823333333333336, "torch_np/numpy_tests/lib/test_arraysetops": 3.8360000000000003, "torch_np/numpy_tests/lib/test_function_base": 45.738, "torch_np/numpy_tests/lib/test_histograms": 5.779333333333334, "torch_np/numpy_tests/lib/test_index_tricks": 1.934666666666666, "torch_np/numpy_tests/lib/test_shape_base_": 4.575333333333334, "torch_np/numpy_tests/lib/test_twodim_base": 2.449333333333333, "torch_np/numpy_tests/lib/test_type_check": 2.977, "torch_np/numpy_tests/linalg/test_linalg": 23.590666666666664, "torch_np/test_basic": 11.438666666666656, "torch_np/test_binary_ufuncs": 1.8249999999999995, "torch_np/test_dtype": 1.0986666666666671, "torch_np/test_function_base": 0.32633333333333336, "torch_np/test_ndarray_methods": 18.580333333333332, "torch_np/test_nep50_examples": 24.50233333333323, "torch_np/test_random": 0.9840000000000003, "torch_np/test_reductions": 13.420333333333254, "torch_np/test_scalars_0D_arrays": 1.0043333333333335, "torch_np/test_ufuncs_basic": 18.269999999999992, "torch_np/test_unary_ufuncs": 1.9756666666666665}}, "linux-focal-py3.12-clang10": {"default": {"backends/xeon/test_launch": 1.7073333333333334, "benchmark_utils/test_benchmark_utils": 0.47900000000000004, "distributions/test_constraints": 0.06900000000000005, "distributions/test_distributions": 42.936, "dynamo/test_activation_checkpointing": 0.3076666666666667, "dynamo/test_after_aot": 5.702000000000001, "dynamo/test_aot_autograd": 12.593333333333332, "dynamo/test_aot_autograd_cache": 15.307333333333334, "dynamo/test_autograd_function": 3.2373333333333325, "dynamo/test_backends": 14.116333333333332, "dynamo/test_backward_higher_order_ops": 12.708000000000004, "dynamo/test_base_output": 0.0023333333333333335, "dynamo/test_bytecode_hook": 5.988666666666667, "dynamo/test_bytecode_utils": 6.456666666666667, "dynamo/test_compile": 6.952000000000001, "dynamo/test_comptime": 0.4013333333333334, "dynamo/test_config": 0.3483333333333334, "dynamo/test_cpp_guard_manager": 158.7960000000001, "dynamo/test_ctx_manager": 1.3650000000000002, "dynamo/test_debug_utils": 0.031, "dynamo/test_decorators": 7.247333333333334, "dynamo/test_deviceguard": 0.014, "dynamo/test_dynamic_shapes": 703.58, "dynamo/test_exc": 1.654, "dynamo/test_exceptions": 0.33733333333333343, "dynamo/test_export": 16.655666666666665, "dynamo/test_export_mutations": 0.33866666666666667, "dynamo/test_frame_init": 0.026333333333333334, "dynamo/test_functions": 18.10266666666668, "dynamo/test_fx_passes_pre_grad": 1.1056666666666666, "dynamo/test_global": 0.3636666666666668, "dynamo/test_guard_manager": 0.042333333333333355, "dynamo/test_higher_order_ops": 26.332666666666668, "dynamo/test_hooks": 25.242000000000004, "dynamo/test_inline_inbuilt_nn_modules": 123.55566666666674, "dynamo/test_input_attr_tracking": 7.8066666666666675, "dynamo/test_interop": 0.36133333333333334, "dynamo/test_logging": 16.258333333333336, "dynamo/test_minifier": 1.1953333333333334, "dynamo/test_misc": 64.84866666666676, "dynamo/test_model_output": 0.0036666666666666666, "dynamo/test_modules": 20.214666666666663, "dynamo/test_nops": 0.225, "dynamo/test_optimizers": 0.5353333333333333, "dynamo/test_pre_dispatch": 0.26466666666666666, "dynamo/test_profiler": 0.9876666666666666, "dynamo/test_python_autograd": 0.49300000000000005, "dynamo/test_recompile_ux": 0.5736666666666667, "dynamo/test_recompiles": 0.6173333333333334, "dynamo/test_reorder_logs": 0.337, "dynamo/test_repros": 48.78600000000004, "dynamo/test_resume": 0.238, "dynamo/test_sdpa": 0.343, "dynamo/test_skip_non_tensor": 0.4453333333333334, "dynamo/test_sources": 0.311, "dynamo/test_structured_trace": 12.081666666666665, "dynamo/test_subclasses": 15.182666666666663, "dynamo/test_subgraphs": 2.331666666666666, "dynamo/test_trace_rules": 0.633, "dynamo/test_unspec": 12.311666666666667, "dynamo/test_verify_correctness": 0.3593333333333333, "dynamo/test_view": 0.421, "export/test_converter": 6.877666666666667, "export/test_db": 3.0949999999999993, "export/test_experimental": 0.7516666666666666, "export/test_export": 29.222333333333335, "export/test_export_nonstrict": 28.996000000000006, "export/test_export_predispatch": 27.670333333333335, "export/test_functionalized_assertions": 0.028, "export/test_hop": 3.0076666666666667, "export/test_lift_unlift": 0.20433333333333337, "export/test_pass_infra": 0.6180000000000001, "export/test_passes": 12.705666666666666, "export/test_retraceability": 44.173, "export/test_safeguard": 0.727, "export/test_schema": 0.1466666666666667, "export/test_serdes": 34.467333333333336, "export/test_serialize": 8.398666666666664, "export/test_sparse": 0.016666666666666673, "export/test_tools": 0.3096666666666666, "export/test_torchbind": 3.0026666666666664, "export/test_tree_utils": 0.015333333333333332, "export/test_unflatten": 3.1336666666666666, "export/test_upgrade": 0.30200000000000005, "export/test_verifier": 0.6683333333333333, "functorch/test_aotdispatch": 3103.226666666668, "functorch/test_control_flow": 125.12933333333326, "functorch/test_eager_transforms": 16.44833333333333, "functorch/test_logging": 0.1376666666666667, "functorch/test_minifier": 0.3319999999999999, "functorch/test_ops": 3099.391999999996, "functorch/test_vmap": 537.7083333333322, "functorch/test_vmap_registrations": 2.6343333333332275, "higher_order_ops/test_with_effects": 9.591666666666667, "inductor/test_benchmark_fusion": 7.396, "inductor/test_binary_folding": 40.620666666666665, "inductor/test_codecache": 40.06066666666666, "inductor/test_codegen_triton": 0.09300000000000001, "inductor/test_compile_worker": 7.819, "inductor/test_compiled_autograd": 506.79500000000036, "inductor/test_compiled_optimizers": 777.9126666666671, "inductor/test_config": 5.102666666666666, "inductor/test_control_flow": 0.008333333333333333, "inductor/test_cpu_cpp_wrapper": 2995.533333333334, "inductor/test_cpu_repro": 700.9043333333334, "inductor/test_cpu_select_algorithm": 3344.832, "inductor/test_custom_lowering": 0.0030000000000000005, "inductor/test_custom_post_grad_passes": 10.354, "inductor/test_debug_trace": 2.4586666666666663, "inductor/test_decompose_mem_bound_mm": 0.001, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 34.13766666666667, "inductor/test_efficient_conv_bn_eval": 76.02666666666667, "inductor/test_extension_backend": 22.585333333333335, "inductor/test_flex_attention": 0.008333333333333333, "inductor/test_foreach": 16.983666666666693, "inductor/test_fused_attention": 172.80700000000002, "inductor/test_fx_fusion": 0.07033333333333334, "inductor/test_graph_transform_observer": 0.018000000000000002, "inductor/test_group_batch_fusion": 0.034, "inductor/test_indexing": 0.5936666666666666, "inductor/test_inductor_freezing": 57.89866666666666, "inductor/test_minifier": 24.345, "inductor/test_mkldnn_pattern_matcher": 765.9583333333334, "inductor/test_mmdecomp": 0.10033333333333333, "inductor/test_standalone_compile": 17.622666666666667, "inductor/test_templated_attention": 0.012666666666666672, "inductor/test_torchbind": 9.616666666666665, "inductor/test_torchinductor": 1642.5559999999996, "inductor/test_torchinductor_codegen_dynamic_shapes": 1511.553333333333, "inductor/test_torchinductor_dynamic_shapes": 1658.2183333333323, "inductor/test_torchinductor_opinfo": 26090.984000000015, "inductor/test_triton_extension_backend": 0.27266666666666667, "inductor/test_triton_kernels": 0.2430000000000001, "inductor/test_utils": 0.017, "lazy/test_debug_util": 0.05633333333333334, "lazy/test_functionalization": 0.077, "lazy/test_generator": 0.05966666666666667, "lazy/test_reuse_ir": 0.3376666666666666, "lazy/test_step_closures": 2.0109999999999997, "lazy/test_ts_opinfo": 7.919000000000008, "nn/test_convolution": 18.852999999999966, "nn/test_dropout": 0.4200000000000001, "nn/test_embedding": 6.138333333333329, "nn/test_init": 3.26, "nn/test_lazy_modules": 0.5193333333333335, "nn/test_load_state_dict": 0.7353333333333333, "nn/test_module_hooks": 0.20200000000000004, "nn/test_multihead_attention": 5.862333333333333, "nn/test_packed_sequence": 0.211, "nn/test_parametrization": 0.9226666666666669, "nn/test_pooling": 29.91066666666667, "nn/test_pruning": 0.09300000000000004, "profiler/test_execution_trace": 0.25266666666666665, "profiler/test_memory_profiler": 3.691333333333334, "profiler/test_profiler": 22.081666666666667, "profiler/test_profiler_tree": 0.08366666666666668, "profiler/test_record_function": 0.08633333333333333, "profiler/test_torch_tidy": 3.9166666666666656, "test_ao_sparsity": 7.134999999999999, "test_autocast": 0.5870000000000001, "test_autograd": 24.427666666666692, "test_autograd_fallback": 0.08833333333333336, "test_binary_ufuncs": 127.80333333333603, "test_bundled_inputs": 0.931, "test_comparison_utils": 0.022333333333333334, "test_compile_benchmark_util": 0.0003333333333333333, "test_complex": 0.05000000000000001, "test_content_store": 6.012999999999999, "test_cpp_api_parity": 3.0359999999999885, "test_cpp_extensions_aot_ninja": 0.04066666666666667, "test_cpp_extensions_aot_no_ninja": 0.039666666666666676, "test_cpp_extensions_jit": 152.77333333333334, "test_cpp_extensions_mtia_backend": 0.44399999999999995, "test_cpp_extensions_open_device_registration": 7.773333333333333, "test_cpp_extensions_stream_and_event": 0.4686666666666666, "test_custom_backend": 0.06899999999999999, "test_custom_ops": 7.683666666666663, "test_dataloader": 118.46666666666665, "test_datapipe": 11.212333333333332, "test_decomp": 5070.909333333347, "test_deploy": 0.015, "test_dispatch": 27.97066666666667, "test_dlpack": 0.25266666666666676, "test_dynamic_shapes": 3.7536666666666623, "test_expanded_weights": 7.980999999999998, "test_fake_tensor": 1.7740000000000002, "test_flop_counter": 0.4753333333333334, "test_foreach": 48.9440000000005, "test_function_schema": 0.3196666666666667, "test_functional_autograd_benchmark": 35.934333333333335, "test_functional_optim": 0.13366666666666668, "test_functionalization": 5.065666666666664, "test_functionalization_of_rng_ops": 0.017333333333333336, "test_futures": 0.6783333333333333, "test_fx": 219.91366666666667, "test_fx_experimental": 71.70733333333332, "test_fx_passes": 0.5396666666666668, "test_fx_reinplace_pass": 0.2850000000000001, "test_import_stats": 2.981666666666667, "test_indexing": 2.00733333333333, "test_itt": 0.016333333333333335, "test_jit": 108.3326666666667, "test_jit_autocast": 17.547666666666668, "test_jit_disabled": 0.11399999999999999, "test_jit_fuser_te": 202.9503333333336, "test_jit_llga_fuser": 39.635, "test_legacy_vmap": 2.1173333333333333, "test_license": 0.014333333333333332, "test_linalg": 126.3609999999996, "test_logging": 2.0526666666666666, "test_masked": 15.05733333333333, "test_maskedtensor": 6.798999999999967, "test_meta": 1503.8486666665528, "test_mkl_verbose": 3.7776666666666667, "test_mkldnn": 95.1083333333333, "test_mkldnn_fusion": 59.463, "test_mkldnn_verbose": 3.5836666666666672, "test_mobile_optimizer": 2.3463333333333334, "test_model_dump": 0.7639999999999999, "test_model_exports_to_core_aten": 0.012666666666666666, "test_module_tracker": 0.019333333333333338, "test_modules": 429.2553333333253, "test_monitor": 0.5096666666666666, "test_multiprocessing": 43.82366666666667, "test_multiprocessing_spawn": 24.14333333333333, "test_namedtensor": 0.45966666666666683, "test_namedtuple_return_api": 1.0676666666666665, "test_native_functions": 0.15133333333333335, "test_native_mha": 0.18366666666666673, "test_nestedtensor": 18.40600000000001, "test_nn": 138.9740000000005, "test_numba_integration": 0.0036666666666666666, "test_numpy_interop": 0.16900000000000007, "test_openmp": 5.851999999999999, "test_ops": 2246.5209999999747, "test_ops_fwd_gradients": 567.1776666666691, "test_ops_gradients": 967.1900000000063, "test_ops_jit": 859.8809999999986, "test_optim": 37.57966666666675, "test_out_dtype_op": 0.21533333333333338, "test_overrides": 1.723666666666607, "test_package": 2.1843333333333326, "test_per_overload_api": 0.019000000000000003, "test_prims": 0.20133333333333336, "test_proxy_tensor": 662.006999999994, "test_pruning_op": 0.2143333333333333, "test_public_bindings": 5.033666666666666, "test_python_dispatch": 0.46766666666666684, "test_pytree": 0.21266666666666678, "test_quantization": 1915.929, "test_reductions": 188.88533333332157, "test_scatter_gather_ops": 3.9516666666666658, "test_schema_check": 161.83499999999677, "test_segment_reductions": 0.9403333333333338, "test_serialization": 33.00066666666667, "test_set_default_mobile_cpu_allocator": 0.017333333333333333, "test_shape_ops": 0.8533333333333336, "test_show_pickle": 0.019666666666666666, "test_sort_and_select": 1.9046666666666632, "test_sparse": 474.6516666666651, "test_sparse_csr": 149.3970000000002, "test_sparse_semi_structured": 0.0033333333333333335, "test_spectral_ops": 5.4716666666666605, "test_stateless": 5.639, "test_subclass": 0.16366666666666677, "test_sympy_utils": 14.400999999999994, "test_tensor_creation_ops": 17.175000000000008, "test_tensorboard": 35.00066666666667, "test_tensorexpr": 44.836333333333336, "test_tensorexpr_pybind": 0.5973333333333334, "test_testing": 32.70333333333324, "test_torch": 15.980333333333377, "test_transformers": 291.34733333333253, "test_type_hints": 0.016, "test_type_info": 0.023000000000000007, "test_type_promotion": 2.8349999999999844, "test_typing": 75.0946666666667, "test_unary_ufuncs": 353.41133333315884, "test_utils": 41.285666666667176, "test_view_ops": 13.976333333333345, "test_vulkan": 0.0, "test_weak": 3.5903333333333323, "test_xnnpack_integration": 43.17066666666667, "torch_np/numpy_tests/core/test_dlpack": 0.14033333333333342, "torch_np/numpy_tests/core/test_dtype": 0.34933333333333344, "torch_np/numpy_tests/core/test_einsum": 11.320333333333332, "torch_np/numpy_tests/core/test_getlimits": 0.04800000000000001, "torch_np/numpy_tests/core/test_indexing": 0.2276666666666668, "torch_np/numpy_tests/core/test_numeric": 4.075, "torch_np/numpy_tests/core/test_numerictypes": 0.050666666666666686, "torch_np/numpy_tests/core/test_scalar_ctors": 0.09633333333333338, "torch_np/numpy_tests/core/test_scalar_methods": 0.004, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 17.488, "torch_np/numpy_tests/core/test_shape_base": 0.46666666666666684, "torch_np/numpy_tests/fft/test_helper": 4.08, "torch_np/numpy_tests/fft/test_pocketfft": 3.9233333333333325, "torch_np/numpy_tests/lib/test_arraypad": 0.037, "torch_np/numpy_tests/lib/test_arraysetops": 0.21566666666666667, "torch_np/numpy_tests/lib/test_function_base": 1.469666666666667, "torch_np/numpy_tests/lib/test_histograms": 0.26300000000000007, "torch_np/numpy_tests/lib/test_index_tricks": 0.08533333333333336, "torch_np/numpy_tests/lib/test_shape_base_": 0.41466666666666674, "torch_np/numpy_tests/lib/test_twodim_base": 0.2770000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.12433333333333334, "torch_np/numpy_tests/linalg/test_linalg": 8.822999999999999, "torch_np/test_basic": 0.6070000000000003, "torch_np/test_binary_ufuncs": 0.1460000000000001, "torch_np/test_dtype": 0.07033333333333337, "torch_np/test_function_base": 0.018666666666666668, "torch_np/test_ndarray_methods": 3.4856666666666665, "torch_np/test_nep50_examples": 3.023666666666538, "torch_np/test_random": 0.07000000000000002, "torch_np/test_reductions": 2.065333333333306, "torch_np/test_scalars_0D_arrays": 0.05666666666666669, "torch_np/test_ufuncs_basic": 0.6600000000000005, "torch_np/test_unary_ufuncs": 0.1420000000000001}, "dynamo": {"backends/xeon/test_launch": 1.958, "benchmark_utils/test_benchmark_utils": 1.6019999999999996, "distributions/test_constraints": 0.08900000000000007, "distributions/test_distributions": 720.4333333333334, "functorch/test_aotdispatch": 94.88733333333346, "functorch/test_control_flow": 440.2830000000001, "functorch/test_eager_transforms": 204.88866666666664, "functorch/test_logging": 0.3953333333333333, "functorch/test_minifier": 1.0796666666666666, "functorch/test_ops": 36.69733333333656, "functorch/test_vmap": 1450.5206666666666, "functorch/test_vmap_registrations": 12.859666666666302, "higher_order_ops/test_with_effects": 7.175333333333334, "lazy/test_debug_util": 0.416, "lazy/test_functionalization": 0.4553333333333333, "lazy/test_generator": 0.383, "lazy/test_reuse_ir": 0.29500000000000004, "lazy/test_step_closures": 2.351, "lazy/test_ts_opinfo": 3.0536666666666505, "nn/test_convolution": 228.56499999999974, "nn/test_dropout": 6.083666666666667, "nn/test_embedding": 237.40299999999988, "nn/test_init": 1.5039999999999998, "nn/test_lazy_modules": 12.973666666666668, "nn/test_load_state_dict": 3.8369999999999993, "nn/test_module_hooks": 18.250666666666667, "nn/test_multihead_attention": 25.00533333333333, "nn/test_packed_sequence": 2.764333333333333, "nn/test_parametrization": 17.415333333333333, "nn/test_pooling": 54.70766666666666, "nn/test_pruning": 6.528, "profiler/test_execution_trace": 1.3186666666666664, "profiler/test_memory_profiler": 0.0, "profiler/test_profiler": 21.378666666666664, "profiler/test_profiler_tree": 1.3710000000000002, "profiler/test_record_function": 0.492, "profiler/test_torch_tidy": 6.226666666666667, "test_ao_sparsity": 70.77166666666668, "test_autocast": 13.01833333333333, "test_autograd": 137.15, "test_autograd_fallback": 1.8776666666666666, "test_binary_ufuncs": 634.0769999999694, "test_bundled_inputs": 1.9149999999999998, "test_comparison_utils": 0.3740000000000001, "test_compile_benchmark_util": 0.0003333333333333333, "test_complex": 1.0503333333333333, "test_content_store": 8.063666666666666, "test_cpp_api_parity": 135.35066666666634, "test_cpp_extensions_aot_ninja": 1.4233333333333336, "test_cpp_extensions_aot_no_ninja": 1.4303333333333332, "test_cpp_extensions_jit": 106.19133333333332, "test_cpp_extensions_mtia_backend": 0.6276666666666667, "test_cpp_extensions_open_device_registration": 9.373666666666669, "test_cpp_extensions_stream_and_event": 0.6103333333333333, "test_custom_ops": 34.54466666666667, "test_dataloader": 257.598, "test_datapipe": 16.945666666666664, "test_decomp": 14.323333333333293, "test_deploy": 0.24666666666666667, "test_dispatch": 37.73133333333333, "test_dlpack": 8.375333333333332, "test_dynamic_shapes": 2.9933333333333336, "test_expanded_weights": 35.37933333333334, "test_fake_tensor": 7.434666666666666, "test_flop_counter": 0.0003333333333333333, "test_foreach": 32.71100000000097, "test_function_schema": 0.7533333333333334, "test_functional_autograd_benchmark": 33.599, "test_functional_optim": 1.097, "test_functionalization": 0.09200000000000001, "test_functionalization_of_rng_ops": 0.26166666666666666, "test_futures": 2.951333333333333, "test_fx": 177.21899999999997, "test_fx_experimental": 362.79699999999997, "test_fx_passes": 7.100666666666666, "test_fx_reinplace_pass": 1.7956666666666667, "test_import_stats": 3.318, "test_indexing": 99.68133333333334, "test_itt": 0.26966666666666667, "test_jit": 333.28600000000006, "test_jit_autocast": 0.0, "test_jit_disabled": 0.37966666666666665, "test_jit_fuser_te": 357.75500000000096, "test_jit_llga_fuser": 59.950333333333326, "test_legacy_vmap": 141.00900000000001, "test_license": 0.2973333333333334, "test_linalg": 1540.267666666666, "test_logging": 2.2696666666666663, "test_masked": 38.235666666666624, "test_maskedtensor": 46.133, "test_meta": 65.82500000000043, "test_mkl_verbose": 4.021, "test_mkldnn": 127.36933333333333, "test_mkldnn_fusion": 0.0003333333333333333, "test_mkldnn_verbose": 4.073666666666667, "test_mobile_optimizer": 4.682666666666666, "test_model_dump": 2.894, "test_model_exports_to_core_aten": 0.11866666666666666, "test_module_tracker": 0.47866666666666663, "test_modules": 35.52366666666758, "test_monitor": 0.27166666666666667, "test_multiprocessing": 25.593999999999998, "test_multiprocessing_spawn": 24.419999999999998, "test_namedtensor": 6.987666666666665, "test_namedtuple_return_api": 1.8133333333333332, "test_native_functions": 0.7366666666666669, "test_native_mha": 23.81, "test_nestedtensor": 71.28166666666667, "test_nn": 686.111666666667, "test_numba_integration": 0.2566666666666667, "test_numpy_interop": 8.503333333333332, "test_openmp": 7.791333333333334, "test_ops": 49.32366666666773, "test_ops_fwd_gradients": 4.374999999999768, "test_ops_gradients": 8.314666666666536, "test_ops_jit": 1.550999999999979, "test_optim": 387.36166666666674, "test_out_dtype_op": 1.046, "test_overrides": 242.25833333333742, "test_package": 153.903, "test_per_overload_api": 0.9913333333333334, "test_prims": 1.2739999999999998, "test_proxy_tensor": 101.7640000000008, "test_pruning_op": 0.24833333333333332, "test_public_bindings": 0.746, "test_python_dispatch": 8.801333333333332, "test_pytree": 9.156999999999998, "test_quantization": 2176.0670000000005, "test_reductions": 513.3746666667045, "test_scatter_gather_ops": 128.91766666666663, "test_schema_check": 58.15666666666817, "test_segment_reductions": 27.75966666666667, "test_serialization": 65.01533333333334, "test_set_default_mobile_cpu_allocator": 0.26966666666666667, "test_shape_ops": 14.659333333333329, "test_show_pickle": 0.2753333333333334, "test_sort_and_select": 41.95999999999999, "test_sparse": 961.6303333333323, "test_sparse_csr": 378.5613333333212, "test_sparse_semi_structured": 0.21600000000000005, "test_spectral_ops": 29.711333333333425, "test_stateless": 15.686666666666662, "test_subclass": 3.771999999999997, "test_sympy_utils": 42.221666666666664, "test_tensor_creation_ops": 203.02400000000003, "test_tensorboard": 37.47966666666667, "test_tensorexpr": 0.002, "test_tensorexpr_pybind": 3.7159999999999997, "test_testing": 104.7986666666667, "test_torch": 249.04033333333294, "test_transformers": 888.6376666666662, "test_type_hints": 0.251, "test_type_info": 0.3146666666666667, "test_type_promotion": 59.26466666666668, "test_typing": 79.03499999999998, "test_unary_ufuncs": 251.55233333321974, "test_utils": 71.59533333333515, "test_view_ops": 52.25066666666666, "test_vulkan": 0.0006666666666666666, "test_weak": 5.839000000000001, "test_xnnpack_integration": 46.17699999999999, "torch_np/numpy_tests/core/test_dlpack": 0.8783333333333339, "torch_np/numpy_tests/core/test_dtype": 1.1260000000000006, "torch_np/numpy_tests/core/test_einsum": 26.294, "torch_np/numpy_tests/core/test_getlimits": 0.4376666666666667, "torch_np/numpy_tests/core/test_indexing": 3.2306666666666666, "torch_np/numpy_tests/core/test_numeric": 36.507333333333335, "torch_np/numpy_tests/core/test_numerictypes": 0.7520000000000002, "torch_np/numpy_tests/core/test_scalar_ctors": 1.6970000000000003, "torch_np/numpy_tests/core/test_scalar_methods": 0.21166666666666667, "torch_np/numpy_tests/core/test_scalarinherit": 0.0003333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 6.191333333333334, "torch_np/numpy_tests/core/test_shape_base": 5.095, "torch_np/numpy_tests/fft/test_helper": 0.798, "torch_np/numpy_tests/fft/test_pocketfft": 81.36266666666666, "torch_np/numpy_tests/lib/test_arraypad": 0.6316666666666667, "torch_np/numpy_tests/lib/test_arraysetops": 3.907666666666666, "torch_np/numpy_tests/lib/test_function_base": 36.74666666666666, "torch_np/numpy_tests/lib/test_histograms": 6.410333333333333, "torch_np/numpy_tests/lib/test_index_tricks": 1.968, "torch_np/numpy_tests/lib/test_shape_base_": 4.2860000000000005, "torch_np/numpy_tests/lib/test_twodim_base": 2.3746666666666667, "torch_np/numpy_tests/lib/test_type_check": 3.0706666666666664, "torch_np/numpy_tests/linalg/test_linalg": 25.451333333333334, "torch_np/test_basic": 10.431999999999976, "torch_np/test_binary_ufuncs": 1.4960000000000002, "torch_np/test_dtype": 0.9563333333333338, "torch_np/test_function_base": 0.321, "torch_np/test_ndarray_methods": 20.32933333333333, "torch_np/test_nep50_examples": 26.52366666666647, "torch_np/test_random": 0.9813333333333337, "torch_np/test_reductions": 13.827666666666573, "torch_np/test_scalars_0D_arrays": 0.9663333333333336, "torch_np/test_ufuncs_basic": 18.72033333333334, "torch_np/test_unary_ufuncs": 1.5146666666666666}}, "linux-focal-py3.8-clang10": {"crossref": {"backends/xeon/test_launch": 2.1199999999999997, "benchmark_utils/test_benchmark_utils": 1.9526666666666666, "distributions/test_constraints": 0.07400000000000005, "distributions/test_distributions": 61.772333333333336, "export/test_converter": 8.488999999999999, "export/test_db": 3.3783333333333334, "export/test_export": 34.73533333333334, "export/test_functionalized_assertions": 0.33266666666666667, "export/test_funtionalized_assertions": 0.6993333333333335, "export/test_hop": 3.064333333333334, "export/test_lift_unlift": 0.18233333333333332, "export/test_pass_infra": 0.9630000000000001, "export/test_passes": 14.905666666666669, "export/test_safeguard": 0.9716666666666667, "export/test_schema": 0.4456666666666667, "export/test_serialize": 9.349, "export/test_sparse": 91.73399999999997, "export/test_tools": 0.5113333333333334, "export/test_torchbind": 3.6876666666666664, "export/test_tree_utils": 0.3066666666666667, "export/test_unflatten": 3.375, "export/test_upgrade": 0.417, "export/test_verifier": 1.0919999999999999, "functorch/test_aotdispatch": 3480.80733333333, "functorch/test_control_flow": 124.95199999999994, "functorch/test_dims": 33.836666666666666, "functorch/test_eager_transforms": 19.137, "functorch/test_logging": 0.30866666666666664, "functorch/test_memory_efficient_fusion": 0.593, "functorch/test_minifier": 0.505, "functorch/test_ops": 3935.66133333329, "functorch/test_parsing": 0.3366666666666667, "functorch/test_rearrange": 0.35666666666666674, "functorch/test_vmap": 676.930999999999, "functorch/test_vmap_registrations": 3.2583333333331956, "higher_order_ops/test_with_effects": 9.691333333333333, "inductor/test_fx_fusion": 0.21333333333333335, "inductor/test_mmdecomp": 0.01900000000000001, "lazy/test_debug_util": 0.32066666666666666, "lazy/test_functionalization": 0.3236666666666667, "lazy/test_generator": 0.3606666666666667, "lazy/test_reuse_ir": 0.621, "lazy/test_step_closures": 2.271333333333333, "lazy/test_ts_opinfo": 10.234999999999978, "nn/test_convolution": 20.114666666666622, "nn/test_dropout": 0.4756666666666667, "nn/test_embedding": 9.401000000000009, "nn/test_init": 4.3759999999999994, "nn/test_lazy_modules": 0.5956666666666669, "nn/test_load_state_dict": 1.134333333333333, "nn/test_module_hooks": 0.2773333333333334, "nn/test_multihead_attention": 7.221333333333333, "nn/test_packed_sequence": 0.5800000000000001, "nn/test_parametrization": 1.6023333333333323, "nn/test_pooling": 30.857, "nn/test_pruning": 0.12366666666666674, "profiler/test_execution_trace": 0.10466666666666667, "profiler/test_memory_profiler": 5.796666666666667, "profiler/test_profiler": 22.25266666666667, "profiler/test_profiler_tree": 0.36166666666666675, "profiler/test_record_function": 0.38933333333333336, "profiler/test_torch_tidy": 4.481, "test_ao_sparsity": 11.425666666666666, "test_autocast": 0.8346666666666668, "test_autograd": 32.456666666666635, "test_autograd_fallback": 0.35700000000000004, "test_binary_ufuncs": 158.38066666666273, "test_bundled_inputs": 1.1619999999999997, "test_comparison_utils": 0.395, "test_compile_benchmark_util": 0.001, "test_complex": 0.064, "test_content_store": 7.876, "test_cpp_api_parity": 3.7323333333333206, "test_cpp_extensions_aot_ninja": 0.037000000000000005, "test_cpp_extensions_aot_no_ninja": 0.037333333333333336, "test_cpp_extensions_jit": 28.588000000000005, "test_cpp_extensions_mtia_backend": 0.7223333333333333, "test_cpp_extensions_open_device_registration": 8.228, "test_cpp_extensions_stream_and_event": 0.7486666666666667, "test_custom_backend": 0.07466666666666666, "test_custom_ops": 9.73133333333333, "test_dataloader": 134.04966666666667, "test_datapipe": 13.059666666666665, "test_decomp": 249.0943333333333, "test_deploy": 0.29833333333333334, "test_dispatch": 24.734999999999996, "test_dlpack": 0.24266666666666684, "test_dynamic_shapes": 4.921666666666662, "test_expanded_weights": 10.392666666666665, "test_fake_tensor": 1.7020000000000002, "test_flop_counter": 0.626, "test_foreach": 77.18599999999996, "test_function_schema": 0.7113333333333333, "test_functional_autograd_benchmark": 39.916, "test_functional_optim": 0.5193333333333333, "test_functionalization": 5.992333333333331, "test_functionalization_of_rng_ops": 0.022333333333333334, "test_futures": 0.9216666666666667, "test_fx": 229.79499999999987, "test_fx_experimental": 74.28766666666668, "test_fx_passes": 0.7450000000000001, "test_fx_reinplace_pass": 0.5940000000000002, "test_import_stats": 3.3890000000000007, "test_indexing": 2.036333333333331, "test_itt": 0.32666666666666666, "test_jit": 108.8816666666667, "test_jit_autocast": 18.612000000000002, "test_jit_cuda_fuser": 0.02800000000000001, "test_jit_disabled": 0.40433333333333327, "test_jit_fuser_te": 226.86533333333364, "test_jit_llga_fuser": 46.28066666666667, "test_legacy_vmap": 2.393999999999999, "test_license": 0.296, "test_linalg": 158.87433333333283, "test_logging": 2.9553333333333334, "test_masked": 21.528333333333297, "test_maskedtensor": 6.749333333333247, "test_meta": 115.59999999997054, "test_mkl_verbose": 4.387666666666667, "test_mkldnn": 117.49999999999996, "test_mkldnn_fusion": 59.07866666666666, "test_mkldnn_verbose": 3.785, "test_mobile_optimizer": 2.787333333333334, "test_model_dump": 1.2646666666666666, "test_model_exports_to_core_aten": 0.19133333333333336, "test_module_init": 2.055999999999991, "test_module_tracker": 0.3313333333333333, "test_modules": 648.6009999999902, "test_monitor": 0.49499999999999994, "test_multiprocessing": 45.80000000000001, "test_multiprocessing_spawn": 25.305333333333333, "test_namedtensor": 0.49733333333333346, "test_namedtuple_return_api": 1.8763333333333332, "test_native_functions": 0.4283333333333334, "test_native_mha": 0.2163333333333334, "test_nestedtensor": 23.860333333333347, "test_nn": 150.26700000000028, "test_numba_integration": 0.005666666666666667, "test_numpy_interop": 0.24100000000000008, "test_nvfuser_frontend": 0.0, "test_openmp": 8.751, "test_ops": 2810.3079999999604, "test_ops_fwd_gradients": 811.0239999999876, "test_ops_gradients": 1302.9629999999459, "test_ops_jit": 1057.4786666666637, "test_optim": 55.54966666666678, "test_out_dtype_op": 0.4033333333333334, "test_overrides": 1.9093333333332538, "test_package": 2.821333333333333, "test_per_overload_api": 0.299, "test_prims": 0.2476666666666667, "test_proxy_tensor": 760.628, "test_pruning_op": 0.602, "test_public_bindings": 6.581333333333333, "test_python_dispatch": 0.6440000000000002, "test_pytree": 0.5760000000000002, "test_quantization": 2268.950666666666, "test_reductions": 199.60033333333345, "test_scatter_gather_ops": 5.716333333333332, "test_schema_check": 206.16399999999769, "test_segment_reductions": 1.509333333333333, "test_serialization": 36.413, "test_set_default_mobile_cpu_allocator": 0.31566666666666665, "test_shape_ops": 1.378666666666666, "test_show_pickle": 0.26033333333333336, "test_sort_and_select": 2.3149999999999977, "test_sparse": 962.6036666666656, "test_sparse_csr": 214.23966666666627, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 6.64533333333332, "test_stateless": 6.736999999999999, "test_subclass": 0.43400000000000016, "test_sympy_utils": 16.82233333333333, "test_tensor_creation_ops": 29.514666666666646, "test_tensorboard": 0.3133333333333334, "test_tensorexpr": 46.70666666666665, "test_tensorexpr_pybind": 0.8586666666666668, "test_testing": 32.637999999999984, "test_torch": 20.46666666666667, "test_transformers": 310.50599999999946, "test_type_hints": 0.4246666666666667, "test_type_info": 0.38233333333333336, "test_type_promotion": 3.5350000000000006, "test_typing": 80.81933333333335, "test_unary_ufuncs": 452.54233333322594, "test_utils": 37.83866666666726, "test_view_ops": 22.634666666666675, "test_vulkan": 0.001, "test_weak": 4.9656666666666665, "test_xnnpack_integration": 45.02166666666667, "torch_np/numpy_tests/core/test_dlpack": 0.004, "torch_np/numpy_tests/core/test_dtype": 0.5713333333333334, "torch_np/numpy_tests/core/test_einsum": 15.077666666666667, "torch_np/numpy_tests/core/test_getlimits": 0.3036666666666667, "torch_np/numpy_tests/core/test_indexing": 0.5810000000000003, "torch_np/numpy_tests/core/test_multiarray": 36.410666666666664, "torch_np/numpy_tests/core/test_numeric": 5.585666666666666, "torch_np/numpy_tests/core/test_numerictypes": 0.4133333333333334, "torch_np/numpy_tests/core/test_scalar_ctors": 0.41266666666666674, "torch_np/numpy_tests/core/test_scalar_methods": 0.37700000000000006, "torch_np/numpy_tests/core/test_scalarinherit": 0.0013333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 26.415999999999997, "torch_np/numpy_tests/core/test_shape_base": 0.7146666666666669, "torch_np/numpy_tests/fft/test_helper": 5.896333333333334, "torch_np/numpy_tests/fft/test_pocketfft": 5.600999999999999, "torch_np/numpy_tests/lib/test_arraypad": 0.39799999999999996, "torch_np/numpy_tests/lib/test_arraysetops": 0.5963333333333334, "torch_np/numpy_tests/lib/test_function_base": 2.3093333333333335, "torch_np/numpy_tests/lib/test_histograms": 0.6133333333333335, "torch_np/numpy_tests/lib/test_index_tricks": 0.38566666666666666, "torch_np/numpy_tests/lib/test_shape_base_": 0.9330000000000002, "torch_np/numpy_tests/lib/test_twodim_base": 0.5526666666666668, "torch_np/numpy_tests/lib/test_type_check": 0.4156666666666668, "torch_np/numpy_tests/linalg/test_linalg": 6.109666666666667, "torch_np/test_basic": 0.6693333333333339, "torch_np/test_binary_ufuncs": 0.45133333333333353, "torch_np/test_dtype": 0.31200000000000006, "torch_np/test_function_base": 0.2876666666666667, "torch_np/test_ndarray_methods": 3.1376666666666666, "torch_np/test_nep50_examples": 0.3096666666666669, "torch_np/test_random": 0.3323333333333334, "torch_np/test_reductions": 3.3273333333332773, "torch_np/test_scalars_0D_arrays": 0.331, "torch_np/test_ufuncs_basic": 1.2806666666666675, "torch_np/test_unary_ufuncs": 0.46366666666666684}, "default": {"backends/xeon/test_launch": 1.7353333333333332, "benchmark_utils/test_benchmark_utils": 1.5496666666666663, "distributions/test_constraints": 0.07200000000000005, "distributions/test_distributions": 59.94666666666668, "dynamo/test_activation_checkpointing": 0.5976666666666667, "dynamo/test_after_aot": 6.098333333333334, "dynamo/test_allow_inline_skip": 0.7776666666666667, "dynamo/test_aot_autograd": 12.211333333333336, "dynamo/test_aot_autograd_cache": 18.038333333333338, "dynamo/test_autograd_function": 2.946999999999999, "dynamo/test_backends": 14.786333333333332, "dynamo/test_backward_higher_order_ops": 13.220666666666666, "dynamo/test_base_output": 0.0033333333333333335, "dynamo/test_bytecode_hook": 6.100666666666666, "dynamo/test_bytecode_utils": 6.843, "dynamo/test_compile": 7.52, "dynamo/test_comptime": 0.6893333333333335, "dynamo/test_config": 0.543, "dynamo/test_cpp_guard_manager": 134.97800000000004, "dynamo/test_ctx_manager": 1.3533333333333335, "dynamo/test_debug_utils": 0.303, "dynamo/test_decorators": 6.862333333333332, "dynamo/test_deviceguard": 0.016666666666666666, "dynamo/test_dynamic_shapes": 717.5280000000001, "dynamo/test_exc": 1.9526666666666666, "dynamo/test_exceptions": 0.5843333333333335, "dynamo/test_export": 17.234333333333325, "dynamo/test_export_mutations": 0.5406666666666667, "dynamo/test_frame_init": 0.2876666666666667, "dynamo/test_functions": 18.280999999999995, "dynamo/test_fx_passes_pre_grad": 1.7776666666666667, "dynamo/test_global": 0.5026666666666667, "dynamo/test_guard_manager": 0.3056666666666667, "dynamo/test_higher_order_ops": 26.43033333333334, "dynamo/test_hooks": 27.215333333333334, "dynamo/test_inline_inbuilt_nn_modules": 111.9530000000001, "dynamo/test_input_attr_tracking": 8.994666666666665, "dynamo/test_interop": 0.535, "dynamo/test_logging": 19.515000000000004, "dynamo/test_minifier": 1.3549999999999998, "dynamo/test_misc": 61.15933333333337, "dynamo/test_model_output": 0.004666666666666667, "dynamo/test_modules": 22.233666666666664, "dynamo/test_nops": 0.393, "dynamo/test_optimizers": 0.635, "dynamo/test_pre_dispatch": 0.5173333333333333, "dynamo/test_profiler": 1.2913333333333332, "dynamo/test_python_autograd": 0.7406666666666667, "dynamo/test_recompile_ux": 0.9433333333333334, "dynamo/test_recompiles": 0.8380000000000001, "dynamo/test_reorder_logs": 0.49633333333333335, "dynamo/test_replay_record": 0.8876666666666667, "dynamo/test_repros": 54.603333333333374, "dynamo/test_resume": 0.39233333333333337, "dynamo/test_sdpa": 0.4746666666666666, "dynamo/test_skip_non_tensor": 0.651, "dynamo/test_sources": 0.47533333333333333, "dynamo/test_structured_trace": 19.064333333333334, "dynamo/test_subclasses": 15.799666666666665, "dynamo/test_subgraphs": 2.2016666666666658, "dynamo/test_trace_rules": 1.3806666666666665, "dynamo/test_triton_kernels": 0.12700000000000009, "dynamo/test_unspec": 17.191333333333336, "dynamo/test_verify_correctness": 0.544, "dynamo/test_view": 0.6013333333333333, "export/test_converter": 7.1209999999999996, "export/test_db": 3.0843333333333334, "export/test_experimental": 1.0823333333333334, "export/test_export": 32.74933333333333, "export/test_export_nonstrict": 27.804999999999993, "export/test_export_predispatch": 29.49433333333334, "export/test_functionalized_assertions": 0.29533333333333334, "export/test_funtionalized_assertions": 0.7006666666666668, "export/test_hop": 2.736333333333334, "export/test_lift_unlift": 0.17433333333333334, "export/test_pass_infra": 0.891, "export/test_passes": 12.863666666666665, "export/test_retraceability": 43.34099999999999, "export/test_safeguard": 0.9183333333333334, "export/test_schema": 0.32899999999999996, "export/test_serdes": 31.16966666666666, "export/test_serialize": 8.966666666666667, "export/test_sparse": 80.42066666666665, "export/test_tools": 0.6196666666666667, "export/test_torchbind": 3.1543333333333323, "export/test_tree_utils": 0.26133333333333336, "export/test_unflatten": 3.1020000000000003, "export/test_upgrade": 0.497, "export/test_verifier": 1.0493333333333335, "functorch/test_aotdispatch": 3242.285333333331, "functorch/test_control_flow": 104.64366666666666, "functorch/test_dims": 34.68, "functorch/test_eager_transforms": 18.244333333333334, "functorch/test_logging": 0.298, "functorch/test_memory_efficient_fusion": 0.59, "functorch/test_minifier": 0.45999999999999996, "functorch/test_ops": 3275.5813333333226, "functorch/test_parsing": 0.3016666666666667, "functorch/test_rearrange": 0.3176666666666667, "functorch/test_vmap": 564.3219999999978, "functorch/test_vmap_registrations": 3.735666666666503, "higher_order_ops/test_with_effects": 8.615333333333334, "inductor/test_benchmark_fusion": 8.626666666666665, "inductor/test_binary_folding": 39.35333333333334, "inductor/test_codecache": 43.322999999999986, "inductor/test_codegen_triton": 0.26533333333333337, "inductor/test_compile_worker": 13.333333333333334, "inductor/test_compiled_autograd": 493.5653333333336, "inductor/test_compiled_optimizers": 795.5130000000005, "inductor/test_config": 7.103333333333334, "inductor/test_control_flow": 0.011333333333333334, "inductor/test_cpp_wrapper": 976.902, "inductor/test_cpu_cpp_wrapper": 3016.5323333333326, "inductor/test_cpu_repro": 744.7283333333331, "inductor/test_cpu_select_algorithm": 3384.580666666667, "inductor/test_custom_lowering": 0.0030000000000000005, "inductor/test_custom_post_grad_passes": 11.344, "inductor/test_debug_trace": 3.3663333333333334, "inductor/test_decompose_mem_bound_mm": 0.0023333333333333335, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 35.28966666666667, "inductor/test_efficient_conv_bn_eval": 77.67866666666667, "inductor/test_extension_backend": 19.488666666666667, "inductor/test_flex_attention": 0.015000000000000006, "inductor/test_foreach": 17.808333333333387, "inductor/test_fused_attention": 179.07933333333335, "inductor/test_fx_fusion": 0.2753333333333333, "inductor/test_graph_transform_observer": 0.016, "inductor/test_group_batch_fusion": 0.2046666666666667, "inductor/test_indexing": 0.649, "inductor/test_inductor_freezing": 55.69133333333334, "inductor/test_memory_planning": 0.0, "inductor/test_metrics": 0.258, "inductor/test_minifier": 24.665000000000003, "inductor/test_minifier_isolate": 48.742333333333335, "inductor/test_mkldnn_pattern_matcher": 775.9463333333333, "inductor/test_mmdecomp": 0.014333333333333339, "inductor/test_profiler": 0.005666666666666667, "inductor/test_standalone_compile": 17.022, "inductor/test_templated_attention": 0.008, "inductor/test_torchbind": 9.748666666666667, "inductor/test_torchinductor": 1687.6490000000001, "inductor/test_torchinductor_codegen_dynamic_shapes": 1587.7473333333326, "inductor/test_torchinductor_dynamic_shapes": 1765.8036666666674, "inductor/test_torchinductor_opinfo": 26854.45466666667, "inductor/test_triton_extension_backend": 1.8066666666666666, "inductor/test_triton_kernels": 0.1093333333333334, "inductor/test_utils": 0.31833333333333336, "lazy/test_debug_util": 0.35366666666666663, "lazy/test_functionalization": 0.3036666666666667, "lazy/test_generator": 0.37233333333333335, "lazy/test_reuse_ir": 0.5576666666666666, "lazy/test_step_closures": 2.248666666666667, "lazy/test_ts_opinfo": 7.761333333333322, "nn/test_convolution": 18.660666666666632, "nn/test_dropout": 0.4096666666666666, "nn/test_embedding": 7.397999999999999, "nn/test_init": 4.191333333333333, "nn/test_lazy_modules": 0.47333333333333355, "nn/test_load_state_dict": 0.898, "nn/test_module_hooks": 0.20700000000000007, "nn/test_multihead_attention": 5.7749999999999995, "nn/test_packed_sequence": 0.4543333333333333, "nn/test_parametrization": 0.9250000000000002, "nn/test_pooling": 29.578666666666667, "nn/test_pruning": 0.11800000000000006, "profiler/test_execution_trace": 0.107, "profiler/test_memory_profiler": 4.671, "profiler/test_profiler": 21.400333333333332, "profiler/test_profiler_tree": 0.3303333333333334, "profiler/test_record_function": 0.30000000000000004, "profiler/test_torch_tidy": 4.437666666666665, "test_ao_sparsity": 7.751666666666666, "test_autocast": 0.8080000000000002, "test_autograd": 28.612000000000027, "test_autograd_fallback": 0.3700000000000001, "test_binary_ufuncs": 126.723333333333, "test_bundled_inputs": 1.2519999999999998, "test_comparison_utils": 0.299, "test_compile_benchmark_util": 0.0006666666666666666, "test_complex": 0.05666666666666668, "test_content_store": 5.855666666666667, "test_cpp_api_parity": 3.723999999999986, "test_cpp_extensions_aot_ninja": 0.035333333333333335, "test_cpp_extensions_aot_no_ninja": 0.036333333333333336, "test_cpp_extensions_jit": 27.947666666666667, "test_cpp_extensions_mtia_backend": 0.7276666666666666, "test_cpp_extensions_open_device_registration": 8.065, "test_cpp_extensions_stream_and_event": 0.7443333333333332, "test_custom_backend": 0.07133333333333332, "test_custom_ops": 7.054999999999999, "test_dataloader": 135.31366666666665, "test_datapipe": 12.187999999999997, "test_decomp": 5155.433333333339, "test_deploy": 0.25433333333333336, "test_dispatch": 24.37066666666666, "test_dlpack": 0.23500000000000018, "test_dynamic_shapes": 5.015666666666662, "test_expanded_weights": 8.136999999999997, "test_fake_tensor": 1.6810000000000003, "test_flop_counter": 0.4563333333333333, "test_foreach": 48.245666666666864, "test_function_schema": 0.7816666666666667, "test_functional_autograd_benchmark": 38.788333333333334, "test_functional_optim": 0.5293333333333333, "test_functionalization": 5.316333333333332, "test_functionalization_of_rng_ops": 0.016333333333333335, "test_futures": 0.9686666666666667, "test_fx": 223.23833333333323, "test_fx_experimental": 68.1966666666667, "test_fx_passes": 0.7500000000000001, "test_fx_reinplace_pass": 0.42666666666666675, "test_import_stats": 3.6503333333333337, "test_indexing": 2.006999999999999, "test_itt": 0.30233333333333334, "test_jit": 99.7283333333333, "test_jit_autocast": 17.889333333333333, "test_jit_cuda_fuser": 0.030000000000000013, "test_jit_disabled": 0.3996666666666666, "test_jit_fuser_te": 207.36133333333336, "test_jit_llga_fuser": 44.059333333333335, "test_legacy_vmap": 2.3096666666666663, "test_license": 0.24933333333333332, "test_linalg": 138.61266666666603, "test_logging": 2.363, "test_masked": 15.958666666666653, "test_maskedtensor": 6.6789999999999745, "test_meta": 1511.6439999999359, "test_mkl_verbose": 3.72, "test_mkldnn": 100.72899999999997, "test_mkldnn_fusion": 57.92666666666667, "test_mkldnn_verbose": 3.4163333333333337, "test_mobile_optimizer": 2.593, "test_model_dump": 1.0096666666666667, "test_model_exports_to_core_aten": 0.18466666666666667, "test_module_init": 1.9919999999999956, "test_module_tracker": 0.25666666666666665, "test_modules": 428.3153333333277, "test_monitor": 0.49833333333333335, "test_multiprocessing": 45.64233333333334, "test_multiprocessing_spawn": 24.99733333333333, "test_namedtensor": 0.45500000000000024, "test_namedtuple_return_api": 1.8786666666666667, "test_native_functions": 0.36800000000000005, "test_native_mha": 0.18400000000000008, "test_nestedtensor": 22.29333333333335, "test_nn": 136.89800000000068, "test_numba_integration": 0.007333333333333334, "test_numpy_interop": 0.19466666666666677, "test_nvfuser_frontend": 0.001, "test_openmp": 5.982666666666667, "test_ops": 2392.7083333333217, "test_ops_fwd_gradients": 589.6403333333318, "test_ops_gradients": 1040.0426666666283, "test_ops_jit": 862.3169999999991, "test_optim": 39.16233333333339, "test_out_dtype_op": 0.36833333333333335, "test_overrides": 1.9096666666665885, "test_package": 2.153666666666666, "test_per_overload_api": 0.261, "test_prims": 0.20733333333333334, "test_proxy_tensor": 680.1039999999997, "test_pruning_op": 0.528, "test_public_bindings": 6.773333333333333, "test_python_dispatch": 0.6153333333333335, "test_pytree": 0.47233333333333355, "test_quantization": 1908.8476666666666, "test_reductions": 193.99433333333502, "test_scatter_gather_ops": 3.8750000000000004, "test_schema_check": 172.5959999999973, "test_segment_reductions": 1.0230000000000001, "test_serialization": 34.71866666666667, "test_set_default_mobile_cpu_allocator": 0.259, "test_shape_ops": 1.2063333333333326, "test_show_pickle": 0.25533333333333336, "test_sort_and_select": 1.968333333333331, "test_sparse": 428.9376666666649, "test_sparse_csr": 160.18133333333347, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 6.039999999999991, "test_stateless": 5.991333333333334, "test_subclass": 0.5110000000000001, "test_sympy_utils": 17.290666666666667, "test_tensor_creation_ops": 21.883000000000028, "test_tensorboard": 29.677666666666667, "test_tensorexpr": 45.75999999999999, "test_tensorexpr_pybind": 0.9506666666666668, "test_testing": 35.14066666666664, "test_torch": 16.74433333333339, "test_transformers": 287.0403333333325, "test_type_hints": 0.36600000000000005, "test_type_info": 0.31333333333333335, "test_type_promotion": 2.9449999999999883, "test_typing": 71.95133333333335, "test_unary_ufuncs": 369.723333333276, "test_utils": 34.916666666667396, "test_view_ops": 14.636666666666676, "test_vulkan": 0.001, "test_weak": 4.670333333333333, "test_xnnpack_integration": 44.35233333333334, "torch_np/numpy_tests/core/test_dlpack": 0.015333333333333336, "torch_np/numpy_tests/core/test_dtype": 0.49400000000000005, "torch_np/numpy_tests/core/test_einsum": 12.72166666666667, "torch_np/numpy_tests/core/test_getlimits": 0.2743333333333334, "torch_np/numpy_tests/core/test_indexing": 0.6870000000000002, "torch_np/numpy_tests/core/test_multiarray": 26.104, "torch_np/numpy_tests/core/test_numeric": 5.821666666666665, "torch_np/numpy_tests/core/test_numerictypes": 0.3096666666666667, "torch_np/numpy_tests/core/test_scalar_ctors": 0.5056666666666668, "torch_np/numpy_tests/core/test_scalar_methods": 0.29066666666666663, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 21.654666666666667, "torch_np/numpy_tests/core/test_shape_base": 0.6420000000000002, "torch_np/numpy_tests/fft/test_helper": 5.013000000000001, "torch_np/numpy_tests/fft/test_pocketfft": 4.838333333333332, "torch_np/numpy_tests/lib/test_arraypad": 0.38466666666666666, "torch_np/numpy_tests/lib/test_arraysetops": 0.383, "torch_np/numpy_tests/lib/test_function_base": 2.063, "torch_np/numpy_tests/lib/test_histograms": 0.6433333333333335, "torch_np/numpy_tests/lib/test_index_tricks": 0.40633333333333344, "torch_np/numpy_tests/lib/test_shape_base_": 0.6586666666666668, "torch_np/numpy_tests/lib/test_twodim_base": 0.6950000000000002, "torch_np/numpy_tests/lib/test_type_check": 0.5456666666666669, "torch_np/numpy_tests/linalg/test_linalg": 5.945666666666665, "torch_np/test_basic": 0.6536666666666672, "torch_np/test_binary_ufuncs": 0.4196666666666668, "torch_np/test_dtype": 0.3346666666666667, "torch_np/test_function_base": 0.325, "torch_np/test_ndarray_methods": 2.718333333333334, "torch_np/test_nep50_examples": 0.05033333333333336, "torch_np/test_random": 0.37100000000000005, "torch_np/test_reductions": 2.839999999999948, "torch_np/test_scalars_0D_arrays": 0.466, "torch_np/test_ufuncs_basic": 1.083333333333334, "torch_np/test_unary_ufuncs": 0.48366666666666686}, "dynamo": {"backends/xeon/test_launch": 1.9903333333333333, "benchmark_utils/test_benchmark_utils": 2.7226666666666666, "distributions/test_constraints": 0.08166666666666672, "distributions/test_distributions": 430.17266666666666, "dynamo/test_after_aot": 8.0485, "dynamo/test_aot_autograd": 14.1495, "dynamo/test_autograd_function": 1.5020000000000002, "dynamo/test_backends": 13.765999999999998, "dynamo/test_backward_higher_order_ops": 12.5365, "dynamo/test_base_output": 0.04866666666666667, "dynamo/test_bytecode_hook": 7.8065, "dynamo/test_compile": 8.217, "dynamo/test_comptime": 0.49800000000000005, "dynamo/test_config": 0.5379999999999999, "dynamo/test_ctx_manager": 1.2870000000000001, "dynamo/test_debug_utils": 0.18099999999999997, "dynamo/test_decorators": 0.7003333333333335, "dynamo/test_exc": 1.6204999999999998, "dynamo/test_export_mutations": 0.4673333333333334, "dynamo/test_frame_init": 0.22, "dynamo/test_functions": 26.42749999999996, "dynamo/test_global": 0.5986666666666668, "dynamo/test_higher_order_ops": 8.714499999999997, "dynamo/test_hooks": 23.791333333333338, "dynamo/test_input_attr_tracking": 9.232333333333331, "dynamo/test_interop": 0.5916666666666668, "dynamo/test_logging": 11.678999999999995, "dynamo/test_minifier": 1.448, "dynamo/test_misc": 34.42850000000003, "dynamo/test_model_output": 0.004, "dynamo/test_nops": 0.397, "dynamo/test_optimizers": 2.0164999999999997, "dynamo/test_pre_dispatch": 0.49250000000000005, "dynamo/test_profiler": 0.9675, "dynamo/test_python_autograd": 0.6910000000000001, "dynamo/test_recompile_ux": 1.0553333333333332, "dynamo/test_recompiles": 0.8570000000000001, "dynamo/test_replay_record": 0.0033333333333333335, "dynamo/test_repros": 42.27000000000002, "dynamo/test_skip_non_tensor": 0.524, "dynamo/test_subclasses": 2.8360000000000003, "dynamo/test_subgraphs": 2.9139999999999997, "dynamo/test_unspec": 10.131, "dynamo/test_verify_correctness": 0.5803333333333334, "export/test_db": 4.859666666666667, "export/test_export": 25.45033333333333, "export/test_functionalized_assertions": 1.0119999999999998, "export/test_funtionalized_assertions": 2.0273333333333334, "export/test_pass_infra": 1.534, "export/test_passes": 5.653666666666667, "export/test_safeguard": 1.6956666666666669, "export/test_serialize": 13.794666666666664, "export/test_torchbind": 0.0, "export/test_unflatten": 2.508666666666667, "export/test_upgrade": 1.4166666666666667, "export/test_verifier": 1.6416666666666666, "functorch/test_aotdispatch": 88.08599999999974, "functorch/test_control_flow": 336.3029999999999, "functorch/test_dims": 0.004, "functorch/test_eager_transforms": 178.4913333333334, "functorch/test_logging": 1.024, "functorch/test_memory_efficient_fusion": 2.2389999999999994, "functorch/test_minifier": 2.337666666666667, "functorch/test_ops": 40.11500000000276, "functorch/test_parsing": 1.0676666666666668, "functorch/test_rearrange": 4.653666666666667, "functorch/test_vmap": 1136.8120000000001, "functorch/test_vmap_registrations": 13.274666666666583, "higher_order_ops/test_with_effects": 8.607999999999999, "inductor/test_benchmark_fusion": 18.726333333333333, "inductor/test_binary_folding": 22.584500000000002, "inductor/test_codecache": 20.153, "inductor/test_codegen_triton": 0.259, "inductor/test_compiled_autograd": 240.18900000000045, "inductor/test_compiled_optimizers": 185.22600000000017, "inductor/test_config": 3.8715, "inductor/test_cpu_cpp_wrapper": 366.154, "inductor/test_cpu_repro": 308.44000000000005, "inductor/test_custom_lowering": 0.0026666666666666666, "inductor/test_custom_post_grad_passes": 3.983333333333333, "inductor/test_debug_trace": 1.8966666666666665, "inductor/test_dependencies": 0.001, "inductor/test_efficient_conv_bn_eval": 0.001, "inductor/test_extension_backend": 3.310666666666666, "inductor/test_foreach": 11.49099999999999, "inductor/test_fused_attention": 41.594, "inductor/test_fx_fusion": 1.4053333333333333, "inductor/test_group_batch_fusion": 0.0, "inductor/test_indexing": 0.6295000000000001, "inductor/test_inductor_freezing": 36.5525, "inductor/test_memory_planning": 0.0003333333333333333, "inductor/test_minifier": 22.60766666666667, "inductor/test_minifier_isolate": 34.816, "inductor/test_mkldnn_pattern_matcher": 681.147, "inductor/test_mmdecomp": 27.706, "inductor/test_profiler": 0.002, "inductor/test_standalone_compile": 7.108, "inductor/test_torchinductor": 952.7994999999999, "inductor/test_torchinductor_codegen_dynamic_shapes": 798.9309999999989, "inductor/test_torchinductor_dynamic_shapes": 936.0326666666662, "inductor/test_torchinductor_opinfo": 2870.451999999996, "lazy/test_debug_util": 1.018, "lazy/test_functionalization": 1.279, "lazy/test_generator": 1.058, "lazy/test_reuse_ir": 1.63, "lazy/test_step_closures": 3.0389999999999997, "lazy/test_ts_opinfo": 3.178333333333329, "nn/test_convolution": 136.49766666666665, "nn/test_dropout": 4.583666666666667, "nn/test_embedding": 177.8793333333333, "nn/test_init": 1.7359999999999995, "nn/test_lazy_modules": 9.746666666666664, "nn/test_load_state_dict": 2.8746666666666663, "nn/test_module_hooks": 13.785333333333334, "nn/test_multihead_attention": 23.659666666666666, "nn/test_packed_sequence": 7.237666666666667, "nn/test_parametrization": 14.051, "nn/test_pooling": 47.625, "nn/test_pruning": 5.235666666666666, "profiler/test_execution_trace": 0.9783333333333334, "profiler/test_memory_profiler": 0.0023333333333333335, "profiler/test_profiler": 74.79866666666666, "profiler/test_profiler_tree": 45.89066666666667, "profiler/test_record_function": 1.3296666666666666, "profiler/test_torch_tidy": 6.842999999999999, "test_ao_sparsity": 67.61399999999999, "test_autocast": 7.530666666666668, "test_autograd": 100.76633333333332, "test_autograd_fallback": 2.1426666666666656, "test_binary_ufuncs": 527.0106666666582, "test_bundled_inputs": 2.7406666666666673, "test_comparison_utils": 1.1376666666666668, "test_compile_benchmark_util": 0.001, "test_complex": 0.6726666666666666, "test_content_store": 7.653333333333333, "test_cpp_api_parity": 86.16433333333362, "test_cpp_extensions_aot_ninja": 0.9433333333333334, "test_cpp_extensions_aot_no_ninja": 0.9383333333333335, "test_cpp_extensions_jit": 28.948000000000004, "test_cpp_extensions_mtia_backend": 1.355333333333333, "test_cpp_extensions_open_device_registration": 4.317666666666667, "test_cpp_extensions_stream_and_event": 1.3483333333333334, "test_custom_ops": 27.639, "test_dataloader": 223.48799999999997, "test_datapipe": 15.801666666666668, "test_decomp": 17.08300000000059, "test_deploy": 0.93, "test_dispatch": 34.24133333333333, "test_dlpack": 6.503, "test_dynamic_shapes": 3.5869999999999997, "test_expanded_weights": 24.887, "test_fake_tensor": 5.543333333333334, "test_flop_counter": 0.006000000000000001, "test_foreach": 27.71699999999979, "test_function_schema": 1.6323333333333332, "test_functional_autograd_benchmark": 34.845, "test_functional_optim": 2.007, "test_functionalization": 0.0036666666666666666, "test_functionalization_of_rng_ops": 0.16066666666666665, "test_futures": 3.2983333333333325, "test_fx": 233.12633333333315, "test_fx_experimental": 257.19100000000003, "test_fx_passes": 6.644999999999999, "test_fx_reinplace_pass": 2.4323333333333337, "test_import_stats": 4.657333333333333, "test_indexing": 57.44700000000001, "test_itt": 1.044, "test_jit": 262.32899999999995, "test_jit_autocast": 0.006666666666666667, "test_jit_disabled": 1.0519999999999998, "test_jit_fuser_te": 327.15300000000343, "test_jit_llga_fuser": 51.08833333333334, "test_legacy_vmap": 114.49766666666669, "test_license": 0.9333333333333335, "test_linalg": 1206.7619999999997, "test_logging": 2.8943333333333334, "test_masked": 34.29600000000007, "test_maskedtensor": 41.331333333333305, "test_meta": 79.31199999998819, "test_mkl_verbose": 4.5393333333333326, "test_mkldnn": 122.18900000000001, "test_mkldnn_fusion": 0.0013333333333333333, "test_mkldnn_verbose": 4.34, "test_mobile_optimizer": 4.859666666666667, "test_model_dump": 3.0820000000000003, "test_model_exports_to_core_aten": 0.9329999999999999, "test_module_init": 449.2890000000004, "test_module_tracker": 1.265, "test_modules": 29.635666666667102, "test_monitor": 1.1303333333333334, "test_multiprocessing": 25.036666666666672, "test_multiprocessing_spawn": 27.336666666666662, "test_namedtensor": 6.349999999999998, "test_namedtuple_return_api": 2.895, "test_native_functions": 1.995, "test_native_mha": 14.907333333333332, "test_nestedtensor": 55.104666666666674, "test_nn": 559.4773333333334, "test_numba_integration": 0.18866666666666673, "test_numpy_interop": 7.286999999999999, "test_nvfuser_frontend": 0.0, "test_openmp": 8.281333333333334, "test_ops": 58.39300000000486, "test_ops_fwd_gradients": 6.170666666666359, "test_ops_gradients": 10.062333333333266, "test_ops_jit": 2.0826666666666322, "test_optim": 341.0089999999996, "test_out_dtype_op": 0.8173333333333335, "test_overrides": 263.11766666666244, "test_package": 97.074, "test_per_overload_api": 1.4509999999999998, "test_prims": 1.0450000000000002, "test_proxy_tensor": 88.9943333333331, "test_pruning_op": 1.0713333333333332, "test_public_bindings": 1.732, "test_python_dispatch": 7.515666666666664, "test_pytree": 8.302333333333332, "test_quantization": 2031.3486666666668, "test_reductions": 397.50000000001836, "test_scatter_gather_ops": 127.84033333333332, "test_schema_check": 53.195000000001585, "test_segment_reductions": 20.90233333333333, "test_serialization": 51.35566666666667, "test_set_default_mobile_cpu_allocator": 0.9466666666666667, "test_shape_ops": 12.898666666666669, "test_show_pickle": 0.9169999999999999, "test_sort_and_select": 31.36499999999999, "test_sparse": 853.8660000000012, "test_sparse_csr": 265.26200000000705, "test_sparse_semi_structured": 0.1536666666666667, "test_spectral_ops": 25.435666666666805, "test_stateless": 13.698, "test_subclass": 3.6543333333333337, "test_sympy_utils": 37.041, "test_tensor_creation_ops": 152.16266666666667, "test_tensorboard": 32.1, "test_tensorexpr": 0.0026666666666666666, "test_tensorexpr_pybind": 3.4926666666666666, "test_testing": 95.1839999999998, "test_torch": 160.93066666666678, "test_transformers": 633.024, "test_type_hints": 0.9546666666666667, "test_type_info": 1.5546666666666669, "test_type_promotion": 49.843000000000025, "test_typing": 76.12466666666667, "test_unary_ufuncs": 219.19600000002887, "test_utils": 58.460666666666675, "test_view_ops": 44.333333333333336, "test_vulkan": 0.001, "test_weak": 6.744, "test_xnnpack_integration": 48.046, "torch_np/numpy_tests/core/test_dlpack": 0.0023333333333333335, "torch_np/numpy_tests/core/test_dtype": 1.632333333333331, "torch_np/numpy_tests/core/test_einsum": 25.019666666666666, "torch_np/numpy_tests/core/test_getlimits": 1.0923333333333334, "torch_np/numpy_tests/core/test_indexing": 3.343666666666666, "torch_np/numpy_tests/core/test_multiarray": 29.464, "torch_np/numpy_tests/core/test_numeric": 24.451000000000004, "torch_np/numpy_tests/core/test_numerictypes": 1.6226666666666665, "torch_np/numpy_tests/core/test_scalar_ctors": 2.472, "torch_np/numpy_tests/core/test_scalar_methods": 1.1466666666666667, "torch_np/numpy_tests/core/test_scalarinherit": 0.0016666666666666668, "torch_np/numpy_tests/core/test_scalarmath": 5.871666666666666, "torch_np/numpy_tests/core/test_shape_base": 4.1336666666666675, "torch_np/numpy_tests/fft/test_helper": 1.561, "torch_np/numpy_tests/fft/test_pocketfft": 49.06433333333334, "torch_np/numpy_tests/lib/test_arraypad": 1.5103333333333333, "torch_np/numpy_tests/lib/test_arraysetops": 3.759, "torch_np/numpy_tests/lib/test_function_base": 30.461666666666662, "torch_np/numpy_tests/lib/test_histograms": 6.005, "torch_np/numpy_tests/lib/test_index_tricks": 2.3529999999999993, "torch_np/numpy_tests/lib/test_shape_base_": 4.017333333333333, "torch_np/numpy_tests/lib/test_twodim_base": 2.9623333333333335, "torch_np/numpy_tests/lib/test_type_check": 3.6323333333333334, "torch_np/numpy_tests/linalg/test_linalg": 20.483333333333334, "torch_np/test_basic": 9.761999999999988, "torch_np/test_binary_ufuncs": 2.1509999999999985, "torch_np/test_dtype": 1.695999999999998, "torch_np/test_function_base": 0.9569999999999999, "torch_np/test_ndarray_methods": 10.107666666666665, "torch_np/test_nep50_examples": 0.20233333333333348, "torch_np/test_random": 2.304666666666666, "torch_np/test_reductions": 12.341333333333324, "torch_np/test_scalars_0D_arrays": 1.777, "torch_np/test_ufuncs_basic": 17.18799999999999, "torch_np/test_unary_ufuncs": 2.231999999999998}, "slow": {"backends/xeon/test_launch": 2.3529999999999998, "benchmark_utils/test_benchmark_utils": 292.80499999999984, "distributions/test_constraints": 0.08300000000000005, "distributions/test_distributions": 0.23400000000000015, "dynamo/test_activation_checkpointing": 0.30800000000000005, "dynamo/test_after_aot": 0.253, "dynamo/test_allow_inline_skip": 0.234, "dynamo/test_aot_autograd": 0.394, "dynamo/test_aot_autograd_cache": 0.263, "dynamo/test_autograd_function": 0.29800000000000004, "dynamo/test_backends": 0.325, "dynamo/test_backward_higher_order_ops": 0.266, "dynamo/test_base_output": 0.004, "dynamo/test_bytecode_hook": 0.264, "dynamo/test_bytecode_utils": 0.264, "dynamo/test_compile": 0.263, "dynamo/test_comptime": 0.265, "dynamo/test_config": 0.266, "dynamo/test_cpp_guard_manager": 1.3030000000000008, "dynamo/test_ctx_manager": 0.05100000000000003, "dynamo/test_debug_utils": 0.374, "dynamo/test_decorators": 0.269, "dynamo/test_deviceguard": 0.013000000000000001, "dynamo/test_dynamic_shapes": 2662.1840000000043, "dynamo/test_exc": 0.011, "dynamo/test_exceptions": 0.257, "dynamo/test_export": 0.19600000000000015, "dynamo/test_export_mutations": 0.388, "dynamo/test_frame_init": 0.334, "dynamo/test_functions": 0.7130000000000003, "dynamo/test_fx_passes_pre_grad": 0.256, "dynamo/test_global": 0.34800000000000003, "dynamo/test_guard_manager": 0.28, "dynamo/test_higher_order_ops": 0.5010000000000002, "dynamo/test_hooks": 0.28800000000000003, "dynamo/test_inline_inbuilt_nn_modules": 1.435000000000001, "dynamo/test_input_attr_tracking": 0.264, "dynamo/test_interop": 0.256, "dynamo/test_logging": 0.34600000000000003, "dynamo/test_minifier": 0.262, "dynamo/test_misc": 0.46200000000000035, "dynamo/test_model_output": 0.004, "dynamo/test_modules": 0.40100000000000013, "dynamo/test_nops": 0.26, "dynamo/test_optimizers": 0.295, "dynamo/test_pre_dispatch": 0.272, "dynamo/test_profiler": 0.264, "dynamo/test_python_autograd": 0.26, "dynamo/test_recompile_ux": 0.34800000000000003, "dynamo/test_recompiles": 0.257, "dynamo/test_reorder_logs": 0.264, "dynamo/test_replay_record": 0.1685, "dynamo/test_repros": 0.2420000000000002, "dynamo/test_resume": 0.254, "dynamo/test_sdpa": 0.255, "dynamo/test_skip_non_tensor": 0.299, "dynamo/test_sources": 0.264, "dynamo/test_structured_trace": 0.296, "dynamo/test_subclasses": 0.3420000000000001, "dynamo/test_subgraphs": 0.29700000000000004, "dynamo/test_trace_rules": 0.261, "dynamo/test_triton_kernels": 0.04500000000000002, "dynamo/test_unspec": 0.29700000000000004, "dynamo/test_verify_correctness": 0.257, "dynamo/test_view": 0.298, "export/test_converter": 0.375, "export/test_db": 0.29400000000000004, "export/test_experimental": 0.279, "export/test_export": 0.6340000000000001, "export/test_export_nonstrict": 0.17000000000000012, "export/test_export_predispatch": 0.1530000000000001, "export/test_functionalized_assertions": 0.258, "export/test_funtionalized_assertions": 0.6976666666666667, "export/test_hop": 0.02100000000000001, "export/test_lift_unlift": 0.265, "export/test_pass_infra": 0.265, "export/test_passes": 0.448, "export/test_retraceability": 0.18000000000000013, "export/test_safeguard": 0.242, "export/test_schema": 0.26, "export/test_serdes": 0.1560000000000001, "export/test_serialize": 0.4230000000000001, "export/test_sparse": 0.4430000000000001, "export/test_tools": 0.299, "export/test_torchbind": 2.7739999999999996, "export/test_tree_utils": 0.287, "export/test_unflatten": 0.275, "export/test_upgrade": 0.244, "export/test_verifier": 0.266, "functorch/test_aotdispatch": 1309.9459999999929, "functorch/test_control_flow": 0.3990000000000002, "functorch/test_dims": 0.32800000000000007, "functorch/test_eager_transforms": 0.3550000000000002, "functorch/test_logging": 0.386, "functorch/test_memory_efficient_fusion": 0.264, "functorch/test_minifier": 0.273, "functorch/test_ops": 144.5050000000079, "functorch/test_parsing": 0.275, "functorch/test_rearrange": 0.271, "functorch/test_vmap": 3.3629999999998788, "functorch/test_vmap_registrations": 2.148999999999894, "higher_order_ops/test_with_effects": 6.238, "inductor/test_benchmark_fusion": 14.276, "inductor/test_binary_folding": 0.003, "inductor/test_codecache": 0.04700000000000003, "inductor/test_codegen_triton": 0.164, "inductor/test_compile_worker": 0.289, "inductor/test_compiled_autograd": 0.7350000000000004, "inductor/test_compiled_optimizers": 1.0720000000000003, "inductor/test_config": 0.324, "inductor/test_control_flow": 0.13, "inductor/test_cpp_wrapper": 64.11750000000005, "inductor/test_cpu_cpp_wrapper": 1687.936999999998, "inductor/test_cpu_repro": 2231.700000000003, "inductor/test_cpu_select_algorithm": 0.2760000000000002, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 0.193, "inductor/test_debug_trace": 0.002, "inductor/test_decompose_mem_bound_mm": 0.005, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 0.317, "inductor/test_efficient_conv_bn_eval": 286.275, "inductor/test_extension_backend": 1.236, "inductor/test_flex_attention": 0.014000000000000005, "inductor/test_foreach": 0.037000000000000026, "inductor/test_fused_attention": 0.050000000000000024, "inductor/test_fx_fusion": 0.166, "inductor/test_graph_transform_observer": 0.019, "inductor/test_group_batch_fusion": 0.167, "inductor/test_indexing": 0.337, "inductor/test_inductor_freezing": 0.02700000000000001, "inductor/test_memory_planning": 0.0, "inductor/test_minifier": 0.289, "inductor/test_minifier_isolate": 0.401, "inductor/test_mkldnn_pattern_matcher": 0.25400000000000006, "inductor/test_mmdecomp": 0.025000000000000015, "inductor/test_profiler": 0.003, "inductor/test_standalone_compile": 0.523, "inductor/test_templated_attention": 0.006, "inductor/test_torchbind": 0.259, "inductor/test_torchinductor": 257.20299999999236, "inductor/test_torchinductor_codegen_dynamic_shapes": 250.38900000000191, "inductor/test_torchinductor_dynamic_shapes": 326.7269999999915, "inductor/test_torchinductor_opinfo": 5.657000000000431, "inductor/test_triton_extension_backend": 0.002, "inductor/test_triton_kernels": 0.08600000000000005, "inductor/test_utils": 0.295, "lazy/test_debug_util": 0.256, "lazy/test_functionalization": 0.355, "lazy/test_generator": 0.26, "lazy/test_reuse_ir": 0.377, "lazy/test_step_closures": 0.264, "lazy/test_ts_opinfo": 0.2760000000000002, "nn/test_convolution": 0.5850000000000004, "nn/test_dropout": 0.009000000000000001, "nn/test_embedding": 0.16600000000000012, "nn/test_init": 0.44100000000000006, "nn/test_lazy_modules": 0.07000000000000005, "nn/test_load_state_dict": 0.03900000000000002, "nn/test_module_hooks": 0.07900000000000001, "nn/test_multihead_attention": 0.019000000000000003, "nn/test_packed_sequence": 0.27, "nn/test_parametrization": 0.06100000000000004, "nn/test_pooling": 8.331999999999972, "nn/test_pruning": 0.056000000000000036, "profiler/test_execution_trace": 0.022000000000000006, "profiler/test_memory_profiler": 0.39, "profiler/test_profiler": 0.06400000000000003, "profiler/test_profiler_tree": 0.266, "profiler/test_record_function": 0.267, "profiler/test_torch_tidy": 0.29100000000000004, "test_ao_sparsity": 0.30400000000000005, "test_autocast": 0.262, "test_autograd": 7.187000000000083, "test_autograd_fallback": 0.278, "test_binary_ufuncs": 13.38499999999823, "test_bundled_inputs": 0.268, "test_comparison_utils": 0.263, "test_compile_benchmark_util": 0.001, "test_complex": 0.01900000000000001, "test_content_store": 0.004, "test_cpp_api_parity": 0.2910000000000002, "test_cpp_extensions_aot_ninja": 0.022000000000000006, "test_cpp_extensions_aot_no_ninja": 0.022000000000000006, "test_cpp_extensions_jit": 0.028000000000000014, "test_cpp_extensions_mtia_backend": 0.771, "test_cpp_extensions_open_device_registration": 1.763999999999998, "test_cpp_extensions_stream_and_event": 0.782, "test_custom_backend": 0.073, "test_custom_ops": 0.6590000000000003, "test_dataloader": 287.4620000000001, "test_datapipe": 0.532, "test_decomp": 2244.723000000333, "test_deploy": 0.262, "test_dispatch": 0.19400000000000003, "test_dlpack": 0.12500000000000008, "test_dynamic_shapes": 0.6630000000000003, "test_expanded_weights": 0.19100000000000014, "test_fake_tensor": 0.18300000000000013, "test_flop_counter": 0.030000000000000013, "test_foreach": 3.429999999999743, "test_function_schema": 0.313, "test_functional_autograd_benchmark": 149.101, "test_functional_optim": 0.291, "test_functionalization": 0.3670000000000001, "test_functionalization_of_rng_ops": 0.001, "test_futures": 0.28800000000000003, "test_fx": 223.1520000000001, "test_fx_experimental": 0.9070000000000006, "test_fx_passes": 0.31700000000000006, "test_fx_reinplace_pass": 0.35100000000000003, "test_import_stats": 0.257, "test_indexing": 0.09000000000000005, "test_itt": 0.305, "test_jit": 68.81700000000036, "test_jit_autocast": 0.06000000000000003, "test_jit_cuda_fuser": 0.01800000000000001, "test_jit_disabled": 0.254, "test_jit_fuser_te": 2268.1080000000215, "test_jit_llga_fuser": 47.04, "test_legacy_vmap": 0.1320000000000001, "test_license": 0.259, "test_linalg": 75.41200000000146, "test_logging": 0.258, "test_masked": 0.21300000000000016, "test_maskedtensor": 1.0300000000000007, "test_meta": 47.532999999981705, "test_mkl_verbose": 0.265, "test_mkldnn": 0.09500000000000007, "test_mkldnn_fusion": 0.275, "test_mkldnn_verbose": 0.262, "test_mobile_optimizer": 0.258, "test_model_dump": 0.307, "test_model_exports_to_core_aten": 0.261, "test_module_init": 0.3890000000000003, "test_module_tracker": 0.262, "test_modules": 5.6270000000000575, "test_monitor": 0.43899999999999995, "test_multiprocessing": 0.031000000000000017, "test_multiprocessing_spawn": 0.263, "test_namedtensor": 0.08900000000000007, "test_namedtuple_return_api": 0.241, "test_native_functions": 0.358, "test_native_mha": 0.028000000000000018, "test_nestedtensor": 0.5370000000000004, "test_nn": 2.2889999999999793, "test_numba_integration": 0.004, "test_numpy_interop": 0.04200000000000003, "test_nvfuser_frontend": 0.0, "test_openmp": 0.556, "test_ops": 949.5289999999595, "test_ops_fwd_gradients": 16.219999999998944, "test_ops_gradients": 771.1089999999352, "test_ops_jit": 111.3230000000015, "test_optim": 0.7200000000000005, "test_out_dtype_op": 0.02200000000000001, "test_overrides": 1.7549999999999233, "test_package": 0.38800000000000007, "test_per_overload_api": 0.396, "test_prims": 0.022000000000000002, "test_proxy_tensor": 8.018000000000132, "test_pruning_op": 0.307, "test_public_bindings": 0.261, "test_python_dispatch": 0.11400000000000007, "test_pytree": 0.43500000000000005, "test_quantization": 1041.6310000000005, "test_reductions": 28.000999999999966, "test_scatter_gather_ops": 0.08500000000000006, "test_schema_check": 6.728000000000635, "test_segment_reductions": 0.08100000000000006, "test_serialization": 0.1360000000000001, "test_set_default_mobile_cpu_allocator": 0.486, "test_shape_ops": 0.09700000000000007, "test_show_pickle": 0.249, "test_sort_and_select": 27.520000000000085, "test_sparse": 3.225999999999914, "test_sparse_csr": 5.19499999999969, "test_sparse_semi_structured": 0.003, "test_spectral_ops": 0.2830000000000002, "test_stateless": 0.07000000000000003, "test_subclass": 0.32500000000000007, "test_sympy_utils": 0.1630000000000001, "test_tensor_creation_ops": 2.5799999999999668, "test_tensorboard": 0.21100000000000002, "test_tensorexpr": 0.32800000000000007, "test_tensorexpr_pybind": 0.278, "test_testing": 2.6019999999999635, "test_torch": 9.262999999999629, "test_transformers": 2.1209999999999654, "test_type_hints": 0.354, "test_type_info": 0.41100000000000003, "test_type_promotion": 0.43700000000000033, "test_typing": 70.76200000000006, "test_unary_ufuncs": 26.53300000000852, "test_utils": 6.291000000000348, "test_view_ops": 0.44900000000000034, "test_vulkan": 0.001, "test_weak": 0.29800000000000004, "test_xnnpack_integration": 337.08400000000006, "torch_np/numpy_tests/core/test_dlpack": 0.010000000000000002, "torch_np/numpy_tests/core/test_dtype": 0.4340000000000001, "torch_np/numpy_tests/core/test_einsum": 0.31000000000000005, "torch_np/numpy_tests/core/test_getlimits": 0.317, "torch_np/numpy_tests/core/test_indexing": 0.32500000000000007, "torch_np/numpy_tests/core/test_multiarray": 660.6859999999998, "torch_np/numpy_tests/core/test_numeric": 0.6520000000000001, "torch_np/numpy_tests/core/test_numerictypes": 0.29000000000000004, "torch_np/numpy_tests/core/test_scalar_ctors": 0.3470000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.259, "torch_np/numpy_tests/core/test_scalarinherit": 0.007, "torch_np/numpy_tests/core/test_scalarmath": 43.98800000000001, "torch_np/numpy_tests/core/test_shape_base": 0.3550000000000001, "torch_np/numpy_tests/fft/test_helper": 0.261, "torch_np/numpy_tests/fft/test_pocketfft": 0.4710000000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.269, "torch_np/numpy_tests/lib/test_arraysetops": 0.264, "torch_np/numpy_tests/lib/test_function_base": 0.8130000000000004, "torch_np/numpy_tests/lib/test_histograms": 0.8560000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.29700000000000004, "torch_np/numpy_tests/lib/test_shape_base_": 0.4990000000000001, "torch_np/numpy_tests/lib/test_twodim_base": 0.37500000000000006, "torch_np/numpy_tests/lib/test_type_check": 0.29800000000000004, "torch_np/numpy_tests/linalg/test_linalg": 2.6999999999999993, "torch_np/test_basic": 0.4890000000000004, "torch_np/test_binary_ufuncs": 0.29100000000000004, "torch_np/test_dtype": 0.29800000000000004, "torch_np/test_function_base": 0.258, "torch_np/test_ndarray_methods": 0.8650000000000003, "torch_np/test_nep50_examples": 0.028000000000000004, "torch_np/test_random": 0.38500000000000006, "torch_np/test_reductions": 1.3450000000000004, "torch_np/test_scalars_0D_arrays": 0.28600000000000003, "torch_np/test_ufuncs_basic": 0.6280000000000003, "torch_np/test_unary_ufuncs": 0.30000000000000004}}, "linux-focal-py3.8-clang10-onnx": {"default": {"onnx/dynamo/test_dynamo_with_onnxruntime_backend": 30.188000000000006, "onnx/dynamo/test_exporter_api": 158.60166666666666, "onnx/dynamo/test_registry_dispatcher": 0.12166666666666669, "onnx/internal/test_beartype": 0.06433333333333334, "onnx/internal/test_diagnostics": 0.18533333333333335, "onnx/internal/test_registraion": 0.10800000000000004, "onnx/test_autograd_funs": 0.09333333333333334, "onnx/test_custom_ops": 0.12566666666666668, "onnx/test_export_modes": 0.12333333333333335, "onnx/test_fx_op_consistency": 8982.724999999993, "onnx/test_fx_passes": 2.236666666666667, "onnx/test_fx_to_onnx": 50.69466666666667, "onnx/test_fx_to_onnx_decomp_skip": 3.1043333333333334, "onnx/test_fx_to_onnx_with_onnxruntime": 772.2583333333333, "onnx/test_fx_type_promotion": 0.05533333333333334, "onnx/test_models_onnxruntime": 333.81700000000006, "onnx/test_onnx_opset": 0.779, "onnx/test_onnxscript_runtime": 0.09000000000000001, "onnx/test_op_consistency": 74.06133333333332, "onnx/test_operators": 3.262666666666662, "onnx/test_pytorch_jit_onnx": 0.1206666666666667, "onnx/test_pytorch_onnx_no_runtime": 1.182333333333333, "onnx/test_pytorch_onnx_onnxruntime": 1761.1743333333316, "onnx/test_pytorch_onnx_shape_inference": 0.2866666666666667, "onnx/test_symbolic_helper": 0.08333333333333333, "onnx/test_utility_funs": 13.836, "onnx/test_verification": 0.5626666666666666, "onnx/torch_export/test_torch_export_with_onnxruntime": 3.031333333333334}}, "linux-focal-rocm5.6-py3.8": {"default": {"backends/xeon/test_launch": 2.65, "benchmark_utils/test_benchmark_utils": 1.75, "distributions/test_constraints": 1.2859999999999978, "distributions/test_distributions": 53.327, "dynamo/test_activation_checkpointing": 1.8849999999999987, "dynamo/test_after_aot": 9.795, "dynamo/test_allow_inline_skip": 1.4556666666666667, "dynamo/test_aot_autograd": 17.454, "dynamo/test_autograd_function": 2.4490000000000003, "dynamo/test_backends": 18.038999999999998, "dynamo/test_backward_higher_order_ops": 21.869, "dynamo/test_base_output": 0.002, "dynamo/test_comptime": 1.3779999999999997, "dynamo/test_config": 1.4539999999999997, "dynamo/test_ctx_manager": 3.638999999999999, "dynamo/test_cudagraphs": 3.462, "dynamo/test_debug_utils": 0.451, "dynamo/test_decorators": 1.7799999999999996, "dynamo/test_dynamic_shapes": 573.8019999999999, "dynamo/test_exc": 2.406, "dynamo/test_export": 15.722999999999995, "dynamo/test_export_mutations": 1.4489999999999998, "dynamo/test_functions": 69.80800000000009, "dynamo/test_global": 1.3739999999999999, "dynamo/test_higher_order_ops": 22.062999999999995, "dynamo/test_hooks": 31.887000000000004, "dynamo/test_interop": 1.4409999999999998, "dynamo/test_logging": 17.441999999999993, "dynamo/test_minifier": 5.137, "dynamo/test_misc": 48.78100000000006, "dynamo/test_model_output": 0.001, "dynamo/test_modules": 14.829999999999995, "dynamo/test_nops": 0.509, "dynamo/test_optimizers": 3.4500000000000006, "dynamo/test_pre_dispatch": 1.537, "dynamo/test_profiler": 2.226, "dynamo/test_python_autograd": 1.94, "dynamo/test_recompiles": 1.944, "dynamo/test_replay_record": 0.002, "dynamo/test_repros": 48.946000000000005, "dynamo/test_skip_non_tensor": 1.4339999999999997, "dynamo/test_subclasses": 3.2769999999999992, "dynamo/test_subgraphs": 4.088, "dynamo/test_trace_rules": 2.218, "dynamo/test_unspec": 14.949, "dynamo/test_verify_correctness": 1.551, "export/test_db": 3.8149999999999995, "export/test_export": 9.349000000000002, "export/test_funtionalized_assertions": 0.425, "export/test_pass_infra": 1.664, "export/test_passes": 2.542, "export/test_serialize": 4.884999999999999, "export/test_unflatten": 2.542, "export/test_upgrade": 1.5479999999999998, "export/test_verifier": 1.8789999999999998, "functorch/test_aotdispatch": 101.76199999999997, "functorch/test_control_flow": 83.26699999999998, "functorch/test_dims": 23.257, "functorch/test_eager_transforms": 12.352999999999998, "functorch/test_memory_efficient_fusion": 11.324, "functorch/test_minifier": 0.6830000000000002, "functorch/test_ops": 9160.016000000058, "functorch/test_parsing": 0.29100000000000004, "functorch/test_rearrange": 0.271, "functorch/test_vmap": 497.6269999999992, "functorch/test_vmap_registrations": 2.1669999999998875, "inductor/test_benchmark_fusion": 60.267, "inductor/test_binary_folding": 12.591000000000001, "inductor/test_codecache": 92.84599999999999, "inductor/test_codegen_triton": 0.32, "inductor/test_compiled_autograd": 281.9960000000004, "inductor/test_config": 7.025000000000001, "inductor/test_coordinate_descent_tuner": 3.36, "inductor/test_cpp_wrapper": 2099.767, "inductor/test_cpu_repro": 581.3490000000002, "inductor/test_cuda_repro": 126.85399999999998, "inductor/test_cudagraph_trees": 65.05399999999999, "inductor/test_custom_lowering": 5.14, "inductor/test_custom_post_grad_passes": 4.632, "inductor/test_dependencies": 0.246, "inductor/test_efficient_conv_bn_eval": 263.484, "inductor/test_extension_backend": 32.027, "inductor/test_fp8": 0.007, "inductor/test_fused_attention": 51.290000000000006, "inductor/test_fx_fusion": 0.36300000000000004, "inductor/test_group_batch_fusion": 35.962999999999994, "inductor/test_indexing": 0.774, "inductor/test_inductor_freezing": 82.05999999999997, "inductor/test_inplacing_pass": 7.42, "inductor/test_kernel_benchmark": 15.100999999999999, "inductor/test_layout_optim": 13.019000000000002, "inductor/test_max_autotune": 37.817666666666675, "inductor/test_memory_planning": 3.619, "inductor/test_minifier": 58.906, "inductor/test_minifier_isolate": 54.839, "inductor/test_mkldnn_pattern_matcher": 125.89699999999996, "inductor/test_mmdecomp": 9.450999999999995, "inductor/test_pattern_matcher": 91.357, "inductor/test_perf": 8.956000000000001, "inductor/test_smoke": 6.348000000000001, "inductor/test_snode_runtime": 2.7900000000000005, "inductor/test_split_cat_fx_passes": 156.029, "inductor/test_standalone_compile": 12.517000000000001, "inductor/test_torchinductor": 2310.2849999999994, "inductor/test_torchinductor_codegen_dynamic_shapes": 1246.5309999999993, "inductor/test_torchinductor_dynamic_shapes": 2409.4539999999997, "inductor/test_torchinductor_opinfo": 1976.4399999999978, "inductor/test_triton_heuristics": 0.339, "inductor/test_triton_wrapper": 8.453, "lazy/test_debug_util": 0.417, "lazy/test_generator": 0.594, "lazy/test_reuse_ir": 0.836, "lazy/test_step_closures": 2.3129999999999997, "lazy/test_ts_opinfo": 0.512, "nn/test_convolution": 134.99699999999973, "nn/test_dropout": 0.8370000000000001, "nn/test_embedding": 14.464999999999991, "nn/test_lazy_modules": 1.027, "nn/test_module_hooks": 0.22500000000000003, "nn/test_multihead_attention": 8.185, "nn/test_packed_sequence": 1.189, "nn/test_parametrization": 1.2389999999999994, "nn/test_pooling": 31.311000000000007, "nn/test_pruning": 0.07600000000000004, "profiler/test_memory_profiler": 6.510000000000001, "profiler/test_profiler": 19.316000000000003, "profiler/test_profiler_tree": 1.0590000000000002, "test_ao_sparsity": 11.312999999999997, "test_autocast": 1.092, "test_autograd": 30.494999999999983, "test_autograd_fallback": 0.272, "test_binary_ufuncs": 130.54400000000092, "test_bundled_inputs": 1.4089999999999994, "test_comparison_utils": 0.393, "test_compile_benchmark_util": 0.0, "test_complex": 0.135, "test_content_store": 6.837, "test_cpp_api_parity": 15.518999999999973, "test_cpp_extensions_aot_ninja": 0.635, "test_cpp_extensions_aot_no_ninja": 0.552, "test_cpp_extensions_jit": 385.056, "test_cpp_extensions_open_device_registration": 32.861, "test_cuda": 54.47300000000001, "test_cuda_expandable_segments": 75.736, "test_cuda_multigpu": 1.4559999999999997, "test_cuda_primary_ctx": 0.003, "test_cuda_sanitizer": 0.8720000000000001, "test_cuda_trace": 1.9380000000000002, "test_custom_ops": 3.9419999999999966, "test_dataloader": 265.684, "test_datapipe": 3.8759999999999994, "test_decomp": 17382.137000000082, "test_deploy": 0.274, "test_dispatch": 58.27, "test_dlpack": 0.36400000000000016, "test_dynamic_shapes": 6.2269999999999985, "test_expanded_weights": 24.572999999999997, "test_fake_tensor": 1.0300000000000002, "test_flop_counter": 0.6290000000000001, "test_foreach": 324.3020000000007, "test_function_schema": 0.7360000000000001, "test_functional_autograd_benchmark": 42.550999999999995, "test_functional_optim": 0.39899999999999997, "test_functionalization": 5.352999999999995, "test_functionalization_of_rng_ops": 3.4139999999999997, "test_futures": 1.039, "test_fx": 289.739, "test_fx_experimental": 15.904, "test_fx_passes": 0.7040000000000002, "test_fx_reinplace_pass": 1.4579999999999997, "test_import_stats": 5.0280000000000005, "test_indexing": 2.402999999999998, "test_itt": 0.233, "test_jit": 220.82200000000003, "test_jit_autocast": 17.205000000000002, "test_jit_cuda_fuser": 1.4459999999999742, "test_jit_disabled": 0.379, "test_jit_fuser_te": 1638.3289999999993, "test_jit_llga_fuser": 0.18200000000000002, "test_jiterator": 28.949999999999974, "test_legacy_vmap": 3.0459999999999985, "test_license": 0.253, "test_linalg": 619.3119999999914, "test_logging": 2.773, "test_masked": 24.021000000000008, "test_maskedtensor": 5.192999999999948, "test_matmul_cuda": 58.974, "test_meta": 2267.7059999998114, "test_mkl_verbose": 4.346, "test_mkldnn": 108.90599999999995, "test_mkldnn_fusion": 36.047999999999995, "test_mkldnn_verbose": 5.189, "test_mobile_optimizer": 2.9269999999999996, "test_model_dump": 1.289, "test_module_init": 1.4419999999999937, "test_modules": 2578.6169999999825, "test_monitor": 0.43500000000000005, "test_multiprocessing": 49.797999999999995, "test_multiprocessing_spawn": 23.104, "test_namedtensor": 2.3349999999999964, "test_namedtuple_return_api": 2.081, "test_native_functions": 0.805, "test_native_mha": 1.3039999999999967, "test_nestedtensor": 5.951999999999993, "test_nn": 200.3900000000045, "test_numba_integration": 0.381, "test_numpy_interop": 0.29000000000000004, "test_nvfuser_frontend": 0.0, "test_openmp": 5.329000000000001, "test_ops": 7019.993999999921, "test_ops_fwd_gradients": 1613.2639999999728, "test_ops_gradients": 2761.1009999999387, "test_ops_jit": 1993.7589999999957, "test_optim": 191.34300000000002, "test_out_dtype_op": 1.6749999999999996, "test_overrides": 1.9839999999999223, "test_package": 2.407999999999999, "test_per_overload_api": 0.412, "test_prims": 1.0130000000000003, "test_proxy_tensor": 31.185, "test_pruning_op": 0.64, "test_public_bindings": 6.405, "test_python_dispatch": 0.5180000000000001, "test_pytree": 0.4440000000000001, "test_quantization": 6403.313000000002, "test_reductions": 101.02000000000308, "test_scatter_gather_ops": 20.523, "test_schema_check": 620.3319999999933, "test_segment_reductions": 2.3240000000000003, "test_serialization": 29.252000000000002, "test_set_default_mobile_cpu_allocator": 0.318, "test_shape_ops": 31.575000000000017, "test_show_pickle": 0.295, "test_sort_and_select": 5.384999999999997, "test_sparse": 946.3179999999977, "test_sparse_csr": 297.63100000000446, "test_sparse_semi_structured": 0.022000000000000013, "test_spectral_ops": 263.97700000000003, "test_stateless": 6.5409999999999995, "test_subclass": 1.2279999999999966, "test_sympy_utils": 21.131999999999998, "test_tensor_creation_ops": 172.99300000000028, "test_tensorboard": 23.435, "test_tensorexpr": 86.92600000000004, "test_tensorexpr_pybind": 0.7140000000000002, "test_testing": 32.59299999999998, "test_torch": 141.7000000000002, "test_transformers": 47.54099999999444, "test_type_hints": 0.282, "test_type_info": 0.263, "test_type_promotion": 15.823000000000023, "test_typing": 61.02999999999999, "test_unary_ufuncs": 288.607000000064, "test_utils": 45.38800000000022, "test_view_ops": 21.26700000000001, "test_vulkan": 0.0, "test_weak": 5.639999999999999, "test_xnnpack_integration": 78.121, "torch_np/numpy_tests/core/test_dlpack": 0.001, "torch_np/numpy_tests/core/test_dtype": 0.35200000000000004, "torch_np/numpy_tests/core/test_einsum": 13.716000000000001, "torch_np/numpy_tests/core/test_getlimits": 0.81, "torch_np/numpy_tests/core/test_indexing": 0.7620000000000001, "torch_np/numpy_tests/core/test_multiarray": 24.250999999999998, "torch_np/numpy_tests/core/test_numeric": 5.013999999999999, "torch_np/numpy_tests/core/test_numerictypes": 0.362, "torch_np/numpy_tests/core/test_scalar_ctors": 0.9670000000000002, "torch_np/numpy_tests/core/test_scalar_methods": 0.186, "torch_np/numpy_tests/core/test_scalarinherit": 0.002, "torch_np/numpy_tests/core/test_scalarmath": 23.671000000000003, "torch_np/numpy_tests/core/test_shape_base": 1.302, "torch_np/numpy_tests/fft/test_helper": 6.600999999999999, "torch_np/numpy_tests/fft/test_pocketfft": 4.394, "torch_np/numpy_tests/lib/test_arraypad": 0.779, "torch_np/numpy_tests/lib/test_arraysetops": 0.504, "torch_np/numpy_tests/lib/test_function_base": 2.6600000000000006, "torch_np/numpy_tests/lib/test_histograms": 1.5419999999999994, "torch_np/numpy_tests/lib/test_index_tricks": 0.8730000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 1.3659999999999997, "torch_np/numpy_tests/lib/test_twodim_base": 1.365, "torch_np/numpy_tests/lib/test_type_check": 0.789, "torch_np/numpy_tests/linalg/test_linalg": 6.0429999999999975, "torch_np/test_basic": 1.5430000000000004, "torch_np/test_binary_ufuncs": 0.769, "torch_np/test_dtype": 0.32000000000000006, "torch_np/test_function_base": 0.893, "torch_np/test_ndarray_methods": 2.1050000000000004, "torch_np/test_nep50_examples": 0.03100000000000001, "torch_np/test_random": 0.3360000000000001, "torch_np/test_reductions": 2.626999999999964, "torch_np/test_scalars_0D_arrays": 0.4750000000000001, "torch_np/test_ufuncs_basic": 1.4760000000000004, "torch_np/test_unary_ufuncs": 1.0799999999999998}, "distributed": {"distributed/_composable/fully_shard/test_fully_shard_compile": 44.803, "distributed/_composable/fully_shard/test_fully_shard_init": 25.021, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 4.457, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 21.509, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 9.937000000000001, "distributed/_composable/fully_shard/test_fully_shard_runtime": 12.157, "distributed/_composable/fully_shard/test_fully_shard_util": 4.457, "distributed/_composable/test_checkpoint": 0.723, "distributed/_composable/test_compose": 43.065999999999995, "distributed/_composable/test_contract": 0.191, "distributed/_composable/test_replicate": 31.548, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 18.672, "distributed/_shard/sharded_tensor/test_logger": 0.245, "distributed/_shard/sharding_spec/test_sharding_spec": 10.976999999999999, "distributed/_tensor/debug/test_op_coverage": 0.323, "distributed/_tensor/test_api": 17.584, "distributed/_tensor/test_basic_strategy": 0.7280000000000001, "distributed/_tensor/test_common_rules": 29.241, "distributed/_tensor/test_device_mesh": 87.97999999999999, "distributed/_tensor/test_dtensor": 98.487, "distributed/_tensor/test_dtensor_compile": 10.782, "distributed/_tensor/test_embedding_ops": 12.786, "distributed/_tensor/test_init": 26.213, "distributed/_tensor/test_math_ops": 13.725999999999999, "distributed/_tensor/test_matrix_ops": 37.667, "distributed/_tensor/test_op_strategy": 0.7440000000000001, "distributed/_tensor/test_pointwise_ops": 0.802, "distributed/_tensor/test_random_ops": 27.560000000000002, "distributed/_tensor/test_redistribute": 33.571000000000005, "distributed/_tensor/test_tensor_ops": 89.18100000000001, "distributed/_tensor/test_utils": 8.303, "distributed/_tensor/test_view_ops": 7.513, "distributed/_tensor/test_xla_integration": 0.247, "distributed/_tools/test_memory_tracker": 2.361, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 27.3, "distributed/algorithms/quantization/test_quantization": 16.891000000000005, "distributed/algorithms/test_join": 31.227, "distributed/checkpoint/e2e/test_fine_tuning": 2.902, "distributed/checkpoint/test_checkpoint": 30.572, "distributed/checkpoint/test_dedup_tensors": 0.192, "distributed/checkpoint/test_dtensor_checkpoint": 4.95, "distributed/checkpoint/test_dtensor_resharding": 21.263, "distributed/checkpoint/test_file_system_checkpoint": 25.631000000000004, "distributed/checkpoint/test_file_system_checkpoint_cpu": 34.352999999999994, "distributed/checkpoint/test_fsdp_model_state": 8.149000000000001, "distributed/checkpoint/test_fsdp_optim_state": 5.623, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 6.227, "distributed/checkpoint/test_fsspec": 6.6209999999999996, "distributed/checkpoint/test_hsdp_checkpoint": 11.984, "distributed/checkpoint/test_nested_dict": 0.195, "distributed/checkpoint/test_planner": 0.199, "distributed/checkpoint/test_state_dict": 41.397, "distributed/checkpoint/test_tp_checkpoint": 6.031, "distributed/checkpoint/test_traverse": 0.2, "distributed/checkpoint/test_utils": 0.17500000000000002, "distributed/elastic/events/lib_test": 0.272, "distributed/elastic/metrics/api_test": 0.278, "distributed/elastic/multiprocessing/api_test": 26.754000000000005, "distributed/elastic/timer/local_timer_example": 9.545, "distributed/elastic/timer/local_timer_test": 4.176, "distributed/elastic/utils/distributed_test": 3.4390000000000005, "distributed/elastic/utils/logging_test": 0.265, "distributed/elastic/utils/util_test": 0.27, "distributed/fsdp/test_checkpoint_wrapper": 0.9850000000000001, "distributed/fsdp/test_distributed_checkpoint": 9.062000000000001, "distributed/fsdp/test_fsdp_apply": 14.083, "distributed/fsdp/test_fsdp_backward_prefetch": 6.108, "distributed/fsdp/test_fsdp_checkpoint": 93.485, "distributed/fsdp/test_fsdp_clip_grad_norm": 37.265, "distributed/fsdp/test_fsdp_comm": 43.419000000000004, "distributed/fsdp/test_fsdp_comm_hooks": 132.36199999999997, "distributed/fsdp/test_fsdp_core": 1732.9520000000002, "distributed/fsdp/test_fsdp_dtensor_state_dict": 75.82100000000001, "distributed/fsdp/test_fsdp_exec_order": 38.252, "distributed/fsdp/test_fsdp_fine_tune": 24.441, "distributed/fsdp/test_fsdp_flatten_params": 42.625, "distributed/fsdp/test_fsdp_freezing_weights": 46.935, "distributed/fsdp/test_fsdp_fx": 0.209, "distributed/fsdp/test_fsdp_grad_acc": 51.315, "distributed/fsdp/test_fsdp_hybrid_shard": 40.404999999999994, "distributed/fsdp/test_fsdp_ignored_modules": 63.82899999999999, "distributed/fsdp/test_fsdp_input": 9.431000000000001, "distributed/fsdp/test_fsdp_memory": 14.963999999999999, "distributed/fsdp/test_fsdp_meta": 40.55200000000001, "distributed/fsdp/test_fsdp_misc": 106.22, "distributed/fsdp/test_fsdp_mixed_precision": 313.77699999999993, "distributed/fsdp/test_fsdp_multiple_forward": 5.549, "distributed/fsdp/test_fsdp_multiple_wrapping": 4.604, "distributed/fsdp/test_fsdp_optim_state": 326.649, "distributed/fsdp/test_fsdp_overlap": 61.229, "distributed/fsdp/test_fsdp_pure_fp16": 10.048, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 80.616, "distributed/fsdp/test_fsdp_state_dict": 806.0939999999996, "distributed/fsdp/test_fsdp_tp_integration": 16.535, "distributed/fsdp/test_fsdp_traversal": 4.406, "distributed/fsdp/test_fsdp_uneven": 5.208, "distributed/fsdp/test_fsdp_unshard_params": 63.812, "distributed/fsdp/test_fsdp_use_orig_params": 129.998, "distributed/fsdp/test_hsdp_dtensor_state_dict": 23.881, "distributed/fsdp/test_shard_utils": 4.423, "distributed/fsdp/test_utils": 0.572, "distributed/fsdp/test_wrap": 107.321, "distributed/nn/jit/test_instantiator": 0.234, "distributed/optim/test_zero_redundancy_optimizer": 149.97299999999998, "distributed/pipeline/sync/skip/test_api": 0.007, "distributed/pipeline/sync/skip/test_gpipe": 3.5049999999999994, "distributed/pipeline/sync/skip/test_inspect_skip_layout": 0.007, "distributed/pipeline/sync/skip/test_leak": 0.17800000000000005, "distributed/pipeline/sync/skip/test_portal": 0.318, "distributed/pipeline/sync/skip/test_stash_pop": 0.011000000000000001, "distributed/pipeline/sync/skip/test_tracker": 0.369, "distributed/pipeline/sync/skip/test_verify_skippables": 0.010000000000000002, "distributed/pipeline/sync/test_balance": 5.9449999999999985, "distributed/pipeline/sync/test_bugs": 2.2790000000000004, "distributed/pipeline/sync/test_checkpoint": 0.65, "distributed/pipeline/sync/test_copy": 0.861, "distributed/pipeline/sync/test_deferred_batch_norm": 0.7370000000000001, "distributed/pipeline/sync/test_dependency": 0.289, "distributed/pipeline/sync/test_inplace": 0.223, "distributed/pipeline/sync/test_microbatch": 0.011000000000000003, "distributed/pipeline/sync/test_phony": 0.006, "distributed/pipeline/sync/test_pipe": 2.7799999999999994, "distributed/pipeline/sync/test_pipeline": 0.002, "distributed/pipeline/sync/test_stream": 1.071, "distributed/pipeline/sync/test_transparency": 0.087, "distributed/pipeline/sync/test_worker": 0.037000000000000005, "distributed/tensor/parallel/test_ddp_2d_parallel": 3.173, "distributed/tensor/parallel/test_fsdp_2d_parallel": 63.370000000000005, "distributed/tensor/parallel/test_parallelize_api": 35.884, "distributed/tensor/parallel/test_tp_examples": 25.494999999999997, "distributed/tensor/parallel/test_tp_random_state": 2.886, "distributed/tensor/parallel/test_tp_style": 34.554, "distributed/tensor/parallel/test_view_sharding_dim_change": 4.288, "distributed/test_c10d_common": 70.48100000000001, "distributed/test_c10d_gloo": 430.2010000000001, "distributed/test_c10d_logger": 16.107999999999997, "distributed/test_c10d_nccl": 583.897, "distributed/test_c10d_object_collectives": 35.906, "distributed/test_c10d_pypg": 161.83299999999997, "distributed/test_c10d_spawn_gloo": 44.568, "distributed/test_c10d_spawn_nccl": 55.285, "distributed/test_c10d_spawn_ucc": 0.009000000000000001, "distributed/test_data_parallel": 7.270999999999998, "distributed/test_distributed_spawn": 840.5349999999992, "distributed/test_dynamo_distributed": 57.205999999999996, "distributed/test_fake_pg": 1.9309999999999996, "distributed/test_functional_api": 35.726000000000006, "distributed/test_hooks": 11.773, "distributed/test_inductor_collectives": 104.15500000000002, "distributed/test_launcher": 1.285, "distributed/test_multi_threaded_pg": 0.809, "distributed/test_nccl": 0.765, "distributed/test_pg_wrapper": 53.53399999999999, "distributed/test_store": 63.28599999999999}, "slow": {"backends/xeon/test_launch": 3.2350000000000003, "benchmark_utils/test_benchmark_utils": 366.5839999999999, "distributions/test_constraints": 0.7510000000000002, "distributions/test_distributions": 0.8780000000000002, "dynamo/test_activation_checkpointing": 0.24600000000000002, "dynamo/test_after_aot": 0.192, "dynamo/test_allow_inline_skip": 0.306, "dynamo/test_aot_autograd": 0.22200000000000003, "dynamo/test_autograd_function": 0.26, "dynamo/test_backends": 0.23600000000000002, "dynamo/test_backward_higher_order_ops": 0.201, "dynamo/test_base_output": 0.005, "dynamo/test_bytecode_hook": 0.189, "dynamo/test_compile": 0.193, "dynamo/test_comptime": 0.197, "dynamo/test_config": 0.189, "dynamo/test_ctx_manager": 0.055000000000000035, "dynamo/test_cudagraphs": 0.23900000000000002, "dynamo/test_debug_utils": 0.234, "dynamo/test_decorators": 0.203, "dynamo/test_dynamic_shapes": 60.429000000000016, "dynamo/test_exc": 0.011, "dynamo/test_export": 0.27200000000000013, "dynamo/test_export_mutations": 0.199, "dynamo/test_frame_init": 0.189, "dynamo/test_functions": 0.47600000000000026, "dynamo/test_global": 0.196, "dynamo/test_higher_order_ops": 0.3830000000000001, "dynamo/test_hooks": 0.21200000000000002, "dynamo/test_input_attr_tracking": 0.228, "dynamo/test_interop": 0.193, "dynamo/test_logging": 0.23300000000000004, "dynamo/test_minifier": 0.231, "dynamo/test_misc": 0.4160000000000003, "dynamo/test_model_output": 0.004, "dynamo/test_modules": 0.2900000000000001, "dynamo/test_nops": 0.224, "dynamo/test_optimizers": 0.226, "dynamo/test_pre_dispatch": 0.194, "dynamo/test_profiler": 0.198, "dynamo/test_python_autograd": 0.193, "dynamo/test_recompile_ux": 0.192, "dynamo/test_recompiles": 0.198, "dynamo/test_replay_record": 0.195, "dynamo/test_repros": 0.43600000000000017, "dynamo/test_sdpa": 0.189, "dynamo/test_skip_non_tensor": 0.198, "dynamo/test_sources": 0.186, "dynamo/test_subclasses": 0.28200000000000003, "dynamo/test_subgraphs": 0.26, "dynamo/test_trace_rules": 0.197, "dynamo/test_triton_kernels": 0.7240000000000003, "dynamo/test_unspec": 0.21700000000000003, "dynamo/test_verify_correctness": 0.193, "export/test_db": 0.22700000000000004, "export/test_experimental": 0.214, "export/test_export": 0.934, "export/test_export_nonstrict": 0.09800000000000007, "export/test_functionalized_assertions": 0.85, "export/test_funtionalized_assertions": 0.8116666666666666, "export/test_lift_unlift": 0.10200000000000001, "export/test_pass_infra": 0.19, "export/test_passes": 0.202, "export/test_retraceability": 0.1680000000000001, "export/test_safeguard": 0.225, "export/test_schema": 0.187, "export/test_serdes": 0.18600000000000008, "export/test_serialize": 1.076, "export/test_torchbind": 0.9660000000000001, "export/test_tree_utils": 0.19, "export/test_unflatten": 0.20600000000000002, "export/test_upgrade": 0.197, "export/test_verifier": 0.198, "functorch/test_aotdispatch": 0.16500000000000012, "functorch/test_control_flow": 0.4740000000000001, "functorch/test_dims": 0.45200000000000007, "functorch/test_eager_transforms": 0.35800000000000026, "functorch/test_logging": 0.226, "functorch/test_memory_efficient_fusion": 0.20700000000000002, "functorch/test_minifier": 0.188, "functorch/test_ops": 1527.6779999998287, "functorch/test_parsing": 0.879, "functorch/test_rearrange": 0.915, "functorch/test_vmap": 7.047000000000077, "functorch/test_vmap_registrations": 2.6439999999998225, "inductor/test_aot_inductor": 0.4820000000000004, "inductor/test_benchmark_fusion": 0.006, "inductor/test_binary_folding": 0.004, "inductor/test_codecache": 3.125, "inductor/test_codegen_triton": 0.194, "inductor/test_compiled_autograd": 0.36200000000000027, "inductor/test_compiled_optimizers": 0.21400000000000016, "inductor/test_config": 0.23500000000000001, "inductor/test_coordinate_descent_tuner": 0.225, "inductor/test_cpp_wrapper": 1971.4419999999986, "inductor/test_cpu_repro": 1032.0899999999979, "inductor/test_cuda_cpp_wrapper": 0.05700000000000004, "inductor/test_cuda_repro": 0.04700000000000003, "inductor/test_cudagraph_trees": 0.07200000000000004, "inductor/test_custom_lowering": 0.225, "inductor/test_custom_post_grad_passes": 0.302, "inductor/test_debug_trace": 0.002, "inductor/test_dependencies": 0.211, "inductor/test_efficient_conv_bn_eval": 298.004, "inductor/test_extension_backend": 31.346, "inductor/test_foreach": 0.19900000000000015, "inductor/test_fp8": 0.019000000000000006, "inductor/test_fused_attention": 0.047000000000000014, "inductor/test_fx_fusion": 0.193, "inductor/test_group_batch_fusion": 0.222, "inductor/test_indexing": 0.234, "inductor/test_inductor_freezing": 0.03500000000000002, "inductor/test_inplacing_pass": 0.224, "inductor/test_kernel_benchmark": 0.233, "inductor/test_layout_optim": 0.23, "inductor/test_max_autotune": 0.043000000000000024, "inductor/test_memory_planning": 0.003, "inductor/test_minifier": 0.384, "inductor/test_minifier_isolate": 0.334, "inductor/test_mkldnn_pattern_matcher": 0.28300000000000003, "inductor/test_mmdecomp": 0.033000000000000015, "inductor/test_move_constructors_to_cuda": 0.017000000000000005, "inductor/test_multi_kernel": 0.232, "inductor/test_pad_mm": 0.29500000000000004, "inductor/test_pattern_matcher": 0.04800000000000003, "inductor/test_perf": 0.28900000000000003, "inductor/test_profiler": 0.296, "inductor/test_smoke": 0.222, "inductor/test_snode_runtime": 0.229, "inductor/test_split_cat_fx_passes": 0.229, "inductor/test_standalone_compile": 0.226, "inductor/test_storage_offset": 0.003, "inductor/test_torchinductor": 0.6330000000000005, "inductor/test_torchinductor_codegen_dynamic_shapes": 259.55700000000314, "inductor/test_torchinductor_dynamic_shapes": 324.39600000000354, "inductor/test_torchinductor_opinfo": 7.846000000000594, "inductor/test_triton_heuristics": 0.227, "inductor/test_triton_wrapper": 0.218, "inductor/test_utils": 0.286, "lazy/test_debug_util": 0.811, "lazy/test_functionalization": 0.838, "lazy/test_generator": 0.836, "lazy/test_reuse_ir": 0.873, "lazy/test_step_closures": 0.841, "lazy/test_ts_opinfo": 0.567, "nn/test_convolution": 1.2600000000000005, "nn/test_dropout": 0.641, "nn/test_embedding": 0.7410000000000001, "nn/test_init": 0.937, "nn/test_lazy_modules": 0.7110000000000001, "nn/test_load_state_dict": 0.636, "nn/test_module_hooks": 0.6990000000000001, "nn/test_multihead_attention": 0.678, "nn/test_packed_sequence": 0.883, "nn/test_parametrization": 0.662, "nn/test_pooling": 8.841999999999969, "nn/test_pruning": 0.668, "profiler/test_memory_profiler": 0.8280000000000001, "profiler/test_profiler": 0.7540000000000001, "profiler/test_profiler_tree": 0.901, "test_ao_sparsity": 0.43300000000000005, "test_autocast": 0.906, "test_autograd": 7.255000000000087, "test_autograd_fallback": 0.884, "test_binary_ufuncs": 21.207999999998208, "test_bundled_inputs": 0.896, "test_comparison_utils": 0.842, "test_compile_benchmark_util": 0.001, "test_complex": 0.628, "test_content_store": 0.004, "test_cpp_api_parity": 1.1699999999999824, "test_cpp_extensions_aot_ninja": 0.582, "test_cpp_extensions_aot_no_ninja": 0.6, "test_cpp_extensions_jit": 0.589, "test_cpp_extensions_open_device_registration": 35.664, "test_cuda": 8.63499999999998, "test_cuda_expandable_segments": 10.930999999999981, "test_cuda_multigpu": 0.6950000000000001, "test_cuda_primary_ctx": 2.851, "test_cuda_sanitizer": 0.885, "test_cuda_trace": 10.215000000000002, "test_custom_ops": 3.906999999999997, "test_dataloader": 114.134, "test_datapipe": 1.007, "test_decomp": 3019.1740000011737, "test_deploy": 0.839, "test_dispatch": 0.902, "test_dlpack": 0.7820000000000001, "test_dynamic_shapes": 0.8490000000000002, "test_expanded_weights": 0.9500000000000002, "test_fake_tensor": 0.11800000000000008, "test_flop_counter": 0.193, "test_foreach": 1.8039999999999154, "test_function_schema": 0.889, "test_functional_autograd_benchmark": 120.868, "test_functional_optim": 0.365, "test_functionalization": 1.1039999999999983, "test_functionalization_of_rng_ops": 0.011000000000000003, "test_futures": 0.886, "test_fx": 281.484, "test_fx_experimental": 0.9240000000000006, "test_fx_passes": 0.9610000000000001, "test_fx_reinplace_pass": 0.871, "test_import_stats": 0.895, "test_indexing": 0.7220000000000001, "test_itt": 0.848, "test_jit": 107.01000000000012, "test_jit_autocast": 0.056000000000000036, "test_jit_cuda_fuser": 1.3539999999999763, "test_jit_disabled": 0.915, "test_jit_fuser_te": 786.160999999998, "test_jit_llga_fuser": 0.009000000000000001, "test_jiterator": 0.9030000000000002, "test_legacy_vmap": 0.7410000000000001, "test_license": 0.889, "test_linalg": 349.8419999999906, "test_logging": 0.885, "test_masked": 0.8060000000000002, "test_maskedtensor": 1.6600000000000004, "test_matmul_cuda": 0.763, "test_meta": 313.22299999960137, "test_mkl_verbose": 0.84, "test_mkldnn": 0.3980000000000001, "test_mkldnn_fusion": 0.898, "test_mkldnn_verbose": 0.822, "test_mobile_optimizer": 0.397, "test_model_dump": 0.86, "test_model_exports_to_core_aten": 0.271, "test_module_init": 0.3955000000000003, "test_modules": 1252.8169999999568, "test_monitor": 1.2, "test_multiprocessing": 0.909, "test_multiprocessing_spawn": 0.859, "test_namedtensor": 0.6980000000000001, "test_namedtuple_return_api": 0.787, "test_native_functions": 0.876, "test_native_mha": 0.798, "test_nestedtensor": 0.7710000000000002, "test_nn": 3.471999999999904, "test_numba_integration": 0.634, "test_numpy_interop": 0.749, "test_nvfuser_frontend": 0.01, "test_openmp": 0.869, "test_ops": 2005.951999999953, "test_ops_fwd_gradients": 168.57700000001364, "test_ops_gradients": 528.3639999999288, "test_ops_jit": 123.27600000000152, "test_optim": 1.2500000000000002, "test_out_dtype_op": 0.02700000000000001, "test_overrides": 2.5029999999998545, "test_package": 0.4100000000000001, "test_per_overload_api": 0.845, "test_prims": 0.5790000000000001, "test_proxy_tensor": 0.16700000000000012, "test_pruning_op": 0.806, "test_public_bindings": 0.887, "test_python_dispatch": 0.11200000000000007, "test_pytree": 1.0679999999999998, "test_quantization": 1097.87, "test_reductions": 5.703000000000107, "test_scatter_gather_ops": 0.7030000000000001, "test_schema_check": 9.420000000000403, "test_segment_reductions": 0.6960000000000001, "test_serialization": 0.8680000000000001, "test_set_default_mobile_cpu_allocator": 0.877, "test_shape_ops": 0.7090000000000001, "test_show_pickle": 0.839, "test_sort_and_select": 1.2259999999999915, "test_sparse": 368.65599999997164, "test_sparse_csr": 119.47199999999994, "test_sparse_semi_structured": 0.09100000000000005, "test_spectral_ops": 0.9670000000000002, "test_stateless": 0.737, "test_subclass": 0.8810000000000001, "test_sympy_utils": 0.5540000000000002, "test_tensor_creation_ops": 1.581999999999971, "test_tensorboard": 0.32400000000000007, "test_tensorexpr": 0.9660000000000001, "test_tensorexpr_pybind": 0.879, "test_testing": 2.8739999999999815, "test_torch": 28.54000000000085, "test_transformers": 50.461999999986574, "test_type_hints": 0.891, "test_type_info": 0.853, "test_type_promotion": 1.2459999999999802, "test_typing": 0.885, "test_unary_ufuncs": 26.637000000009458, "test_utils": 6.740000000000501, "test_view_ops": 0.8960000000000002, "test_vulkan": 0.0, "test_weak": 0.999, "test_xnnpack_integration": 237.23899999999998, "torch_np/numpy_tests/core/test_dlpack": 0.005, "torch_np/numpy_tests/core/test_dtype": 0.32700000000000007, "torch_np/numpy_tests/core/test_einsum": 0.358, "torch_np/numpy_tests/core/test_getlimits": 0.7969999999999999, "torch_np/numpy_tests/core/test_indexing": 0.3400000000000001, "torch_np/numpy_tests/core/test_multiarray": 848.7609999999999, "torch_np/numpy_tests/core/test_numeric": 0.5620000000000002, "torch_np/numpy_tests/core/test_numerictypes": 0.87, "torch_np/numpy_tests/core/test_scalar_ctors": 0.8690000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.794, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 58.16899999999999, "torch_np/numpy_tests/core/test_shape_base": 0.8760000000000001, "torch_np/numpy_tests/fft/test_helper": 0.811, "torch_np/numpy_tests/fft/test_pocketfft": 0.8590000000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.802, "torch_np/numpy_tests/lib/test_arraysetops": 0.275, "torch_np/numpy_tests/lib/test_function_base": 0.7600000000000003, "torch_np/numpy_tests/lib/test_histograms": 1.3439999999999976, "torch_np/numpy_tests/lib/test_index_tricks": 0.8500000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.8670000000000001, "torch_np/numpy_tests/lib/test_twodim_base": 0.8290000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.8490000000000001, "torch_np/numpy_tests/linalg/test_linalg": 2.3569999999999998, "torch_np/test_basic": 1.2179999999999995, "torch_np/test_binary_ufuncs": 0.852, "torch_np/test_dtype": 0.8390000000000001, "torch_np/test_function_base": 0.764, "torch_np/test_ndarray_methods": 0.48900000000000016, "torch_np/test_nep50_examples": 0.07100000000000004, "torch_np/test_random": 0.258, "torch_np/test_reductions": 1.8610000000000007, "torch_np/test_scalars_0D_arrays": 0.22000000000000003, "torch_np/test_ufuncs_basic": 1.2610000000000003, "torch_np/test_unary_ufuncs": 0.79}}, "linux-focal-rocm5.7-py3.8": {"default": {"backends/xeon/test_launch": 1.8145, "benchmark_utils/test_benchmark_utils": 2.952, "distributions/test_constraints": 0.6980000000000004, "distributions/test_distributions": 46.4745, "dynamo/test_activation_checkpointing": 16.3315, "dynamo/test_after_aot": 5.5825, "dynamo/test_aot_autograd": 18.952, "dynamo/test_autograd_function": 1.8374999999999992, "dynamo/test_backends": 10.576999999999998, "dynamo/test_backward_higher_order_ops": 10.965000000000002, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_hook": 5.3985, "dynamo/test_compile": 7.236, "dynamo/test_comptime": 0.65, "dynamo/test_config": 0.6900000000000001, "dynamo/test_ctx_manager": 2.0749999999999993, "dynamo/test_cudagraphs": 2.5445, "dynamo/test_debug_utils": 0.512, "dynamo/test_decorators": 0.7590000000000001, "dynamo/test_dynamic_shapes": 704.3735, "dynamo/test_exc": 1.5839999999999999, "dynamo/test_export": 17.46999999999999, "dynamo/test_export_mutations": 0.7355, "dynamo/test_frame_init": 0.1445, "dynamo/test_functions": 20.367499999999993, "dynamo/test_global": 0.6305000000000001, "dynamo/test_higher_order_ops": 17.45, "dynamo/test_hooks": 18.9865, "dynamo/test_input_attr_tracking": 7.032499999999999, "dynamo/test_interop": 0.7674999999999998, "dynamo/test_logging": 17.6015, "dynamo/test_minifier": 2.4654999999999996, "dynamo/test_misc": 34.55450000000003, "dynamo/test_model_output": 0.002, "dynamo/test_modules": 11.735999999999997, "dynamo/test_nops": 0.5990000000000001, "dynamo/test_optimizers": 1.8920000000000001, "dynamo/test_pre_dispatch": 0.6725000000000001, "dynamo/test_profiler": 1.254, "dynamo/test_python_autograd": 0.8815000000000001, "dynamo/test_recompile_ux": 1.1740000000000002, "dynamo/test_recompiles": 0.9405000000000001, "dynamo/test_replay_record": 0.7605000000000002, "dynamo/test_repros": 28.358500000000003, "dynamo/test_sdpa": 0.623, "dynamo/test_skip_non_tensor": 0.6859999999999999, "dynamo/test_sources": 0.1265, "dynamo/test_subclasses": 8.582999999999998, "dynamo/test_subgraphs": 2.118499999999999, "dynamo/test_trace_rules": 2.0414999999999996, "dynamo/test_triton_kernels": 17.2725, "dynamo/test_unspec": 10.8355, "dynamo/test_verify_correctness": 0.7575000000000001, "export/test_db": 2.6615, "export/test_experimental": 0.7655, "export/test_export": 18.684999999999995, "export/test_export_nonstrict": 14.986999999999998, "export/test_functionalized_assertions": 0.591, "export/test_funtionalized_assertions": 0.9663333333333334, "export/test_lift_unlift": 0.0825, "export/test_pass_infra": 0.9730000000000001, "export/test_passes": 1.4505, "export/test_retraceability": 22.434499999999996, "export/test_safeguard": 0.9335, "export/test_schema": 0.1585, "export/test_serdes": 15.7315, "export/test_serialize": 4.975999999999999, "export/test_torchbind": 0.5960000000000001, "export/test_tree_utils": 0.1245, "export/test_unflatten": 1.5465, "export/test_upgrade": 0.721, "export/test_verifier": 0.9215, "functorch/test_aotdispatch": 13.982500000000002, "functorch/test_control_flow": 79.42699999999998, "functorch/test_dims": 20.055500000000006, "functorch/test_eager_transforms": 7.115499999999999, "functorch/test_logging": 0.1775, "functorch/test_memory_efficient_fusion": 8.161999999999999, "functorch/test_minifier": 0.36950000000000005, "functorch/test_ops": 3048.20599999998, "functorch/test_parsing": 0.56, "functorch/test_rearrange": 0.5660000000000001, "functorch/test_vmap": 256.27549999999985, "functorch/test_vmap_registrations": 2.2834999999998606, "inductor/test_aot_inductor": 2173.2479999999996, "inductor/test_benchmark_fusion": 45.37949999999999, "inductor/test_binary_folding": 21.515, "inductor/test_codecache": 47.7665, "inductor/test_codegen_triton": 0.1915, "inductor/test_compiled_autograd": 212.5630000000004, "inductor/test_compiled_optimizers": 375.50750000000005, "inductor/test_config": 4.0305, "inductor/test_coordinate_descent_tuner": 1.8765, "inductor/test_cpp_wrapper": 833.6050000000001, "inductor/test_cpu_repro": 452.94849999999997, "inductor/test_cuda_cpp_wrapper": 738.1789999999999, "inductor/test_cuda_repro": 75.6455, "inductor/test_cudagraph_trees": 39.915, "inductor/test_custom_lowering": 2.1555, "inductor/test_custom_post_grad_passes": 4.1135, "inductor/test_debug_trace": 2.0255, "inductor/test_dependencies": 0.14900000000000002, "inductor/test_efficient_conv_bn_eval": 0.002, "inductor/test_extension_backend": 23.7965, "inductor/test_foreach": 139.32349999999997, "inductor/test_fp8": 0.004, "inductor/test_fused_attention": 123.38399999999999, "inductor/test_fx_fusion": 0.3665, "inductor/test_group_batch_fusion": 50.3435, "inductor/test_indexing": 0.4, "inductor/test_inductor_freezing": 48.358, "inductor/test_inductor_utils": 0.7476666666666666, "inductor/test_inplacing_pass": 2.3529999999999998, "inductor/test_kernel_benchmark": 52.695499999999996, "inductor/test_layout_optim": 5.0605, "inductor/test_max_autotune": 99.76250000000003, "inductor/test_memory_planning": 1.492, "inductor/test_minifier": 26.951, "inductor/test_minifier_isolate": 41.459999999999994, "inductor/test_mkldnn_pattern_matcher": 67.20399999999991, "inductor/test_mmdecomp": 6.858499999999999, "inductor/test_move_constructors_to_cuda": 11.277500000000002, "inductor/test_multi_kernel": 9.391000000000002, "inductor/test_pad_mm": 7.061333333333331, "inductor/test_pattern_matcher": 46.976000000000006, "inductor/test_perf": 5.5649999999999995, "inductor/test_profiler": 2.0504999999999995, "inductor/test_select_algorithm": 38.355000000000004, "inductor/test_smoke": 2.468, "inductor/test_snode_runtime": 2.6245000000000003, "inductor/test_split_cat_fx_passes": 74.42750000000001, "inductor/test_standalone_compile": 6.7295, "inductor/test_storage_offset": 2.058, "inductor/test_torchinductor": 702.2225, "inductor/test_torchinductor_codegen_dynamic_shapes": 1317.2275, "inductor/test_torchinductor_dynamic_shapes": 1650.8839999999993, "inductor/test_torchinductor_opinfo": 1242.0814999999914, "inductor/test_triton_heuristics": 0.1245, "inductor/test_triton_wrapper": 3.95, "inductor/test_unbacked_symints": 12.704, "inductor/test_utils": 0.2165, "lazy/test_debug_util": 0.5705, "lazy/test_functionalization": 0.5830000000000001, "lazy/test_generator": 0.587, "lazy/test_reuse_ir": 2.606, "lazy/test_step_closures": 2.526, "lazy/test_ts_opinfo": 0.608, "nn/test_convolution": 354.56949999999983, "nn/test_dropout": 1.3995, "nn/test_embedding": 9.580499999999978, "nn/test_init": 86.5245, "nn/test_lazy_modules": 6.014000000000003, "nn/test_load_state_dict": 1.3884999999999992, "nn/test_module_hooks": 0.5960000000000001, "nn/test_multihead_attention": 414.94899999999996, "nn/test_packed_sequence": 6.161, "nn/test_parametrization": 6.0525, "nn/test_pooling": 5.177499999999997, "nn/test_pruning": 0.43950000000000006, "profiler/test_memory_profiler": 3.7040000000000006, "profiler/test_profiler": 27.185000000000002, "profiler/test_profiler_tree": 0.5760000000000001, "test_ao_sparsity": 61.337500000000006, "test_autocast": 1.57, "test_autograd": 26.85824999999999, "test_autograd_fallback": 0.6535000000000001, "test_binary_ufuncs": 185.71850000000182, "test_bundled_inputs": 3.3164999999999996, "test_comparison_utils": 0.626, "test_compile_benchmark_util": 0.0, "test_complex": 0.485, "test_content_store": 2.0595, "test_cpp_api_parity": 13.914499999999961, "test_cpp_extensions_aot_ninja": 0.7565, "test_cpp_extensions_aot_no_ninja": 0.739, "test_cpp_extensions_jit": 282.909, "test_cpp_extensions_open_device_registration": 24.106, "test_cuda": 55.550000000000004, "test_cuda_expandable_segments": 45.45000000000002, "test_cuda_multigpu": 0.9225, "test_cuda_primary_ctx": 1.1475, "test_cuda_sanitizer": 0.783, "test_cuda_trace": 6.48, "test_custom_ops": 2.5575000000000006, "test_dataloader": 133.90150000000003, "test_datapipe": 7.557499999999999, "test_decomp": 4543.145999999985, "test_deploy": 0.535, "test_dispatch": 37.77100000000001, "test_dlpack": 0.6185, "test_dynamic_shapes": 4.2745, "test_expanded_weights": 30.022499999999994, "test_fake_tensor": 1.5280000000000005, "test_flop_counter": 5.516000000000001, "test_foreach": 114.97699999999958, "test_function_schema": 0.778, "test_functional_autograd_benchmark": 0.5295000000000001, "test_functional_optim": 0.265, "test_functionalization": 7.452499999999995, "test_functionalization_of_rng_ops": 1.9670000000000003, "test_futures": 1.2289999999999999, "test_fx": 191.892, "test_fx_experimental": 140.65149999999994, "test_fx_passes": 0.8385000000000002, "test_fx_reinplace_pass": 0.7560000000000001, "test_import_stats": 2.933, "test_indexing": 1.8104999999999953, "test_itt": 0.5175000000000001, "test_jit": 276.0695000000001, "test_jit_autocast": 16.927, "test_jit_disabled": 0.7025, "test_jit_fuser_te": 839.2310000000004, "test_jit_llga_fuser": 0.14, "test_jiterator": 17.123999999999945, "test_legacy_vmap": 2.4864999999999977, "test_license": 0.5485, "test_linalg": 280.055499999998, "test_logging": 2.2960000000000003, "test_masked": 19.724499999999978, "test_maskedtensor": 4.989500000000007, "test_matmul_cuda": 18.79550000000002, "test_meta": 1653.298499999865, "test_mkl_verbose": 3.136, "test_mkldnn_fusion": 209.389, "test_mkldnn_verbose": 2.9255, "test_mobile_optimizer": 3.0459999999999994, "test_model_dump": 1.49, "test_model_exports_to_core_aten": 0.194, "test_module_init": 1.4349999999999938, "test_modules": 557.5404999999738, "test_monitor": 0.7365, "test_multiprocessing": 43.49149999999999, "test_multiprocessing_spawn": 15.0815, "test_namedtensor": 2.2304999999999953, "test_namedtuple_return_api": 1.8064999999999998, "test_native_functions": 0.658, "test_native_mha": 0.9575000000000002, "test_nestedtensor": 4.976499999999994, "test_nn": 311.4125000000043, "test_numba_integration": 0.597, "test_numpy_interop": 0.6020000000000001, "test_openmp": 3.721, "test_ops": 4734.275249999981, "test_ops_fwd_gradients": 672.8324999999688, "test_ops_gradients": 881.0884999999532, "test_ops_jit": 904.012, "test_optim": 264.19899999999996, "test_out_dtype_op": 0.7825000000000001, "test_overrides": 2.278499999999893, "test_package": 1.5145, "test_per_overload_api": 0.6315, "test_prims": 0.7200000000000001, "test_proxy_tensor": 52.4375, "test_pruning_op": 0.6605, "test_public_bindings": 0.5375000000000001, "test_python_dispatch": 0.8660000000000001, "test_pytree": 0.7815000000000003, "test_quantization": 4700.676000000001, "test_reductions": 67.5570000000014, "test_scatter_gather_ops": 11.116499999999998, "test_schema_check": 418.7514999999943, "test_segment_reductions": 1.875, "test_serialization": 20.841000000000008, "test_set_default_mobile_cpu_allocator": 0.6145, "test_shape_ops": 18.064499999999992, "test_show_pickle": 0.5549999999999999, "test_sort_and_select": 3.742499999999997, "test_sparse": 342.96849999999813, "test_sparse_csr": 613.9329999999977, "test_sparse_semi_structured": 0.0675, "test_spectral_ops": 105.88150000000019, "test_stateless": 4.162, "test_subclass": 0.6880000000000001, "test_sympy_utils": 13.063000000000002, "test_tensor_creation_ops": 74.19700000000034, "test_tensorboard": 15.492, "test_tensorexpr": 56.18150000000001, "test_tensorexpr_pybind": 0.8445, "test_testing": 22.118999999999932, "test_torch": 133.25325000000058, "test_transformers": 77.0060000000027, "test_type_hints": 0.521, "test_type_info": 0.544, "test_type_promotion": 10.649500000000003, "test_typing": 40.513999999999974, "test_unary_ufuncs": 545.9729999998882, "test_utils": 27.856000000000357, "test_view_ops": 14.110999999999997, "test_vulkan": 0.0, "test_weak": 4.36, "test_xnnpack_integration": 33.170500000000004, "torch_np/numpy_tests/core/test_dlpack": 0.002, "torch_np/numpy_tests/core/test_dtype": 0.28950000000000004, "torch_np/numpy_tests/core/test_einsum": 10.455, "torch_np/numpy_tests/core/test_getlimits": 0.505, "torch_np/numpy_tests/core/test_indexing": 0.5845000000000002, "torch_np/numpy_tests/core/test_multiarray": 20.051500000000004, "torch_np/numpy_tests/core/test_numeric": 2.9469999999999996, "torch_np/numpy_tests/core/test_numerictypes": 0.547, "torch_np/numpy_tests/core/test_scalar_ctors": 0.627, "torch_np/numpy_tests/core/test_scalar_methods": 0.493, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 16.52, "torch_np/numpy_tests/core/test_shape_base": 0.7620000000000001, "torch_np/numpy_tests/fft/test_helper": 4.3025, "torch_np/numpy_tests/fft/test_pocketfft": 25.796000000000003, "torch_np/numpy_tests/lib/test_arraypad": 0.509, "torch_np/numpy_tests/lib/test_arraysetops": 0.28250000000000003, "torch_np/numpy_tests/lib/test_function_base": 1.5475000000000003, "torch_np/numpy_tests/lib/test_histograms": 1.7690000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.546, "torch_np/numpy_tests/lib/test_shape_base_": 0.897, "torch_np/numpy_tests/lib/test_twodim_base": 1.4809999999999999, "torch_np/numpy_tests/lib/test_type_check": 0.5730000000000001, "torch_np/numpy_tests/linalg/test_linalg": 3.6870000000000007, "torch_np/test_basic": 1.3970000000000002, "torch_np/test_binary_ufuncs": 0.5790000000000001, "torch_np/test_dtype": 0.524, "torch_np/test_function_base": 0.5635, "torch_np/test_ndarray_methods": 1.6870000000000007, "torch_np/test_nep50_examples": 0.030000000000000013, "torch_np/test_random": 0.18100000000000002, "torch_np/test_reductions": 2.2509999999999826, "torch_np/test_scalars_0D_arrays": 0.23500000000000004, "torch_np/test_ufuncs_basic": 1.1600000000000004, "torch_np/test_unary_ufuncs": 0.5940000000000001}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_collectives": 128.9675, "distributed/_composable/fsdp/test_fully_shard_comm": 13.219999999999999, "distributed/_composable/fsdp/test_fully_shard_init": 1.9005, "distributed/_composable/fsdp/test_fully_shard_state": 0.7635000000000001, "distributed/_composable/fsdp/test_fully_shard_training": 158.56900000000002, "distributed/_composable/fully_shard/test_fully_shard_compile": 77.859, "distributed/_composable/fully_shard/test_fully_shard_init": 37.197, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 7.0235, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 32.226, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 16.093, "distributed/_composable/fully_shard/test_fully_shard_runtime": 19.514499999999998, "distributed/_composable/fully_shard/test_fully_shard_util": 6.9695, "distributed/_composable/test_checkpoint": 1.185, "distributed/_composable/test_compose": 69.59299999999999, "distributed/_composable/test_contract": 0.3055, "distributed/_composable/test_replicate": 48.52550000000001, "distributed/_composable/test_replicate_with_compiler": 51.012, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 24.1535, "distributed/_shard/sharded_tensor/test_logger": 0.9984999999999999, "distributed/_shard/sharding_spec/test_sharding_spec": 16.6965, "distributed/_shard/test_sharder": 9.34, "distributed/_tensor/debug/test_comm_mode": 1.2414999999999998, "distributed/_tensor/debug/test_op_coverage": 0.6245, "distributed/_tensor/experimental/test_tp_transform": 17.9785, "distributed/_tensor/test_api": 28.9005, "distributed/_tensor/test_common_rules": 50.5895, "distributed/_tensor/test_convolution_ops": 56.227, "distributed/_tensor/test_dtensor": 179.6055, "distributed/_tensor/test_dtensor_compile": 67.9225, "distributed/_tensor/test_embedding_ops": 22.345, "distributed/_tensor/test_experimental_ops": 21.079, "distributed/_tensor/test_init": 36.572500000000005, "distributed/_tensor/test_math_ops": 58.937, "distributed/_tensor/test_matrix_ops": 62.929500000000004, "distributed/_tensor/test_op_strategy": 0.593, "distributed/_tensor/test_optimizers": 76.7665, "distributed/_tensor/test_pointwise_ops": 0.917, "distributed/_tensor/test_random_ops": 43.659, "distributed/_tensor/test_redistribute": 45.1885, "distributed/_tensor/test_tensor_ops": 154.4625, "distributed/_tensor/test_utils": 11.674999999999999, "distributed/_tensor/test_view_ops": 10.1635, "distributed/_tensor/test_xla_integration": 0.27, "distributed/_tools/test_memory_tracker": 3.9844999999999997, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 41.706, "distributed/algorithms/quantization/test_quantization": 63.94499999999999, "distributed/algorithms/test_join": 50.5695, "distributed/checkpoint/e2e/test_e2e_save_and_load": 41.7365, "distributed/checkpoint/e2e/test_fine_tuning": 4.8555, "distributed/checkpoint/e2e/test_fsdp_ep": 4.5169999999999995, "distributed/checkpoint/e2e/test_pipeline": 6.3965, "distributed/checkpoint/test_checkpoint": 44.5475, "distributed/checkpoint/test_compatibility": 0.7489999999999999, "distributed/checkpoint/test_dedup_tensors": 0.2945, "distributed/checkpoint/test_dtensor_checkpoint": 8.0175, "distributed/checkpoint/test_dtensor_resharding": 45.6395, "distributed/checkpoint/test_file_system_checkpoint": 38.433, "distributed/checkpoint/test_file_system_checkpoint_cpu": 51.971000000000004, "distributed/checkpoint/test_fsdp_model_state": 13.2195, "distributed/checkpoint/test_fsdp_optim_state": 17.8985, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 9.9645, "distributed/checkpoint/test_fsspec": 10.795000000000002, "distributed/checkpoint/test_hsdp_checkpoint": 17.044, "distributed/checkpoint/test_nested_dict": 0.2955, "distributed/checkpoint/test_planner": 0.319, "distributed/checkpoint/test_save_load_api": 3.38, "distributed/checkpoint/test_state_dict": 94.1265, "distributed/checkpoint/test_state_dict_utils": 18.404, "distributed/checkpoint/test_torch_save_to_dcp": 15.559999999999999, "distributed/checkpoint/test_tp_checkpoint": 16.3585, "distributed/checkpoint/test_traverse": 0.31200000000000006, "distributed/checkpoint/test_utils": 0.3155, "distributed/elastic/events/lib_test": 1.0835, "distributed/elastic/metrics/api_test": 0.92, "distributed/elastic/multiprocessing/api_test": 38.7485, "distributed/elastic/timer/local_timer_example": 14.747, "distributed/elastic/timer/local_timer_test": 6.596500000000001, "distributed/elastic/utils/distributed_test": 4.237, "distributed/elastic/utils/logging_test": 1.0710000000000002, "distributed/elastic/utils/util_test": 1.008, "distributed/fsdp/test_checkpoint_wrapper": 1.4644999999999997, "distributed/fsdp/test_distributed_checkpoint": 0.27849999999999997, "distributed/fsdp/test_fsdp_apply": 20.7545, "distributed/fsdp/test_fsdp_backward_prefetch": 10.1315, "distributed/fsdp/test_fsdp_checkpoint": 137.38, "distributed/fsdp/test_fsdp_clip_grad_norm": 62.64349999999999, "distributed/fsdp/test_fsdp_comm": 68.697, "distributed/fsdp/test_fsdp_comm_hooks": 196.93200000000002, "distributed/fsdp/test_fsdp_core": 2591.3705, "distributed/fsdp/test_fsdp_dtensor_state_dict": 121.9915, "distributed/fsdp/test_fsdp_exec_order": 61.855000000000004, "distributed/fsdp/test_fsdp_fine_tune": 55.934, "distributed/fsdp/test_fsdp_flatten_params": 66.1515, "distributed/fsdp/test_fsdp_freezing_weights": 269.257, "distributed/fsdp/test_fsdp_fx": 0.317, "distributed/fsdp/test_fsdp_grad_acc": 74.85900000000001, "distributed/fsdp/test_fsdp_hybrid_shard": 75.99199999999999, "distributed/fsdp/test_fsdp_ignored_modules": 99.63750000000002, "distributed/fsdp/test_fsdp_input": 13.797999999999998, "distributed/fsdp/test_fsdp_memory": 23.481, "distributed/fsdp/test_fsdp_meta": 64.0965, "distributed/fsdp/test_fsdp_misc": 110.39850000000001, "distributed/fsdp/test_fsdp_mixed_precision": 485.72100000000006, "distributed/fsdp/test_fsdp_multiple_forward": 8.2125, "distributed/fsdp/test_fsdp_multiple_wrapping": 7.679, "distributed/fsdp/test_fsdp_optim_state": 519.1379999999999, "distributed/fsdp/test_fsdp_overlap": 212.82399999999998, "distributed/fsdp/test_fsdp_pure_fp16": 14.854, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 175.10750000000002, "distributed/fsdp/test_fsdp_state_dict": 1247.275, "distributed/fsdp/test_fsdp_tp_integration": 37.04, "distributed/fsdp/test_fsdp_traversal": 6.89, "distributed/fsdp/test_fsdp_uneven": 7.758, "distributed/fsdp/test_fsdp_unshard_params": 93.9265, "distributed/fsdp/test_fsdp_use_orig_params": 206.55699999999996, "distributed/fsdp/test_hsdp_dtensor_state_dict": 35.878, "distributed/fsdp/test_shard_utils": 12.9415, "distributed/fsdp/test_utils": 1.4829999999999997, "distributed/fsdp/test_wrap": 170.64899999999997, "distributed/nn/jit/test_instantiator": 0.9420000000000001, "distributed/optim/test_zero_redundancy_optimizer": 242.5725, "distributed/pipeline/sync/skip/test_api": 0.0185, "distributed/pipeline/sync/skip/test_gpipe": 5.542, "distributed/pipeline/sync/skip/test_inspect_skip_layout": 0.0105, "distributed/pipeline/sync/skip/test_leak": 0.7190000000000001, "distributed/pipeline/sync/skip/test_portal": 0.376, "distributed/pipeline/sync/skip/test_stash_pop": 0.034, "distributed/pipeline/sync/skip/test_tracker": 0.4545, "distributed/pipeline/sync/skip/test_verify_skippables": 0.015000000000000003, "distributed/pipeline/sync/test_balance": 9.013499999999999, "distributed/pipeline/sync/test_bugs": 5.0305, "distributed/pipeline/sync/test_checkpoint": 1.1945000000000001, "distributed/pipeline/sync/test_copy": 5.0809999999999995, "distributed/pipeline/sync/test_deferred_batch_norm": 2.092, "distributed/pipeline/sync/test_dependency": 0.43599999999999994, "distributed/pipeline/sync/test_inplace": 0.3385, "distributed/pipeline/sync/test_microbatch": 0.017000000000000005, "distributed/pipeline/sync/test_phony": 0.018500000000000003, "distributed/pipeline/sync/test_pipe": 4.903499999999999, "distributed/pipeline/sync/test_pipeline": 0.003, "distributed/pipeline/sync/test_stream": 1.8855, "distributed/pipeline/sync/test_transparency": 0.5269999999999999, "distributed/pipeline/sync/test_worker": 0.029, "distributed/tensor/parallel/test_ddp_2d_parallel": 4.821, "distributed/tensor/parallel/test_fsdp_2d_parallel": 41.695, "distributed/tensor/parallel/test_parallelize_api": 37.8955, "distributed/tensor/parallel/test_tp_examples": 47.391, "distributed/tensor/parallel/test_tp_random_state": 4.664, "distributed/tensor/parallel/test_tp_style": 51.646, "distributed/tensor/parallel/test_view_sharding_dim_change": 5.068, "distributed/test_c10d_common": 103.40899999999999, "distributed/test_c10d_functional_native": 247.48700000000002, "distributed/test_c10d_gloo": 725.9490000000001, "distributed/test_c10d_logger": 25.067, "distributed/test_c10d_nccl": 1313.3805000000002, "distributed/test_c10d_object_collectives": 57.94800000000001, "distributed/test_c10d_pypg": 253.581, "distributed/test_c10d_spawn_gloo": 70.348, "distributed/test_c10d_spawn_nccl": 89.94250000000001, "distributed/test_c10d_spawn_ucc": 0.013500000000000002, "distributed/test_compute_comm_reordering": 46.485, "distributed/test_data_parallel": 12.268499999999998, "distributed/test_device_mesh": 166.109, "distributed/test_distributed_spawn": 5142.826499999988, "distributed/test_dynamo_distributed": 142.5375, "distributed/test_fake_pg": 2.9369999999999994, "distributed/test_functional_api": 114.09, "distributed/test_inductor_collectives": 168.6175, "distributed/test_launcher": 2.5555, "distributed/test_multi_threaded_pg": 0.9340000000000002, "distributed/test_nccl": 2.070499999999999, "distributed/test_pg_wrapper": 101.37100000000001, "distributed/test_store": 92.576}}, "linux-focal-rocm6.0-py3.8": {"default": {"backends/xeon/test_launch": 2.176, "benchmark_utils/test_benchmark_utils": 3.8379999999999996, "distributions/test_constraints": 3.5580000000000003, "distributions/test_distributions": 46.040000000000006, "dynamo/test_activation_checkpointing": 32.766000000000005, "dynamo/test_after_aot": 4.485, "dynamo/test_aot_autograd": 25.08799999999999, "dynamo/test_aot_autograd_cache": 0.30300000000000005, "dynamo/test_autograd_function": 2.0449999999999995, "dynamo/test_backends": 9.346, "dynamo/test_backward_higher_order_ops": 9.42, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_hook": 4.605, "dynamo/test_compile": 5.109999999999999, "dynamo/test_comptime": 0.32600000000000007, "dynamo/test_config": 0.329, "dynamo/test_cpp_guard_manager": 112.22700000000017, "dynamo/test_ctx_manager": 3.9629999999999983, "dynamo/test_cudagraphs": 2.9669999999999996, "dynamo/test_debug_utils": 3.0579999999999994, "dynamo/test_decorators": 0.40800000000000014, "dynamo/test_deviceguard": 0.014, "dynamo/test_dynamic_shapes": 417.385, "dynamo/test_exc": 1.534, "dynamo/test_export": 17.297999999999995, "dynamo/test_export_mutations": 0.33100000000000007, "dynamo/test_frame_init": 0.188, "dynamo/test_functions": 6.070999999999983, "dynamo/test_fx_passes_pre_grad": 1.195, "dynamo/test_global": 0.30100000000000005, "dynamo/test_guard_manager": 0.21600000000000003, "dynamo/test_higher_order_ops": 23.708, "dynamo/test_hooks": 18.84400000000001, "dynamo/test_input_attr_tracking": 6.026000000000001, "dynamo/test_interop": 0.321, "dynamo/test_logging": 22.027000000000008, "dynamo/test_minifier": 4.484999999999999, "dynamo/test_misc": 41.92100000000009, "dynamo/test_model_output": 0.001, "dynamo/test_modules": 14.286000000000001, "dynamo/test_nops": 0.251, "dynamo/test_optimizers": 0.46, "dynamo/test_pre_dispatch": 0.323, "dynamo/test_profiler": 1.03, "dynamo/test_python_autograd": 0.422, "dynamo/test_recompile_ux": 0.7390000000000001, "dynamo/test_recompiles": 0.54, "dynamo/test_reorder_logs": 0.29000000000000004, "dynamo/test_replay_record": 1.0003333333333335, "dynamo/test_repros": 29.878999999999998, "dynamo/test_sdpa": 0.28700000000000003, "dynamo/test_skip_non_tensor": 0.30500000000000005, "dynamo/test_sources": 0.25, "dynamo/test_structured_trace": 16.114, "dynamo/test_subclasses": 11.960000000000003, "dynamo/test_subgraphs": 1.6259999999999994, "dynamo/test_trace_rules": 1.8929999999999998, "dynamo/test_triton_kernels": 19.522999999999996, "dynamo/test_unspec": 8.238999999999999, "dynamo/test_verify_correctness": 0.337, "export/test_db": 2.1049999999999995, "export/test_experimental": 0.388, "export/test_export": 21.158999999999992, "export/test_export_nonstrict": 18.249000000000006, "export/test_export_predispatch": 21.472000000000005, "export/test_functionalized_assertions": 0.707, "export/test_hop": 0.656, "export/test_lift_unlift": 0.056, "export/test_pass_infra": 0.6430000000000001, "export/test_passes": 9.166, "export/test_retraceability": 27.883999999999986, "export/test_safeguard": 0.5650000000000001, "export/test_schema": 0.22, "export/test_serdes": 36.17199999999999, "export/test_serialize": 10.078000000000001, "export/test_torchbind": 1.159, "export/test_tree_utils": 0.188, "export/test_unflatten": 2.286, "export/test_upgrade": 0.35000000000000003, "export/test_verifier": 0.599, "functorch/test_aotdispatch": 21.281999999999996, "functorch/test_control_flow": 68.62299999999995, "functorch/test_dims": 21.088, "functorch/test_eager_transforms": 9.747999999999992, "functorch/test_logging": 0.217, "functorch/test_memory_efficient_fusion": 8.273000000000001, "functorch/test_minifier": 0.3460000000000001, "functorch/test_ops": 2844.3689999999983, "functorch/test_parsing": 0.745, "functorch/test_rearrange": 0.772, "functorch/test_vmap": 313.4729999999994, "functorch/test_vmap_registrations": 2.527999999999845, "higher_order_ops/test_with_effects": 4.529, "inductor/test_aot_inductor": 4583.435, "inductor/test_benchmark_fusion": 152.04299999999998, "inductor/test_binary_folding": 33.622, "inductor/test_codecache": 88.127, "inductor/test_codegen_triton": 0.2, "inductor/test_compiled_autograd": 171.23500000000007, "inductor/test_compiled_optimizers": 1301.6029999999998, "inductor/test_config": 3.675999999999998, "inductor/test_control_flow": 136.94100000000003, "inductor/test_coordinate_descent_tuner": 3.338, "inductor/test_cpu_repro": 426.004, "inductor/test_cuda_cpp_wrapper": 826.1119999999999, "inductor/test_cuda_repro": 118.369, "inductor/test_cudagraph_trees": 92.849, "inductor/test_custom_lowering": 4.86, "inductor/test_custom_post_grad_passes": 8.408, "inductor/test_cutlass_backend": 42.99233333333334, "inductor/test_debug_trace": 1.842, "inductor/test_decompose_mem_bound_mm": 50.982000000000006, "inductor/test_dependencies": 0.161, "inductor/test_distributed_patterns": 27.201000000000008, "inductor/test_efficient_conv_bn_eval": 0.001, "inductor/test_extension_backend": 35.729, "inductor/test_flex_attention": 0.002, "inductor/test_foreach": 387.06299999999976, "inductor/test_fp8": 0.002, "inductor/test_fused_attention": 169.48, "inductor/test_fx_fusion": 0.44100000000000006, "inductor/test_group_batch_fusion": 79.316, "inductor/test_indexing": 0.41300000000000003, "inductor/test_inductor_freezing": 86.44200000000001, "inductor/test_inplacing_pass": 8.36, "inductor/test_kernel_benchmark": 138.55200000000002, "inductor/test_layout_optim": 15.308, "inductor/test_max_autotune": 215.18000000000004, "inductor/test_memory_planning": 5.477, "inductor/test_metrics": 4.111, "inductor/test_minifier": 24.286, "inductor/test_minifier_isolate": 44.799, "inductor/test_mkldnn_pattern_matcher": 85.45100000000012, "inductor/test_mmdecomp": 18.236000000000008, "inductor/test_move_constructors_to_cuda": 12.591000000000001, "inductor/test_multi_kernel": 68.58399999999999, "inductor/test_pad_mm": 204.70399999999998, "inductor/test_padding": 23.662, "inductor/test_pattern_matcher": 98.15400000000002, "inductor/test_perf": 12.126, "inductor/test_profiler": 5.545, "inductor/test_select_algorithm": 107.25299999999999, "inductor/test_smoke": 8.747, "inductor/test_snode_runtime": 6.002999999999999, "inductor/test_split_cat_fx_passes": 79.283, "inductor/test_standalone_compile": 13.527000000000001, "inductor/test_templated_attention": 0.002, "inductor/test_torchinductor": 1638.6389999999992, "inductor/test_torchinductor_codegen_dynamic_shapes": 1931.563, "inductor/test_torchinductor_dynamic_shapes": 2773.8950000000004, "inductor/test_torchinductor_opinfo": 3844.893999999995, "inductor/test_triton_extension_backend": 0.525, "inductor/test_triton_heuristics": 0.146, "inductor/test_triton_kernels": 40.35900000000004, "inductor/test_triton_wrapper": 6.371, "inductor/test_unbacked_symints": 31.461000000000002, "inductor/test_utils": 0.184, "lazy/test_debug_util": 0.756, "lazy/test_functionalization": 0.787, "lazy/test_generator": 0.754, "lazy/test_reuse_ir": 2.299, "lazy/test_step_closures": 2.738, "lazy/test_ts_opinfo": 0.801, "nn/test_convolution": 363.8819999999999, "nn/test_dropout": 1.4629999999999999, "nn/test_embedding": 10.621999999999986, "nn/test_init": 3.92, "nn/test_lazy_modules": 4.25, "nn/test_load_state_dict": 1.7429999999999992, "nn/test_module_hooks": 0.804, "nn/test_multihead_attention": 501.08, "nn/test_packed_sequence": 4.149, "nn/test_parametrization": 10.409999999999998, "nn/test_pooling": 4.969999999999999, "nn/test_pruning": 0.7010000000000001, "profiler/test_execution_trace": 5.625, "profiler/test_memory_profiler": 4.397, "profiler/test_profiler": 26.672, "profiler/test_profiler_tree": 0.855, "profiler/test_record_function": 0.793, "profiler/test_torch_tidy": 3.7179999999999995, "test_ao_sparsity": 97.57000000000001, "test_autocast": 4.552, "test_autograd": 37.324000000000005, "test_autograd_fallback": 0.8230000000000001, "test_binary_ufuncs": 173.57975000000147, "test_bundled_inputs": 1.6369999999999996, "test_comparison_utils": 0.745, "test_compile_benchmark_util": 0.0, "test_complex": 0.683, "test_content_store": 3.158, "test_cpp_api_parity": 15.14800000000003, "test_cpp_extensions_aot_ninja": 0.73, "test_cpp_extensions_aot_no_ninja": 0.752, "test_cpp_extensions_jit": 291.48900000000003, "test_cpp_extensions_mtia_backend": 0.395, "test_cpp_extensions_open_device_registration": 25.168, "test_cpp_extensions_stream_and_event": 0.37, "test_cuda": 87.22749999999996, "test_cuda_expandable_segments": 47.128, "test_cuda_multigpu": 1.1219999999999997, "test_cuda_primary_ctx": 1.105, "test_cuda_sanitizer": 1.0259999999999998, "test_cuda_trace": 6.102999999999999, "test_custom_ops": 17.911999999999995, "test_dataloader": 157.06200000000004, "test_datapipe": 7.735999999999999, "test_decomp": 5499.847999999992, "test_deploy": 0.697, "test_dispatch": 42.889, "test_dlpack": 0.8170000000000002, "test_dynamic_shapes": 3.5310000000000006, "test_expanded_weights": 35.83099999999999, "test_fake_tensor": 1.3120000000000003, "test_flop_counter": 4.245, "test_foreach": 303.98599999999715, "test_function_schema": 0.949, "test_functional_autograd_benchmark": 47.705, "test_functional_optim": 0.30900000000000005, "test_functionalization": 7.144999999999994, "test_functionalization_of_rng_ops": 1.796, "test_futures": 1.3699999999999999, "test_fx": 179.83799999999994, "test_fx_experimental": 116.82600000000001, "test_fx_passes": 1.044, "test_fx_reinplace_pass": 0.8890000000000001, "test_import_stats": 3.787, "test_indexing": 2.715999999999993, "test_itt": 0.798, "test_jit": 190.8559999999998, "test_jit_autocast": 17.384999999999998, "test_jit_disabled": 0.887, "test_jit_fuser_te": 611.2629999999992, "test_jit_llga_fuser": 0.2, "test_jiterator": 18.388999999999964, "test_legacy_vmap": 54.590999999999966, "test_license": 0.772, "test_linalg": 1260.0279999999934, "test_logging": 3.149, "test_masked": 20.168999999999972, "test_maskedtensor": 5.540000000000008, "test_matmul_cuda": 22.887000000000018, "test_meta": 1780.5079999999414, "test_mkl_verbose": 4.982, "test_mkldnn_fusion": 32.946999999999996, "test_mkldnn_verbose": 3.872, "test_mobile_optimizer": 3.1679999999999997, "test_model_dump": 1.7129999999999999, "test_model_exports_to_core_aten": 0.186, "test_modules": 910.958999999957, "test_monitor": 0.851, "test_multiprocessing": 45.12499999999999, "test_multiprocessing_spawn": 18.948999999999998, "test_namedtensor": 2.5539999999999954, "test_namedtuple_return_api": 2.077, "test_native_functions": 0.8210000000000001, "test_native_mha": 3.7379999999999955, "test_nestedtensor": 7.660999999999989, "test_nn": 385.432750000005, "test_numba_integration": 0.8300000000000001, "test_numpy_interop": 0.7450000000000001, "test_openmp": 3.767, "test_ops": 5672.5505000000585, "test_ops_fwd_gradients": 689.3620000000096, "test_ops_gradients": 908.5220000000163, "test_ops_jit": 903.8799999999994, "test_optim": 508.0169999999997, "test_out_dtype_op": 0.373, "test_overrides": 2.497999999999875, "test_package": 1.6779999999999997, "test_per_overload_api": 0.731, "test_prims": 0.8200000000000001, "test_proxy_tensor": 39.308, "test_pruning_op": 0.9610000000000001, "test_public_bindings": 0.749, "test_python_dispatch": 0.4620000000000001, "test_pytree": 1.0080000000000002, "test_quantization": 6256.594999999999, "test_reductions": 94.93099999999588, "test_scatter_gather_ops": 10.530999999999999, "test_schema_check": 399.708999999994, "test_segment_reductions": 1.9499999999999986, "test_serialization": 22.632999999999996, "test_set_default_mobile_cpu_allocator": 0.731, "test_shape_ops": 18.247000000000007, "test_show_pickle": 0.732, "test_sort_and_select": 4.097999999999998, "test_sparse": 385.61299999999704, "test_sparse_csr": 506.4209999999956, "test_sparse_semi_structured": 0.009000000000000001, "test_spectral_ops": 155.49800000000005, "test_stateless": 4.955, "test_subclass": 0.8540000000000001, "test_sympy_utils": 12.202999999999996, "test_tensor_creation_ops": 78.42000000000043, "test_tensorboard": 139.017, "test_tensorexpr": 59.338, "test_tensorexpr_pybind": 0.9850000000000001, "test_testing": 26.56599999999993, "test_torch": 172.49800000000045, "test_transformers": 241.2760000000151, "test_type_hints": 0.556, "test_type_info": 0.741, "test_type_promotion": 11.616000000000025, "test_typing": 46.357999999999976, "test_unary_ufuncs": 366.34124999987336, "test_utils": 37.70200000000047, "test_view_ops": 14.396999999999991, "test_vulkan": 0.001, "test_weak": 3.7679999999999993, "test_xnnpack_integration": 31.452999999999996, "torch_np/numpy_tests/core/test_dlpack": 0.001, "torch_np/numpy_tests/core/test_dtype": 0.47600000000000003, "torch_np/numpy_tests/core/test_einsum": 11.126000000000001, "torch_np/numpy_tests/core/test_getlimits": 0.884, "torch_np/numpy_tests/core/test_indexing": 0.8260000000000001, "torch_np/numpy_tests/core/test_multiarray": 22.205000000000013, "torch_np/numpy_tests/core/test_numeric": 3.6889999999999996, "torch_np/numpy_tests/core/test_numerictypes": 0.811, "torch_np/numpy_tests/core/test_scalar_ctors": 0.8500000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.731, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 16.509999999999998, "torch_np/numpy_tests/core/test_shape_base": 1.036, "torch_np/numpy_tests/fft/test_helper": 4.5969999999999995, "torch_np/numpy_tests/fft/test_pocketfft": 54.839999999999996, "torch_np/numpy_tests/lib/test_arraypad": 0.8140000000000001, "torch_np/numpy_tests/lib/test_arraysetops": 0.47200000000000003, "torch_np/numpy_tests/lib/test_function_base": 2.234, "torch_np/numpy_tests/lib/test_histograms": 4.446999999999999, "torch_np/numpy_tests/lib/test_index_tricks": 0.8630000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 1.133, "torch_np/numpy_tests/lib/test_twodim_base": 1.4680000000000002, "torch_np/numpy_tests/lib/test_type_check": 0.8630000000000001, "torch_np/numpy_tests/linalg/test_linalg": 4.656000000000001, "torch_np/test_basic": 4.026, "torch_np/test_binary_ufuncs": 0.912, "torch_np/test_dtype": 0.865, "torch_np/test_function_base": 0.792, "torch_np/test_ndarray_methods": 1.8510000000000002, "torch_np/test_nep50_examples": 0.014000000000000002, "torch_np/test_random": 0.29900000000000004, "torch_np/test_reductions": 2.416999999999983, "torch_np/test_scalars_0D_arrays": 0.405, "torch_np/test_ufuncs_basic": 1.3640000000000003, "torch_np/test_unary_ufuncs": 0.8940000000000001}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": 33.28, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 12.342, "distributed/_composable/fsdp/test_fully_shard_comm": 116.267, "distributed/_composable/fsdp/test_fully_shard_compile": 9.016, "distributed/_composable/fsdp/test_fully_shard_extensions": 19.352, "distributed/_composable/fsdp/test_fully_shard_frozen": 35.79, "distributed/_composable/fsdp/test_fully_shard_init": 5.164, "distributed/_composable/fsdp/test_fully_shard_memory": 8.595, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 42.364000000000004, "distributed/_composable/fsdp/test_fully_shard_overlap": 0.277, "distributed/_composable/fsdp/test_fully_shard_state": 0.273, "distributed/_composable/fsdp/test_fully_shard_state_dict": 11.835999999999999, "distributed/_composable/fsdp/test_fully_shard_training": 249.65699999999995, "distributed/_composable/fully_shard/test_fully_shard_compile": 50.7, "distributed/_composable/fully_shard/test_fully_shard_init": 25.141999999999996, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 6.405, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 16.773, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 13.322, "distributed/_composable/fully_shard/test_fully_shard_runtime": 16.353, "distributed/_composable/fully_shard/test_fully_shard_util": 3.708, "distributed/_composable/test_checkpoint": 4.0760000000000005, "distributed/_composable/test_compose": 57.265, "distributed/_composable/test_contract": 0.202, "distributed/_composable/test_replicate": 35.523, "distributed/_composable/test_replicate_with_compiler": 108.181, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 14.347999999999999, "distributed/_shard/sharded_tensor/test_logger": 0.992, "distributed/_shard/sharding_spec/test_sharding_spec": 14.825, "distributed/_shard/test_sharder": 9.978, "distributed/_tensor/debug/test_comm_mode": 3.0999999999999996, "distributed/_tensor/debug/test_op_coverage": 0.385, "distributed/_tensor/experimental/test_tp_transform": 13.353, "distributed/_tensor/test_api": 23.092000000000002, "distributed/_tensor/test_attention": 4.654000000000001, "distributed/_tensor/test_common_rules": 29.073000000000004, "distributed/_tensor/test_convolution_ops": 37.093, "distributed/_tensor/test_dtensor": 97.562, "distributed/_tensor/test_dtensor_compile": 21.941, "distributed/_tensor/test_embedding_ops": 17.479, "distributed/_tensor/test_experimental_ops": 16.677, "distributed/_tensor/test_init": 20.848, "distributed/_tensor/test_math_ops": 32.797000000000004, "distributed/_tensor/test_matrix_ops": 57.787000000000006, "distributed/_tensor/test_op_strategy": 0.376, "distributed/_tensor/test_optimizers": 74.455, "distributed/_tensor/test_pointwise_ops": 0.5840000000000001, "distributed/_tensor/test_random_ops": 36.397, "distributed/_tensor/test_redistribute": 28.887, "distributed/_tensor/test_tensor_ops": 217.74800000000008, "distributed/_tensor/test_utils": 11.889999999999999, "distributed/_tensor/test_view_ops": 8.928, "distributed/_tensor/test_xla_integration": 1.2510000000000001, "distributed/_tools/test_memory_tracker": 6.868, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 35.549, "distributed/algorithms/quantization/test_quantization": 38.698, "distributed/algorithms/test_join": 32.087, "distributed/checkpoint/e2e/test_e2e_save_and_load": 32.039, "distributed/checkpoint/e2e/test_fine_tuning": 4.612, "distributed/checkpoint/e2e/test_fsdp_ep": 2.903, "distributed/checkpoint/e2e/test_pipeline": 5.591, "distributed/checkpoint/fsdp/test_fsdp_dsd": 13.739999999999998, "distributed/checkpoint/test_checkpoint": 38.815999999999995, "distributed/checkpoint/test_compatibility": 0.39, "distributed/checkpoint/test_dedup_tensors": 0.184, "distributed/checkpoint/test_dtensor_checkpoint": 5.995, "distributed/checkpoint/test_dtensor_resharding": 23.615000000000002, "distributed/checkpoint/test_file_system_checkpoint": 31.644000000000005, "distributed/checkpoint/test_file_system_checkpoint_cpu": 30.128, "distributed/checkpoint/test_format_utils": 15.555, "distributed/checkpoint/test_fsdp_model_state": 9.638, "distributed/checkpoint/test_fsdp_optim_state": 14.256, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 7.503, "distributed/checkpoint/test_fsspec": 7.897, "distributed/checkpoint/test_hsdp_checkpoint": 11.475, "distributed/checkpoint/test_nested_dict": 0.19, "distributed/checkpoint/test_planner": 0.20700000000000002, "distributed/checkpoint/test_save_load_api": 4.593, "distributed/checkpoint/test_state_dict": 89.94399999999999, "distributed/checkpoint/test_state_dict_utils": 24.016000000000002, "distributed/checkpoint/test_tp_checkpoint": 11.248000000000001, "distributed/checkpoint/test_traverse": 0.2, "distributed/checkpoint/test_utils": 0.197, "distributed/elastic/events/lib_test": 1.001, "distributed/elastic/metrics/api_test": 0.999, "distributed/elastic/multiprocessing/api_test": 34.38, "distributed/elastic/timer/local_timer_example": 8.648, "distributed/elastic/timer/local_timer_test": 5.7010000000000005, "distributed/elastic/utils/distributed_test": 3.4729999999999994, "distributed/elastic/utils/logging_test": 0.945, "distributed/elastic/utils/util_test": 0.996, "distributed/fsdp/test_checkpoint_wrapper": 1.2789999999999997, "distributed/fsdp/test_distributed_checkpoint": 0.188, "distributed/fsdp/test_fsdp_apply": 11.754999999999999, "distributed/fsdp/test_fsdp_backward_prefetch": 7.315, "distributed/fsdp/test_fsdp_checkpoint": 118.54, "distributed/fsdp/test_fsdp_clip_grad_norm": 43.638999999999996, "distributed/fsdp/test_fsdp_comm": 53.517, "distributed/fsdp/test_fsdp_comm_hooks": 172.42700000000002, "distributed/fsdp/test_fsdp_core": 1498.0039999999997, "distributed/fsdp/test_fsdp_dtensor_state_dict": 95.901, "distributed/fsdp/test_fsdp_exec_order": 52.629000000000005, "distributed/fsdp/test_fsdp_fine_tune": 42.527, "distributed/fsdp/test_fsdp_flatten_params": 61.705000000000005, "distributed/fsdp/test_fsdp_freezing_weights": 222.56499999999997, "distributed/fsdp/test_fsdp_fx": 0.29, "distributed/fsdp/test_fsdp_grad_acc": 42.254000000000005, "distributed/fsdp/test_fsdp_hybrid_shard": 42.872, "distributed/fsdp/test_fsdp_ignored_modules": 86.29899999999999, "distributed/fsdp/test_fsdp_input": 12.93, "distributed/fsdp/test_fsdp_memory": 18.725, "distributed/fsdp/test_fsdp_meta": 47.01699999999999, "distributed/fsdp/test_fsdp_misc": 89.46199999999999, "distributed/fsdp/test_fsdp_mixed_precision": 426.39200000000005, "distributed/fsdp/test_fsdp_multiple_forward": 6.894, "distributed/fsdp/test_fsdp_multiple_wrapping": 6.614, "distributed/fsdp/test_fsdp_optim_state": 440.874, "distributed/fsdp/test_fsdp_overlap": 50.888000000000005, "distributed/fsdp/test_fsdp_pure_fp16": 13.249, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 137.397, "distributed/fsdp/test_fsdp_state_dict": 986.3249999999997, "distributed/fsdp/test_fsdp_tp_integration": 10.856, "distributed/fsdp/test_fsdp_traversal": 5.687, "distributed/fsdp/test_fsdp_uneven": 6.717, "distributed/fsdp/test_fsdp_unshard_params": 89.031, "distributed/fsdp/test_fsdp_use_orig_params": 174.812, "distributed/fsdp/test_hsdp_dtensor_state_dict": 35.937, "distributed/fsdp/test_shard_utils": 7.537, "distributed/fsdp/test_utils": 1.2009999999999998, "distributed/fsdp/test_wrap": 150.65, "distributed/nn/jit/test_instantiator": 1.3989999999999998, "distributed/optim/test_zero_redundancy_optimizer": 216.73499999999996, "distributed/pipeline/sync/skip/test_api": 0.006, "distributed/pipeline/sync/skip/test_gpipe": 4.49, "distributed/pipeline/sync/skip/test_inspect_skip_layout": 0.007, "distributed/pipeline/sync/skip/test_leak": 0.31700000000000006, "distributed/pipeline/sync/skip/test_portal": 0.297, "distributed/pipeline/sync/skip/test_stash_pop": 0.009000000000000001, "distributed/pipeline/sync/skip/test_tracker": 0.36, "distributed/pipeline/sync/skip/test_verify_skippables": 0.011000000000000003, "distributed/pipeline/sync/test_balance": 7.9159999999999995, "distributed/pipeline/sync/test_bugs": 2.13, "distributed/pipeline/sync/test_checkpoint": 0.568, "distributed/pipeline/sync/test_copy": 1.011, "distributed/pipeline/sync/test_deferred_batch_norm": 1.9380000000000002, "distributed/pipeline/sync/test_dependency": 0.31, "distributed/pipeline/sync/test_inplace": 0.133, "distributed/pipeline/sync/test_microbatch": 0.011000000000000003, "distributed/pipeline/sync/test_phony": 0.007, "distributed/pipeline/sync/test_pipe": 3.925999999999999, "distributed/pipeline/sync/test_pipeline": 0.002, "distributed/pipeline/sync/test_stream": 1.2810000000000001, "distributed/pipeline/sync/test_transparency": 0.241, "distributed/pipeline/sync/test_worker": 0.032, "distributed/tensor/parallel/test_ddp_2d_parallel": 4.586, "distributed/tensor/parallel/test_fsdp_2d_parallel": 33.262, "distributed/tensor/parallel/test_parallelize_api": 28.336999999999996, "distributed/tensor/parallel/test_tp_examples": 44.484, "distributed/tensor/parallel/test_tp_random_state": 2.91, "distributed/tensor/parallel/test_tp_style": 47.033, "distributed/test_c10d_common": 95.62600000000002, "distributed/test_c10d_functional_native": 217.128, "distributed/test_c10d_gloo": 555.422, "distributed/test_c10d_logger": 15.069, "distributed/test_c10d_nccl": 985.1119999999999, "distributed/test_c10d_object_collectives": 45.999, "distributed/test_c10d_pypg": 231.687, "distributed/test_c10d_spawn_gloo": 67.321, "distributed/test_c10d_spawn_nccl": 51.881, "distributed/test_c10d_spawn_ucc": 0.009000000000000001, "distributed/test_compute_comm_reordering": 2.9079999999999995, "distributed/test_data_parallel": 9.367000000000003, "distributed/test_device_mesh": 77.36699999999999, "distributed/test_distributed_spawn": 3786.2259999999987, "distributed/test_dynamo_distributed": 114.695, "distributed/test_fake_pg": 3.3599999999999994, "distributed/test_functional_api": 49.400000000000006, "distributed/test_inductor_collectives": 137.05, "distributed/test_launcher": 2.028, "distributed/test_multi_threaded_pg": 1.0610000000000002, "distributed/test_nccl": 1.1939999999999995, "distributed/test_pg_wrapper": 96.696, "distributed/test_store": 63.11599999999999}, "slow": {"backends/xeon/test_launch": 2.2840000000000003, "benchmark_utils/test_benchmark_utils": 305.3249999999999, "distributions/test_constraints": 3.2700000000000005, "distributions/test_distributions": 0.6760000000000002, "dynamo/test_activation_checkpointing": 0.17400000000000002, "dynamo/test_after_aot": 0.197, "dynamo/test_aot_autograd": 0.23200000000000004, "dynamo/test_autograd_function": 0.17800000000000002, "dynamo/test_backends": 0.161, "dynamo/test_backward_higher_order_ops": 0.227, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_hook": 0.189, "dynamo/test_compile": 0.2, "dynamo/test_comptime": 0.199, "dynamo/test_config": 0.217, "dynamo/test_cpp_guard_manager": 1.1210000000000009, "dynamo/test_ctx_manager": 0.04900000000000003, "dynamo/test_cudagraphs": 0.219, "dynamo/test_debug_utils": 0.155, "dynamo/test_decorators": 0.23500000000000001, "dynamo/test_deviceguard": 0.011, "dynamo/test_dynamic_shapes": 42.03699999999996, "dynamo/test_exc": 0.01, "dynamo/test_export": 0.18600000000000014, "dynamo/test_export_mutations": 0.203, "dynamo/test_frame_init": 0.208, "dynamo/test_functions": 0.42500000000000027, "dynamo/test_fx_passes_pre_grad": 0.188, "dynamo/test_global": 0.201, "dynamo/test_guard_manager": 0.234, "dynamo/test_higher_order_ops": 0.34400000000000014, "dynamo/test_hooks": 0.22400000000000003, "dynamo/test_input_attr_tracking": 0.202, "dynamo/test_interop": 0.199, "dynamo/test_logging": 0.17900000000000005, "dynamo/test_minifier": 0.227, "dynamo/test_misc": 0.5640000000000004, "dynamo/test_model_output": 0.001, "dynamo/test_modules": 0.2250000000000001, "dynamo/test_nops": 0.198, "dynamo/test_optimizers": 0.197, "dynamo/test_pre_dispatch": 0.193, "dynamo/test_profiler": 0.223, "dynamo/test_python_autograd": 0.198, "dynamo/test_recompile_ux": 0.203, "dynamo/test_recompiles": 0.201, "dynamo/test_reorder_logs": 0.22, "dynamo/test_replay_record": 0.20099999999999998, "dynamo/test_repros": 0.22100000000000017, "dynamo/test_sdpa": 0.197, "dynamo/test_skip_non_tensor": 0.202, "dynamo/test_sources": 0.195, "dynamo/test_structured_trace": 0.137, "dynamo/test_subclasses": 0.21000000000000005, "dynamo/test_subgraphs": 0.23400000000000004, "dynamo/test_trace_rules": 0.2, "dynamo/test_triton_kernels": 0.8360000000000003, "dynamo/test_unspec": 0.23400000000000004, "dynamo/test_verify_correctness": 0.195, "export/test_db": 0.22500000000000003, "export/test_experimental": 0.194, "export/test_export": 0.2560000000000001, "export/test_export_nonstrict": 0.1340000000000001, "export/test_export_predispatch": 0.1330000000000001, "export/test_functionalized_assertions": 0.642, "export/test_hop": 0.015000000000000006, "export/test_lift_unlift": 0.079, "export/test_pass_infra": 0.199, "export/test_passes": 0.232, "export/test_retraceability": 0.1340000000000001, "export/test_safeguard": 0.214, "export/test_schema": 0.219, "export/test_serdes": 0.2620000000000002, "export/test_serialize": 9.623, "export/test_torchbind": 1.1330000000000002, "export/test_tree_utils": 0.192, "export/test_unflatten": 0.20900000000000002, "export/test_upgrade": 0.233, "export/test_verifier": 0.2, "functorch/test_aotdispatch": 0.1650000000000001, "functorch/test_control_flow": 0.42200000000000015, "functorch/test_dims": 0.28, "functorch/test_eager_transforms": 0.35400000000000026, "functorch/test_logging": 0.191, "functorch/test_memory_efficient_fusion": 0.20700000000000002, "functorch/test_minifier": 0.199, "functorch/test_ops": 132.4200000000122, "functorch/test_parsing": 0.727, "functorch/test_rearrange": 0.655, "functorch/test_vmap": 7.966000000000383, "functorch/test_vmap_registrations": 2.430999999999854, "higher_order_ops/test_with_effects": 4.3629999999999995, "inductor/test_aot_inductor": 0.6060000000000004, "inductor/test_benchmark_fusion": 0.017, "inductor/test_binary_folding": 0.004, "inductor/test_codecache": 6.415, "inductor/test_codegen_triton": 0.144, "inductor/test_compiled_autograd": 0.4220000000000003, "inductor/test_compiled_optimizers": 0.2430000000000002, "inductor/test_config": 0.16, "inductor/test_control_flow": 0.19400000000000003, "inductor/test_coordinate_descent_tuner": 0.151, "inductor/test_cpu_repro": 711.4809999999974, "inductor/test_cuda_cpp_wrapper": 0.054000000000000034, "inductor/test_cuda_repro": 0.046000000000000034, "inductor/test_cudagraph_trees": 0.07700000000000005, "inductor/test_custom_lowering": 0.146, "inductor/test_custom_post_grad_passes": 0.155, "inductor/test_debug_trace": 0.001, "inductor/test_decompose_mem_bound_mm": 0.14900000000000002, "inductor/test_dependencies": 0.143, "inductor/test_distributed_patterns": 0.161, "inductor/test_efficient_conv_bn_eval": 0.002, "inductor/test_extension_backend": 21.97, "inductor/test_foreach": 0.20100000000000015, "inductor/test_fp8": 0.002, "inductor/test_fused_attention": 0.19900000000000004, "inductor/test_fx_fusion": 0.126, "inductor/test_group_batch_fusion": 0.151, "inductor/test_indexing": 0.254, "inductor/test_inductor_freezing": 0.04200000000000002, "inductor/test_inplacing_pass": 0.13, "inductor/test_kernel_benchmark": 0.166, "inductor/test_layout_optim": 0.02500000000000001, "inductor/test_max_autotune": 0.17200000000000001, "inductor/test_memory_planning": 0.003, "inductor/test_metrics": 0.006, "inductor/test_minifier": 0.155, "inductor/test_minifier_isolate": 0.133, "inductor/test_mkldnn_pattern_matcher": 0.3400000000000001, "inductor/test_mmdecomp": 0.02000000000000001, "inductor/test_move_constructors_to_cuda": 0.015000000000000003, "inductor/test_multi_kernel": 0.162, "inductor/test_pad_mm": 0.135, "inductor/test_padding": 0.157, "inductor/test_pattern_matcher": 0.04000000000000002, "inductor/test_perf": 0.20300000000000004, "inductor/test_profiler": 0.151, "inductor/test_select_algorithm": 0.14800000000000002, "inductor/test_smoke": 0.134, "inductor/test_snode_runtime": 0.14900000000000002, "inductor/test_split_cat_fx_passes": 0.136, "inductor/test_standalone_compile": 0.161, "inductor/test_templated_attention": 0.002, "inductor/test_torchinductor": 0.6650000000000005, "inductor/test_torchinductor_codegen_dynamic_shapes": 1.6090000000000009, "inductor/test_torchinductor_dynamic_shapes": 34.00099999999894, "inductor/test_torchinductor_opinfo": 11.069999999998863, "inductor/test_triton_extension_backend": 0.001, "inductor/test_triton_heuristics": 0.147, "inductor/test_triton_kernels": 0.29900000000000015, "inductor/test_triton_wrapper": 0.146, "inductor/test_unbacked_symints": 0.009000000000000001, "inductor/test_utils": 0.207, "lazy/test_debug_util": 0.632, "lazy/test_functionalization": 0.651, "lazy/test_generator": 0.641, "lazy/test_reuse_ir": 0.635, "lazy/test_step_closures": 0.651, "lazy/test_ts_opinfo": 0.479, "nn/test_convolution": 1.1250000000000004, "nn/test_dropout": 0.523, "nn/test_embedding": 0.7000000000000002, "nn/test_init": 0.8170000000000001, "nn/test_lazy_modules": 0.621, "nn/test_load_state_dict": 0.562, "nn/test_module_hooks": 0.554, "nn/test_multihead_attention": 0.529, "nn/test_packed_sequence": 0.646, "nn/test_parametrization": 0.5680000000000001, "nn/test_pooling": 4.452999999999993, "nn/test_pruning": 0.553, "profiler/test_execution_trace": 0.015000000000000003, "profiler/test_memory_profiler": 0.655, "profiler/test_profiler": 0.9480000000000001, "profiler/test_profiler_tree": 0.642, "profiler/test_record_function": 0.65, "profiler/test_torch_tidy": 0.641, "test_ao_sparsity": 0.29600000000000004, "test_autocast": 0.636, "test_autograd": 8.17000000000009, "test_autograd_fallback": 0.6880000000000001, "test_binary_ufuncs": 18.32199999999813, "test_bundled_inputs": 0.663, "test_comparison_utils": 0.636, "test_compile_benchmark_util": 0.0, "test_complex": 0.524, "test_content_store": 0.004, "test_cpp_api_parity": 0.9640000000000004, "test_cpp_extensions_aot_ninja": 0.387, "test_cpp_extensions_aot_no_ninja": 0.387, "test_cpp_extensions_jit": 0.393, "test_cpp_extensions_mtia_backend": 0.435, "test_cpp_extensions_open_device_registration": 25.055, "test_cpp_extensions_stream_and_event": 0.436, "test_cuda": 3.3629999999999884, "test_cuda_expandable_segments": 3.3839999999999995, "test_cuda_multigpu": 0.529, "test_cuda_primary_ctx": 1.9729999999999999, "test_cuda_sanitizer": 0.65, "test_cuda_trace": 6.8549999999999995, "test_custom_ops": 0.23200000000000015, "test_dataloader": 0.6710000000000002, "test_datapipe": 0.7490000000000001, "test_decomp": 96.99200000002814, "test_deploy": 0.616, "test_dispatch": 0.5850000000000001, "test_dlpack": 0.6250000000000001, "test_dynamic_shapes": 0.6880000000000002, "test_expanded_weights": 0.7180000000000002, "test_fake_tensor": 0.12200000000000008, "test_flop_counter": 0.02300000000000001, "test_foreach": 2.676999999999818, "test_function_schema": 0.656, "test_functional_autograd_benchmark": 54.105000000000004, "test_functional_optim": 0.202, "test_functionalization": 0.7410000000000001, "test_functionalization_of_rng_ops": 0.014000000000000005, "test_futures": 0.645, "test_fx": 176.47899999999993, "test_fx_experimental": 0.7090000000000005, "test_fx_passes": 0.682, "test_fx_reinplace_pass": 0.644, "test_import_stats": 0.626, "test_indexing": 1.0859999999999927, "test_itt": 0.633, "test_jit": 94.32500000000003, "test_jit_autocast": 0.051000000000000024, "test_jit_disabled": 0.613, "test_jit_fuser_te": 12.216000000000015, "test_jit_llga_fuser": 0.006, "test_jiterator": 0.8030000000000003, "test_legacy_vmap": 0.6300000000000001, "test_license": 0.634, "test_linalg": 27.734000000000613, "test_logging": 0.634, "test_masked": 0.6010000000000001, "test_maskedtensor": 1.5480000000000007, "test_matmul_cuda": 0.528, "test_meta": 49.634999999977396, "test_mkl_verbose": 0.636, "test_mkldnn_fusion": 0.651, "test_mkldnn_verbose": 0.634, "test_mobile_optimizer": 0.198, "test_model_dump": 0.663, "test_model_exports_to_core_aten": 0.216, "test_modules": 4.550999999999843, "test_monitor": 0.704, "test_multiprocessing": 0.531, "test_multiprocessing_spawn": 0.645, "test_namedtensor": 0.5870000000000001, "test_namedtuple_return_api": 0.623, "test_native_functions": 0.652, "test_native_mha": 0.552, "test_nestedtensor": 0.4670000000000003, "test_nn": 2.772999999999918, "test_numba_integration": 0.507, "test_numpy_interop": 0.5730000000000001, "test_openmp": 0.626, "test_ops": 1084.6570000001082, "test_ops_fwd_gradients": 15.083999999999454, "test_ops_gradients": 14.258999999998009, "test_ops_jit": 1.7519999999999423, "test_optim": 1.1600000000000006, "test_out_dtype_op": 0.020000000000000007, "test_overrides": 2.114999999999891, "test_package": 0.3720000000000001, "test_per_overload_api": 0.67, "test_prims": 0.49, "test_proxy_tensor": 0.27100000000000013, "test_pruning_op": 0.687, "test_public_bindings": 0.672, "test_python_dispatch": 0.11000000000000007, "test_pytree": 0.772, "test_quantization": 975.0629999999998, "test_reductions": 5.241000000000008, "test_scatter_gather_ops": 0.5910000000000001, "test_schema_check": 10.937999999998729, "test_segment_reductions": 0.5830000000000001, "test_serialization": 1.1520000000000001, "test_set_default_mobile_cpu_allocator": 0.633, "test_shape_ops": 0.5850000000000001, "test_show_pickle": 0.622, "test_sort_and_select": 0.797, "test_sparse": 3.659999999999913, "test_sparse_csr": 5.1529999999996665, "test_sparse_semi_structured": 0.011000000000000003, "test_spectral_ops": 0.7290000000000003, "test_stateless": 0.56, "test_subclass": 0.7520000000000001, "test_sympy_utils": 0.47700000000000015, "test_tensor_creation_ops": 1.1510000000000005, "test_tensorboard": 0.17400000000000004, "test_tensorexpr": 0.7200000000000001, "test_tensorexpr_pybind": 0.64, "test_testing": 2.6509999999999745, "test_torch": 22.917000000000854, "test_transformers": 46.719999999998315, "test_type_hints": 0.642, "test_type_info": 0.638, "test_type_promotion": 0.8780000000000003, "test_typing": 49.16399999999997, "test_unary_ufuncs": 25.83500000000863, "test_utils": 6.590000000000384, "test_view_ops": 0.7810000000000002, "test_vulkan": 0.0, "test_weak": 0.669, "test_xnnpack_integration": 752.505, "torch_np/numpy_tests/core/test_dlpack": 0.001, "torch_np/numpy_tests/core/test_dtype": 0.24200000000000002, "torch_np/numpy_tests/core/test_einsum": 0.23700000000000004, "torch_np/numpy_tests/core/test_getlimits": 0.726, "torch_np/numpy_tests/core/test_indexing": 0.25100000000000006, "torch_np/numpy_tests/core/test_multiarray": 507.2549999999998, "torch_np/numpy_tests/core/test_numeric": 0.4600000000000002, "torch_np/numpy_tests/core/test_numerictypes": 0.678, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6880000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.628, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 38.657999999999994, "torch_np/numpy_tests/core/test_shape_base": 0.7370000000000001, "torch_np/numpy_tests/fft/test_helper": 0.643, "torch_np/numpy_tests/fft/test_pocketfft": 0.7010000000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.64, "torch_np/numpy_tests/lib/test_arraysetops": 0.24500000000000002, "torch_np/numpy_tests/lib/test_function_base": 0.5440000000000003, "torch_np/numpy_tests/lib/test_histograms": 0.945, "torch_np/numpy_tests/lib/test_index_tricks": 0.669, "torch_np/numpy_tests/lib/test_shape_base_": 0.6890000000000001, "torch_np/numpy_tests/lib/test_twodim_base": 0.662, "torch_np/numpy_tests/lib/test_type_check": 0.674, "torch_np/numpy_tests/linalg/test_linalg": 1.5700000000000003, "torch_np/test_basic": 0.9110000000000003, "torch_np/test_binary_ufuncs": 0.68, "torch_np/test_dtype": 0.6930000000000001, "torch_np/test_function_base": 0.631, "torch_np/test_ndarray_methods": 0.40200000000000014, "torch_np/test_nep50_examples": 0.011, "torch_np/test_random": 0.273, "torch_np/test_reductions": 1.5990000000000006, "torch_np/test_scalars_0D_arrays": 0.22400000000000003, "torch_np/test_ufuncs_basic": 1.0020000000000002, "torch_np/test_unary_ufuncs": 0.77}}, "linux-focal-rocm6.1-py3.8": {"default": {"backends/xeon/test_launch": 2.11, "benchmark_utils/test_benchmark_utils": 3.8256666666666668, "distributions/test_constraints": 1.2309999999999977, "distributions/test_distributions": 48.6185, "dynamo/test_activation_checkpointing": 34.446666666666665, "dynamo/test_after_aot": 5.724333333333334, "dynamo/test_aot_autograd": 21.522666666666666, "dynamo/test_aot_autograd_cache": 10.349000000000002, "dynamo/test_autograd_function": 4.9319999999999995, "dynamo/test_backends": 11.466, "dynamo/test_backward_higher_order_ops": 11.342333333333334, "dynamo/test_base_output": 0.001, "dynamo/test_bytecode_hook": 4.364333333333334, "dynamo/test_bytecode_utils": 5.4576666666666656, "dynamo/test_compile": 5.424666666666666, "dynamo/test_comptime": 0.5026666666666667, "dynamo/test_config": 0.48633333333333334, "dynamo/test_cpp_guard_manager": 130.96350000000012, "dynamo/test_ctx_manager": 15.921666666666667, "dynamo/test_cudagraphs": 3.946666666666667, "dynamo/test_debug_utils": 15.573999999999998, "dynamo/test_decorators": 5.036666666666668, "dynamo/test_deviceguard": 0.016333333333333335, "dynamo/test_dynamic_shapes": 502.93166666666684, "dynamo/test_exc": 1.6289999999999998, "dynamo/test_exceptions": 0.4353333333333334, "dynamo/test_export": 27.536666666666672, "dynamo/test_export_mutations": 0.48033333333333333, "dynamo/test_frame_init": 0.26166666666666666, "dynamo/test_functions": 22.677333333333355, "dynamo/test_fx_passes_pre_grad": 1.0963333333333334, "dynamo/test_global": 0.462, "dynamo/test_guard_manager": 0.379, "dynamo/test_higher_order_ops": 34.644, "dynamo/test_hooks": 24.23166666666667, "dynamo/test_inline_inbuilt_nn_modules": 145.9420000000002, "dynamo/test_input_attr_tracking": 6.885333333333334, "dynamo/test_interop": 0.5473333333333333, "dynamo/test_logging": 39.681000000000004, "dynamo/test_minifier": 16.129333333333335, "dynamo/test_misc": 89.2380000000001, "dynamo/test_model_output": 0.0030000000000000005, "dynamo/test_modules": 47.79966666666666, "dynamo/test_nops": 0.3193333333333333, "dynamo/test_optimizers": 0.6123333333333334, "dynamo/test_pre_dispatch": 0.47266666666666673, "dynamo/test_profiler": 1.2943333333333333, "dynamo/test_python_autograd": 0.5553333333333333, "dynamo/test_recompile_ux": 1.0176666666666667, "dynamo/test_recompiles": 0.715, "dynamo/test_reorder_logs": 0.43900000000000006, "dynamo/test_repros": 50.712666666666685, "dynamo/test_resume": 0.40199999999999997, "dynamo/test_sdpa": 0.42533333333333334, "dynamo/test_skip_non_tensor": 0.42100000000000004, "dynamo/test_sources": 0.42333333333333334, "dynamo/test_structured_trace": 29.234666666666666, "dynamo/test_subclasses": 15.541333333333332, "dynamo/test_subgraphs": 1.7693333333333328, "dynamo/test_trace_rules": 1.0673333333333332, "dynamo/test_unspec": 10.766333333333334, "dynamo/test_verify_correctness": 0.6196666666666667, "dynamo/test_view": 0.5156666666666667, "export/test_converter": 5.875, "export/test_db": 2.3293333333333326, "export/test_experimental": 0.8293333333333334, "export/test_export": 44.31599999999999, "export/test_export_nonstrict": 21.52733333333333, "export/test_export_predispatch": 30.53266666666667, "export/test_functionalized_assertions": 0.3415, "export/test_hop": 2.080666666666666, "export/test_lift_unlift": 0.278, "export/test_pass_infra": 0.6690000000000002, "export/test_passes": 10.579333333333333, "export/test_retraceability": 34.59466666666666, "export/test_safeguard": 0.8213333333333335, "export/test_schema": 0.25766666666666665, "export/test_serdes": 34.90800000000001, "export/test_serialize": 8.111666666666666, "export/test_sparse": 127.67400000000023, "export/test_tools": 0.5183333333333334, "export/test_torchbind": 3.308666666666666, "export/test_tree_utils": 0.258, "export/test_unflatten": 2.472, "export/test_upgrade": 0.3583333333333334, "export/test_verifier": 0.7469999999999999, "functorch/test_ac": 3.1565000000000003, "functorch/test_aotdispatch": 60.86633333333333, "functorch/test_control_flow": 78.56433333333338, "functorch/test_dims": 43.90366666666667, "functorch/test_eager_transforms": 28.00400000000001, "functorch/test_logging": 0.2806666666666667, "functorch/test_memory_efficient_fusion": 10.159, "functorch/test_minifier": 0.38833333333333336, "functorch/test_ops": 3997.70766666664, "functorch/test_parsing": 0.2515, "functorch/test_rearrange": 0.25300000000000006, "functorch/test_vmap": 330.7239999999987, "functorch/test_vmap_registrations": 2.0583333333332283, "higher_order_ops/test_with_effects": 7.502333333333333, "inductor/test_aot_inductor": 6537.581999999999, "inductor/test_benchmark_fusion": 153.1495, "inductor/test_binary_folding": 34.0095, "inductor/test_codecache": 133.853, "inductor/test_codegen_triton": 0.22949999999999998, "inductor/test_compile_worker": 11.719666666666667, "inductor/test_compiled_autograd": 368.043666666667, "inductor/test_compiled_optimizers": 3151.012666666667, "inductor/test_config": 4.434666666666666, "inductor/test_control_flow": 154.87800000000001, "inductor/test_coordinate_descent_tuner": 3.999333333333334, "inductor/test_cpu_repro": 806.4836666666666, "inductor/test_cuda_cpp_wrapper": 1623.04, "inductor/test_cuda_repro": 234.89300000000003, "inductor/test_cudagraph_trees": 102.49550000000002, "inductor/test_custom_lowering": 3.8914999999999997, "inductor/test_custom_post_grad_passes": 9.970333333333334, "inductor/test_debug_trace": 33.35633333333333, "inductor/test_decompose_mem_bound_mm": 71.14999999999999, "inductor/test_dependencies": 0.20650000000000002, "inductor/test_distributed_patterns": 30.933000000000003, "inductor/test_efficient_conv_bn_eval": 501.30466666666666, "inductor/test_extension_backend": 35.065, "inductor/test_flex_attention": 1001.5949999999997, "inductor/test_foreach": 443.8265, "inductor/test_fp8": 0.007000000000000001, "inductor/test_fused_attention": 149.0776666666667, "inductor/test_fx_fusion": 0.40466666666666673, "inductor/test_graph_transform_observer": 0.0115, "inductor/test_group_batch_fusion": 292.475, "inductor/test_indexing": 2.5395000000000003, "inductor/test_inductor_freezing": 83.4805, "inductor/test_inplacing_pass": 6.050000000000001, "inductor/test_kernel_benchmark": 281.725, "inductor/test_layout_optim": 25.566666666666666, "inductor/test_loop_ordering": 19.8715, "inductor/test_max_autotune": 295.18466666666666, "inductor/test_memory_planning": 34.159, "inductor/test_metrics": 4.662999999999999, "inductor/test_minifier": 27.132666666666665, "inductor/test_minifier_isolate": 55.196333333333335, "inductor/test_mkldnn_pattern_matcher": 293.666, "inductor/test_mmdecomp": 20.14066666666667, "inductor/test_move_constructors_to_cuda": 13.219, "inductor/test_multi_kernel": 109.37933333333332, "inductor/test_pad_mm": 170.3113333333333, "inductor/test_padding": 42.223, "inductor/test_pattern_matcher": 127.036, "inductor/test_perf": 129.80700000000002, "inductor/test_profiler": 7.613999999999999, "inductor/test_select_algorithm": 137.25333333333333, "inductor/test_smoke": 18.448999999999998, "inductor/test_snode_runtime": 27.0, "inductor/test_split_cat_fx_passes": 108.67666666666666, "inductor/test_standalone_compile": 16.73633333333333, "inductor/test_torchbind": 6.553999999999999, "inductor/test_torchinductor": 3116.7915000000007, "inductor/test_torchinductor_codegen_dynamic_shapes": 3081.2926666666667, "inductor/test_torchinductor_dynamic_shapes": 3817.1429999999996, "inductor/test_torchinductor_opinfo": 20872.327333333338, "inductor/test_torchinductor_strided_blocks": 20.432000000000002, "inductor/test_triton_extension_backend": 1.0170000000000001, "inductor/test_triton_heuristics": 31.769999999999996, "inductor/test_triton_kernels": 163.34999999999997, "inductor/test_triton_wrapper": 10.865, "inductor/test_unbacked_symints": 36.317, "inductor/test_utils": 0.2545, "lazy/test_debug_util": 0.261, "lazy/test_functionalization": 0.27166666666666667, "lazy/test_generator": 0.26566666666666666, "lazy/test_reuse_ir": 2.1216666666666666, "lazy/test_step_closures": 2.219, "lazy/test_ts_opinfo": 0.21033333333333334, "nn/test_convolution": 233.4974999999995, "nn/test_dropout": 0.8216666666666668, "nn/test_embedding": 10.45233333333332, "nn/test_init": 3.664333333333333, "nn/test_lazy_modules": 6.782666666666664, "nn/test_load_state_dict": 1.291499999999999, "nn/test_module_hooks": 0.2685, "nn/test_multihead_attention": 398.83099999999996, "nn/test_packed_sequence": 2.4479999999999995, "nn/test_parametrization": 35.975, "nn/test_pooling": 13.8015, "nn/test_pruning": 0.06900000000000003, "profiler/test_execution_trace": 16.015, "profiler/test_memory_profiler": 3.4915000000000003, "profiler/test_profiler": 61.75233333333333, "profiler/test_profiler_tree": 0.395, "profiler/test_record_function": 0.35250000000000004, "profiler/test_torch_tidy": 3.0805, "test_ao_sparsity": 63.013000000000005, "test_autocast": 13.6135, "test_autograd": 75.7671666666666, "test_autograd_fallback": 0.36750000000000005, "test_binary_ufuncs": 178.7922000000025, "test_bundled_inputs": 3.0226666666666664, "test_comparison_utils": 0.329, "test_compile_benchmark_util": 0.0005, "test_complex": 0.09250000000000001, "test_content_store": 3.9414999999999996, "test_cpp_api_parity": 21.430500000000045, "test_cpp_extensions_aot_ninja": 0.367, "test_cpp_extensions_aot_no_ninja": 0.367, "test_cpp_extensions_jit": 293.71000000000004, "test_cpp_extensions_mtia_backend": 0.0005, "test_cpp_extensions_open_device_registration": 29.34050000000001, "test_cpp_extensions_stream_and_event": 0.0, "test_cuda": 87.12433333333335, "test_cuda_expandable_segments": 81.87733333333337, "test_cuda_multigpu": 0.45766666666666667, "test_cuda_primary_ctx": 0.003, "test_cuda_sanitizer": 0.541, "test_cuda_trace": 1.9849999999999999, "test_custom_ops": 28.493000000000013, "test_dataloader": 178.97400000000002, "test_datapipe": 9.674666666666665, "test_decomp": 9325.640999999989, "test_deploy": 0.22133333333333335, "test_dispatch": 41.49050000000001, "test_dlpack": 0.2330000000000001, "test_dynamic_shapes": 3.632499999999998, "test_expanded_weights": 72.045, "test_fake_tensor": 15.52066666666667, "test_flop_counter": 20.02733333333333, "test_foreach": 110.57350000000088, "test_function_schema": 0.5295000000000001, "test_functional_autograd_benchmark": 128.4403333333333, "test_functional_optim": 0.29200000000000004, "test_functionalization": 11.353999999999996, "test_functionalization_of_rng_ops": 1.8286666666666667, "test_futures": 0.9470000000000001, "test_fx": 187.95866666666666, "test_fx_experimental": 273.6183333333332, "test_fx_passes": 0.5295000000000001, "test_fx_reinplace_pass": 0.43900000000000006, "test_import_stats": 3.3994999999999997, "test_indexing": 1.71533333333333, "test_itt": 0.23666666666666666, "test_jit": 281.1019999999998, "test_jit_autocast": 28.496999999999996, "test_jit_disabled": 0.5355000000000001, "test_jit_fuser_te": 907.5449999999993, "test_jit_llga_fuser": 0.19599999999999998, "test_jiterator": 23.711000000000013, "test_legacy_vmap": 211.07500000000016, "test_license": 0.2365, "test_linalg": 997.5079999999911, "test_logging": 2.613, "test_masked": 24.140000000000015, "test_maskedtensor": 5.210999999999998, "test_matmul_cuda": 29.021000000000015, "test_meta": 1849.6606666665382, "test_mkl_verbose": 4.2915, "test_mkldnn_fusion": 209.79100000000003, "test_mkldnn_verbose": 3.892333333333333, "test_mobile_optimizer": 3.1935000000000002, "test_model_dump": 2.0736666666666665, "test_model_exports_to_core_aten": 0.15133333333333335, "test_module_tracker": 0.23966666666666667, "test_modules": 1608.8069999999773, "test_monitor": 0.3633333333333333, "test_multiprocessing": 53.056, "test_multiprocessing_spawn": 31.538000000000004, "test_namedtensor": 1.3676666666666646, "test_namedtuple_return_api": 1.5034999999999998, "test_native_functions": 0.4543333333333333, "test_native_mha": 12.554999999999989, "test_nestedtensor": 25.209666666666653, "test_nn": 417.79040000000424, "test_numba_integration": 0.274, "test_numpy_interop": 0.2240000000000001, "test_openmp": 3.9730000000000003, "test_ops": 4642.94999999995, "test_ops_fwd_gradients": 698.1089999999955, "test_ops_gradients": 1980.993333333261, "test_ops_jit": 921.1706666666663, "test_optim": 380.0404999999995, "test_out_dtype_op": 0.657, "test_overrides": 1.94249999999992, "test_package": 1.6049999999999998, "test_per_overload_api": 0.347, "test_prims": 0.4406666666666667, "test_proxy_tensor": 77.83000000000001, "test_pruning_op": 0.501, "test_public_bindings": 4.839333333333333, "test_python_dispatch": 0.6940000000000002, "test_pytree": 0.5923333333333335, "test_quantization": 7851.2283333333335, "test_reductions": 98.0354999999963, "test_scatter_gather_ops": 11.557666666666668, "test_schema_check": 368.46149999999136, "test_segment_reductions": 1.721666666666667, "test_serialization": 15.310333333333332, "test_set_default_mobile_cpu_allocator": 0.33099999999999996, "test_shape_ops": 29.313000000000002, "test_show_pickle": 0.223, "test_sort_and_select": 3.543999999999996, "test_sparse": 466.199, "test_sparse_csr": 695.7583333333331, "test_sparse_semi_structured": 0.023000000000000003, "test_spectral_ops": 219.35600000000017, "test_stateless": 4.613666666666666, "test_subclass": 0.4825000000000001, "test_sympy_utils": 11.212333333333332, "test_tensor_creation_ops": 79.52850000000038, "test_tensorboard": 160.33966666666666, "test_tensorexpr": 62.754999999999995, "test_tensorexpr_pybind": 0.626, "test_testing": 41.00833333333333, "test_torch": 208.82300000000086, "test_transformers": 490.4779999998307, "test_type_hints": 0.23299999999999998, "test_type_info": 0.35833333333333334, "test_type_promotion": 5.403999999999983, "test_typing": 53.290666666666645, "test_unary_ufuncs": 652.4051666666753, "test_utils": 47.8335000000003, "test_view_ops": 13.608999999999995, "test_vulkan": 0.0, "test_weak": 3.6713333333333327, "test_xnnpack_integration": 467.4289999999999, "torch_np/numpy_tests/core/test_dlpack": 0.001, "torch_np/numpy_tests/core/test_dtype": 0.2943333333333334, "torch_np/numpy_tests/core/test_einsum": 13.106666666666664, "torch_np/numpy_tests/core/test_getlimits": 0.3333333333333333, "torch_np/numpy_tests/core/test_indexing": 0.5840000000000002, "torch_np/numpy_tests/core/test_multiarray": 24.155333333333335, "torch_np/numpy_tests/core/test_numeric": 3.779, "torch_np/numpy_tests/core/test_numerictypes": 0.24633333333333338, "torch_np/numpy_tests/core/test_scalar_ctors": 0.38700000000000007, "torch_np/numpy_tests/core/test_scalar_methods": 0.215, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 16.830000000000002, "torch_np/numpy_tests/core/test_shape_base": 0.48366666666666674, "torch_np/numpy_tests/fft/test_helper": 4.486666666666667, "torch_np/numpy_tests/fft/test_pocketfft": 30.85466666666667, "torch_np/numpy_tests/lib/test_arraypad": 0.25433333333333336, "torch_np/numpy_tests/lib/test_arraysetops": 0.353, "torch_np/numpy_tests/lib/test_function_base": 1.8836666666666666, "torch_np/numpy_tests/lib/test_histograms": 3.1236666666666664, "torch_np/numpy_tests/lib/test_index_tricks": 0.2916666666666667, "torch_np/numpy_tests/lib/test_shape_base_": 0.645, "torch_np/numpy_tests/lib/test_twodim_base": 1.0363333333333333, "torch_np/numpy_tests/lib/test_type_check": 0.3196666666666667, "torch_np/numpy_tests/linalg/test_linalg": 4.473999999999999, "torch_np/test_basic": 14.038333333333332, "torch_np/test_binary_ufuncs": 0.2930000000000001, "torch_np/test_dtype": 0.25433333333333336, "torch_np/test_function_base": 0.342, "torch_np/test_ndarray_methods": 1.981000000000001, "torch_np/test_nep50_examples": 0.0115, "torch_np/test_random": 0.26733333333333337, "torch_np/test_reductions": 2.058999999999967, "torch_np/test_scalars_0D_arrays": 0.3546666666666667, "torch_np/test_ufuncs_basic": 0.8890000000000003, "torch_np/test_unary_ufuncs": 0.3010000000000001}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": 83.28999999999999, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 35.272, "distributed/_composable/fsdp/test_fully_shard_comm": 189.582, "distributed/_composable/fsdp/test_fully_shard_compile": 31.781, "distributed/_composable/fsdp/test_fully_shard_extensions": 52.396, "distributed/_composable/fsdp/test_fully_shard_frozen": 86.739, "distributed/_composable/fsdp/test_fully_shard_init": 28.460499999999996, "distributed/_composable/fsdp/test_fully_shard_memory": 32.735, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 154.769, "distributed/_composable/fsdp/test_fully_shard_overlap": 0.309, "distributed/_composable/fsdp/test_fully_shard_state": 0.43200000000000005, "distributed/_composable/fsdp/test_fully_shard_state_dict": 62.098, "distributed/_composable/fsdp/test_fully_shard_training": 479.14949999999993, "distributed/_composable/fully_shard/test_fully_shard_compile": 106.08350000000002, "distributed/_composable/fully_shard/test_fully_shard_init": 57.235499999999995, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 26.7385, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 27.8285, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 53.763999999999996, "distributed/_composable/fully_shard/test_fully_shard_runtime": 58.675999999999995, "distributed/_composable/fully_shard/test_fully_shard_util": 6.357, "distributed/_composable/test_checkpoint": 20.621499999999997, "distributed/_composable/test_compose": 200.49849999999998, "distributed/_composable/test_contract": 0.3325, "distributed/_composable/test_replicate": 106.469, "distributed/_composable/test_replicate_with_compiler": 100.398, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 24.000499999999995, "distributed/_shard/sharded_tensor/test_logger": 0.3215, "distributed/_shard/sharding_spec/test_sharding_spec": 15.0295, "distributed/_shard/test_sharder": 9.7455, "distributed/_tensor/debug/test_comm_mode": 19.0925, "distributed/_tensor/debug/test_op_coverage": 0.556, "distributed/_tensor/experimental/test_local_map": 106.23949999999999, "distributed/_tensor/experimental/test_tp_transform": 53.6465, "distributed/_tensor/test_api": 40.4185, "distributed/_tensor/test_attention": 5.370000000000002, "distributed/_tensor/test_common_rules": 49.972, "distributed/_tensor/test_convolution_ops": 42.286500000000004, "distributed/_tensor/test_dtensor": 164.61399999999998, "distributed/_tensor/test_dtensor_compile": 62.171, "distributed/_tensor/test_embedding_ops": 18.887, "distributed/_tensor/test_experimental_ops": 18.583, "distributed/_tensor/test_init": 36.2635, "distributed/_tensor/test_math_ops": 65.48949999999999, "distributed/_tensor/test_matrix_ops": 174.31900000000002, "distributed/_tensor/test_op_strategy": 0.5255000000000001, "distributed/_tensor/test_optimizers": 271.46750000000003, "distributed/_tensor/test_pointwise_ops": 0.9440000000000001, "distributed/_tensor/test_random_ops": 39.575500000000005, "distributed/_tensor/test_redistribute": 56.13350000000001, "distributed/_tensor/test_tensor_ops": 365.971, "distributed/_tensor/test_utils": 28.936, "distributed/_tensor/test_view_ops": 31.244, "distributed/_tensor/test_xla_integration": 0.308, "distributed/_tools/test_memory_tracker": 26.4045, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 57.650999999999996, "distributed/algorithms/quantization/test_quantization": 60.94699999999999, "distributed/algorithms/test_join": 45.741, "distributed/checkpoint/e2e/test_e2e_save_and_load": 62.924499999999995, "distributed/checkpoint/e2e/test_fine_tuning": 4.8885, "distributed/checkpoint/e2e/test_fsdp_ep": 4.889, "distributed/checkpoint/e2e/test_pipeline": 6.302, "distributed/checkpoint/fsdp/test_fsdp_dsd": 33.324, "distributed/checkpoint/test_checkpoint": 41.080999999999996, "distributed/checkpoint/test_compatibility": 0.6535, "distributed/checkpoint/test_dedup_tensors": 0.3155, "distributed/checkpoint/test_dtensor_checkpoint": 6.7135, "distributed/checkpoint/test_dtensor_resharding": 38.527499999999996, "distributed/checkpoint/test_file_system_checkpoint": 32.861000000000004, "distributed/checkpoint/test_file_system_checkpoint_cpu": 49.843999999999994, "distributed/checkpoint/test_format_utils": 16.662, "distributed/checkpoint/test_fsdp_model_state": 31.666, "distributed/checkpoint/test_fsdp_optim_state": 52.908, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 27.1855, "distributed/checkpoint/test_fsspec": 33.9275, "distributed/checkpoint/test_hsdp_checkpoint": 19.049500000000002, "distributed/checkpoint/test_nested_dict": 0.3225, "distributed/checkpoint/test_planner": 0.679, "distributed/checkpoint/test_save_load_api": 4.8415, "distributed/checkpoint/test_state_dict": 336.1234999999999, "distributed/checkpoint/test_state_dict_utils": 24.894, "distributed/checkpoint/test_tp_checkpoint": 33.718, "distributed/checkpoint/test_traverse": 0.321, "distributed/checkpoint/test_utils": 0.3255, "distributed/elastic/events/lib_test": 0.42750000000000005, "distributed/elastic/metrics/api_test": 0.324, "distributed/elastic/multiprocessing/api_test": 47.1225, "distributed/elastic/test_control_plane": 5.9505, "distributed/elastic/timer/local_timer_example": 17.188499999999998, "distributed/elastic/timer/local_timer_test": 7.270000000000001, "distributed/elastic/utils/distributed_test": 3.4189999999999996, "distributed/elastic/utils/logging_test": 0.34650000000000003, "distributed/elastic/utils/util_test": 0.43150000000000005, "distributed/fsdp/test_checkpoint_wrapper": 19.494, "distributed/fsdp/test_distributed_checkpoint": 0.3135, "distributed/fsdp/test_fsdp_apply": 19.642500000000002, "distributed/fsdp/test_fsdp_backward_prefetch": 27.8435, "distributed/fsdp/test_fsdp_checkpoint": 449.6165000000001, "distributed/fsdp/test_fsdp_clip_grad_norm": 129.493, "distributed/fsdp/test_fsdp_comm": 266.42449999999997, "distributed/fsdp/test_fsdp_comm_hooks": 478.46900000000016, "distributed/fsdp/test_fsdp_core": 2687.6755, "distributed/fsdp/test_fsdp_dtensor_state_dict": 381.03450000000004, "distributed/fsdp/test_fsdp_exec_order": 211.1605, "distributed/fsdp/test_fsdp_fine_tune": 122.4355, "distributed/fsdp/test_fsdp_flatten_params": 123.30350000000001, "distributed/fsdp/test_fsdp_freezing_weights": 868.0690000000001, "distributed/fsdp/test_fsdp_fx": 0.3335, "distributed/fsdp/test_fsdp_grad_acc": 149.86700000000002, "distributed/fsdp/test_fsdp_hybrid_shard": 84.208, "distributed/fsdp/test_fsdp_ignored_modules": 265.69249999999994, "distributed/fsdp/test_fsdp_input": 51.0335, "distributed/fsdp/test_fsdp_memory": 66.8905, "distributed/fsdp/test_fsdp_meta": 169.26900000000003, "distributed/fsdp/test_fsdp_misc": 269.129, "distributed/fsdp/test_fsdp_mixed_precision": 1553.7044999999998, "distributed/fsdp/test_fsdp_multiple_forward": 26.889, "distributed/fsdp/test_fsdp_multiple_wrapping": 26.336999999999996, "distributed/fsdp/test_fsdp_optim_state": 1532.8085, "distributed/fsdp/test_fsdp_overlap": 77.299, "distributed/fsdp/test_fsdp_pure_fp16": 52.5685, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 479.1915, "distributed/fsdp/test_fsdp_state_dict": 2084.7035, "distributed/fsdp/test_fsdp_tp_integration": 18.093, "distributed/fsdp/test_fsdp_traversal": 6.304, "distributed/fsdp/test_fsdp_uneven": 26.3925, "distributed/fsdp/test_fsdp_unshard_params": 154.986, "distributed/fsdp/test_fsdp_use_orig_params": 693.1055, "distributed/fsdp/test_hsdp_dtensor_state_dict": 36.805499999999995, "distributed/fsdp/test_shard_utils": 12.340999999999998, "distributed/fsdp/test_utils": 0.654, "distributed/fsdp/test_wrap": 413.02, "distributed/launcher/test_run": 56.51049999999999, "distributed/nn/jit/test_instantiator": 0.3345, "distributed/optim/test_zero_redundancy_optimizer": 345.80549999999994, "distributed/pipeline/sync/skip/test_api": 0.015, "distributed/pipeline/sync/skip/test_gpipe": 9.348, "distributed/pipeline/sync/skip/test_inspect_skip_layout": 0.021, "distributed/pipeline/sync/skip/test_leak": 1.2210000000000005, "distributed/pipeline/sync/skip/test_portal": 0.759, "distributed/pipeline/sync/skip/test_stash_pop": 0.027000000000000003, "distributed/pipeline/sync/skip/test_tracker": 0.879, "distributed/pipeline/sync/skip/test_verify_skippables": 0.030000000000000006, "distributed/pipeline/sync/test_balance": 18.534, "distributed/pipeline/sync/test_bugs": 6.918, "distributed/pipeline/sync/test_checkpoint": 2.0100000000000002, "distributed/pipeline/sync/test_copy": 3.2729999999999997, "distributed/pipeline/sync/test_deferred_batch_norm": 3.819, "distributed/pipeline/sync/test_dependency": 0.747, "distributed/pipeline/sync/test_inplace": 0.303, "distributed/pipeline/sync/test_microbatch": 0.03300000000000001, "distributed/pipeline/sync/test_phony": 0.018000000000000002, "distributed/pipeline/sync/test_pipe": 7.748999999999997, "distributed/pipeline/sync/test_pipeline": 0.006, "distributed/pipeline/sync/test_stream": 4.9350000000000005, "distributed/pipeline/sync/test_transparency": 0.873, "distributed/pipeline/sync/test_worker": 0.03300000000000001, "distributed/pipelining/test_backward": 0.374, "distributed/pipelining/test_chunkspec": 1.08, "distributed/pipelining/test_microbatch": 0.7555000000000001, "distributed/pipelining/test_pipe": 1.3384999999999998, "distributed/pipelining/test_schedule": 46.75099999999999, "distributed/pipelining/test_stage": 42.6065, "distributed/pipelining/test_stage_backward": 0.216, "distributed/pipelining/test_transformer": 1.0150000000000001, "distributed/pipelining/test_unflatten": 1.1905000000000001, "distributed/tensor/parallel/test_ddp_2d_parallel": 4.885, "distributed/tensor/parallel/test_fsdp_2d_parallel": 56.299, "distributed/tensor/parallel/test_micro_pipeline_tp": 33.3955, "distributed/tensor/parallel/test_parallelize_api": 49.308499999999995, "distributed/tensor/parallel/test_tp_examples": 113.57600000000001, "distributed/tensor/parallel/test_tp_random_state": 4.786, "distributed/tensor/parallel/test_tp_style": 137.058, "distributed/test_c10d_common": 122.0445, "distributed/test_c10d_functional_native": 238.941, "distributed/test_c10d_gloo": 1043.2535000000003, "distributed/test_c10d_logger": 24.031999999999996, "distributed/test_c10d_nccl": 1832.5689999999997, "distributed/test_c10d_object_collectives": 58.517, "distributed/test_c10d_ops_nccl": 7.565999999999998, "distributed/test_c10d_pypg": 794.083, "distributed/test_c10d_spawn_gloo": 110.3125, "distributed/test_c10d_spawn_nccl": 76.89850000000001, "distributed/test_c10d_spawn_ucc": 0.013500000000000002, "distributed/test_compute_comm_reordering": 4.793999999999999, "distributed/test_control_collectives": 0.3835, "distributed/test_cuda_p2p": 27.735999999999997, "distributed/test_data_parallel": 43.2425, "distributed/test_device_mesh": 192.79250000000002, "distributed/test_distributed_spawn": 9307.648000000045, "distributed/test_dynamo_distributed": 230.8875, "distributed/test_fake_pg": 19.476, "distributed/test_functional_api": 92.862, "distributed/test_inductor_collectives": 264.5435, "distributed/test_launcher": 1.941, "distributed/test_multi_threaded_pg": 0.9765000000000001, "distributed/test_nccl": 0.661, "distributed/test_pg_wrapper": 98.93350000000001, "distributed/test_store": 88.1555}, "slow": {"backends/xeon/test_launch": 1.918, "benchmark_utils/test_benchmark_utils": 390.81199999999984, "distributions/test_constraints": 0.8880000000000002, "distributions/test_distributions": 0.23400000000000015, "dynamo/test_activation_checkpointing": 0.499, "dynamo/test_after_aot": 0.228, "dynamo/test_aot_autograd": 0.274, "dynamo/test_aot_autograd_cache": 0.267, "dynamo/test_autograd_function": 0.5770000000000001, "dynamo/test_backends": 0.24600000000000002, "dynamo/test_backward_higher_order_ops": 0.244, "dynamo/test_base_output": 0.004, "dynamo/test_bytecode_hook": 0.211, "dynamo/test_bytecode_utils": 0.247, "dynamo/test_compile": 0.249, "dynamo/test_comptime": 0.249, "dynamo/test_config": 0.246, "dynamo/test_cpp_guard_manager": 1.2690000000000008, "dynamo/test_ctx_manager": 0.054000000000000034, "dynamo/test_cudagraphs": 0.28500000000000003, "dynamo/test_debug_utils": 0.243, "dynamo/test_decorators": 0.259, "dynamo/test_deviceguard": 0.011999999999999999, "dynamo/test_dynamic_shapes": 2615.403000000022, "dynamo/test_exc": 0.011, "dynamo/test_exceptions": 0.244, "dynamo/test_export": 0.18800000000000014, "dynamo/test_export_mutations": 0.305, "dynamo/test_frame_init": 0.247, "dynamo/test_functions": 0.5340000000000003, "dynamo/test_fx_passes_pre_grad": 0.24, "dynamo/test_global": 0.24000000000000002, "dynamo/test_guard_manager": 0.272, "dynamo/test_higher_order_ops": 0.4780000000000002, "dynamo/test_hooks": 0.276, "dynamo/test_inline_inbuilt_nn_modules": 1.2140000000000009, "dynamo/test_input_attr_tracking": 0.255, "dynamo/test_interop": 0.247, "dynamo/test_logging": 0.335, "dynamo/test_minifier": 0.321, "dynamo/test_misc": 0.7100000000000005, "dynamo/test_model_output": 0.004, "dynamo/test_modules": 0.3410000000000001, "dynamo/test_nops": 0.215, "dynamo/test_optimizers": 0.249, "dynamo/test_pre_dispatch": 0.23, "dynamo/test_profiler": 0.251, "dynamo/test_python_autograd": 0.289, "dynamo/test_recompile_ux": 0.251, "dynamo/test_recompiles": 0.22, "dynamo/test_reorder_logs": 0.251, "dynamo/test_repros": 0.4510000000000003, "dynamo/test_resume": 0.258, "dynamo/test_sdpa": 0.245, "dynamo/test_skip_non_tensor": 0.245, "dynamo/test_sources": 0.256, "dynamo/test_structured_trace": 0.28900000000000003, "dynamo/test_subclasses": 0.5870000000000001, "dynamo/test_subgraphs": 0.28200000000000003, "dynamo/test_trace_rules": 0.25, "dynamo/test_unspec": 0.277, "dynamo/test_verify_correctness": 0.357, "dynamo/test_view": 0.249, "export/test_converter": 0.277, "export/test_db": 0.34500000000000003, "export/test_experimental": 0.259, "export/test_export": 0.4460000000000002, "export/test_export_nonstrict": 0.1560000000000001, "export/test_export_predispatch": 0.1450000000000001, "export/test_functionalized_assertions": 0.242, "export/test_hop": 0.02100000000000001, "export/test_lift_unlift": 0.09999999999999999, "export/test_pass_infra": 0.247, "export/test_passes": 0.262, "export/test_retraceability": 0.1560000000000001, "export/test_safeguard": 0.301, "export/test_schema": 0.25, "export/test_serdes": 0.1560000000000001, "export/test_serialize": 0.32300000000000006, "export/test_sparse": 0.3870000000000001, "export/test_tools": 0.229, "export/test_torchbind": 2.4099999999999993, "export/test_tree_utils": 0.246, "export/test_unflatten": 0.253, "export/test_upgrade": 0.281, "export/test_verifier": 0.226, "functorch/test_aotdispatch": 0.2940000000000002, "functorch/test_control_flow": 0.40300000000000014, "functorch/test_dims": 0.28400000000000003, "functorch/test_eager_transforms": 0.35400000000000026, "functorch/test_logging": 0.262, "functorch/test_memory_efficient_fusion": 0.231, "functorch/test_minifier": 0.224, "functorch/test_ops": 911.2139999999466, "functorch/test_parsing": 0.281, "functorch/test_rearrange": 0.262, "functorch/test_vmap": 19.749000000001402, "functorch/test_vmap_registrations": 1.8569999999999074, "higher_order_ops/test_with_effects": 6.032000000000001, "inductor/test_aot_inductor": 68.35700000000044, "inductor/test_benchmark_fusion": 0.016, "inductor/test_binary_folding": 0.004, "inductor/test_codecache": 21.272000000000002, "inductor/test_codegen_triton": 0.131, "inductor/test_compile_worker": 0.123, "inductor/test_compiled_autograd": 0.47800000000000037, "inductor/test_compiled_optimizers": 141.01100000000005, "inductor/test_config": 0.16, "inductor/test_control_flow": 0.19800000000000004, "inductor/test_coordinate_descent_tuner": 0.228, "inductor/test_cpu_repro": 1160.281999999997, "inductor/test_cuda_cpp_wrapper": 0.07300000000000005, "inductor/test_cuda_repro": 0.05100000000000004, "inductor/test_cudagraph_trees": 0.08400000000000006, "inductor/test_custom_lowering": 0.14100000000000001, "inductor/test_custom_post_grad_passes": 0.171, "inductor/test_debug_trace": 0.002, "inductor/test_decompose_mem_bound_mm": 0.269, "inductor/test_dependencies": 0.155, "inductor/test_distributed_patterns": 0.139, "inductor/test_efficient_conv_bn_eval": 1034.076, "inductor/test_extension_backend": 24.863, "inductor/test_flex_attention": 0.003, "inductor/test_foreach": 0.19800000000000015, "inductor/test_fp8": 0.011000000000000003, "inductor/test_fused_attention": 0.09700000000000006, "inductor/test_fx_fusion": 0.152, "inductor/test_graph_transform_observer": 0.011, "inductor/test_group_batch_fusion": 103.14900000000002, "inductor/test_indexing": 0.14700000000000002, "inductor/test_inductor_freezing": 0.044000000000000025, "inductor/test_inplacing_pass": 0.227, "inductor/test_kernel_benchmark": 0.016000000000000007, "inductor/test_layout_optim": 0.03600000000000001, "inductor/test_loop_ordering": 0.224, "inductor/test_max_autotune": 0.16900000000000004, "inductor/test_memory_planning": 0.218, "inductor/test_metrics": 0.006, "inductor/test_minifier": 0.226, "inductor/test_minifier_isolate": 0.221, "inductor/test_mkldnn_pattern_matcher": 0.22800000000000006, "inductor/test_mmdecomp": 0.026000000000000016, "inductor/test_move_constructors_to_cuda": 0.017000000000000005, "inductor/test_multi_kernel": 0.23900000000000002, "inductor/test_pad_mm": 0.157, "inductor/test_padding": 0.312, "inductor/test_pattern_matcher": 0.04000000000000002, "inductor/test_perf": 0.20500000000000002, "inductor/test_profiler": 0.221, "inductor/test_select_algorithm": 0.164, "inductor/test_smoke": 0.223, "inductor/test_snode_runtime": 0.17, "inductor/test_split_cat_fx_passes": 0.14400000000000002, "inductor/test_standalone_compile": 0.133, "inductor/test_torchbind": 0.228, "inductor/test_torchinductor": 271.38300000000385, "inductor/test_torchinductor_codegen_dynamic_shapes": 204.53000000000367, "inductor/test_torchinductor_dynamic_shapes": 288.9580000000042, "inductor/test_torchinductor_opinfo": 25.729000000002365, "inductor/test_triton_extension_backend": 0.003, "inductor/test_triton_heuristics": 0.21, "inductor/test_triton_kernels": 0.40000000000000013, "inductor/test_triton_wrapper": 0.22, "inductor/test_unbacked_symints": 0.010000000000000002, "inductor/test_utils": 0.247, "lazy/test_debug_util": 0.276, "lazy/test_functionalization": 0.25, "lazy/test_generator": 0.247, "lazy/test_reuse_ir": 0.302, "lazy/test_step_closures": 0.23500000000000001, "lazy/test_ts_opinfo": 0.005, "nn/test_convolution": 0.6710000000000004, "nn/test_dropout": 0.009000000000000001, "nn/test_embedding": 0.1530000000000001, "nn/test_init": 0.404, "nn/test_lazy_modules": 0.06800000000000005, "nn/test_load_state_dict": 0.03400000000000002, "nn/test_module_hooks": 0.06000000000000002, "nn/test_multihead_attention": 0.019000000000000003, "nn/test_packed_sequence": 0.23500000000000001, "nn/test_parametrization": 0.059000000000000045, "nn/test_pooling": 5.115000000000019, "nn/test_pruning": 0.044000000000000025, "profiler/test_execution_trace": 0.018000000000000002, "profiler/test_memory_profiler": 0.28200000000000003, "profiler/test_profiler": 0.06500000000000004, "profiler/test_profiler_tree": 0.32, "profiler/test_record_function": 0.279, "profiler/test_torch_tidy": 0.276, "test_ao_sparsity": 0.26400000000000007, "test_autocast": 0.223, "test_autograd": 20.582000000000328, "test_autograd_fallback": 0.23600000000000002, "test_binary_ufuncs": 16.875999999998534, "test_bundled_inputs": 0.255, "test_comparison_utils": 0.239, "test_compile_benchmark_util": 0.0, "test_complex": 0.016000000000000007, "test_content_store": 0.005, "test_cpp_api_parity": 0.4900000000000004, "test_cpp_extensions_aot_ninja": 0.024000000000000007, "test_cpp_extensions_aot_no_ninja": 0.02300000000000001, "test_cpp_extensions_jit": 0.028000000000000018, "test_cpp_extensions_mtia_backend": 0.0, "test_cpp_extensions_open_device_registration": 25.143000000000022, "test_cpp_extensions_stream_and_event": 0.0, "test_cuda": 4.658000000000001, "test_cuda_expandable_segments": 4.644000000000033, "test_cuda_multigpu": 0.037000000000000005, "test_cuda_primary_ctx": 0.703, "test_cuda_sanitizer": 0.24500000000000002, "test_cuda_trace": 1.9939999999999998, "test_custom_ops": 0.23500000000000015, "test_dataloader": 136.22899999999998, "test_datapipe": 0.279, "test_decomp": 4887.337000001199, "test_deploy": 0.235, "test_dispatch": 0.17800000000000002, "test_dlpack": 0.11800000000000009, "test_dynamic_shapes": 0.5120000000000002, "test_expanded_weights": 0.22100000000000014, "test_fake_tensor": 0.21700000000000014, "test_flop_counter": 0.025000000000000012, "test_foreach": 1.46499999999996, "test_function_schema": 0.264, "test_functional_autograd_benchmark": 94.132, "test_functional_optim": 0.249, "test_functionalization": 0.3720000000000001, "test_functionalization_of_rng_ops": 0.010000000000000002, "test_futures": 0.263, "test_fx": 183.23599999999996, "test_fx_experimental": 0.7080000000000005, "test_fx_passes": 0.25400000000000006, "test_fx_reinplace_pass": 0.306, "test_import_stats": 0.236, "test_indexing": 0.08800000000000005, "test_itt": 0.244, "test_jit": 388.257, "test_jit_autocast": 0.08000000000000002, "test_jit_disabled": 0.207, "test_jit_fuser_te": 732.7009999999998, "test_jit_llga_fuser": 0.003, "test_jiterator": 0.2910000000000002, "test_legacy_vmap": 0.12500000000000008, "test_license": 0.305, "test_linalg": 778.9429999999859, "test_logging": 0.223, "test_masked": 0.1360000000000001, "test_maskedtensor": 1.0500000000000007, "test_matmul_cuda": 0.031000000000000017, "test_meta": 303.91799999956385, "test_mkl_verbose": 0.265, "test_mkldnn_fusion": 0.225, "test_mkldnn_verbose": 0.229, "test_mobile_optimizer": 0.194, "test_model_dump": 0.25, "test_model_exports_to_core_aten": 0.172, "test_module_tracker": 0.249, "test_modules": 873.9219999999478, "test_monitor": 0.354, "test_multiprocessing": 0.031000000000000017, "test_multiprocessing_spawn": 0.228, "test_namedtensor": 0.08700000000000006, "test_namedtuple_return_api": 0.202, "test_native_functions": 0.226, "test_native_mha": 0.05400000000000004, "test_nestedtensor": 0.4830000000000003, "test_nn": 2.2029999999999803, "test_numba_integration": 0.012999999999999998, "test_numpy_interop": 0.04100000000000003, "test_openmp": 0.236, "test_ops": 1992.1689999994408, "test_ops_fwd_gradients": 84.39600000001369, "test_ops_gradients": 858.7659999999412, "test_ops_jit": 68.66000000000155, "test_optim": 0.7140000000000005, "test_out_dtype_op": 0.021000000000000005, "test_overrides": 1.6819999999999302, "test_package": 0.3920000000000001, "test_per_overload_api": 0.246, "test_prims": 0.022000000000000002, "test_proxy_tensor": 0.17300000000000013, "test_pruning_op": 0.258, "test_public_bindings": 0.23500000000000001, "test_python_dispatch": 0.11100000000000007, "test_pytree": 0.32100000000000006, "test_quantization": 3564.142999999998, "test_reductions": 6.231999999999932, "test_scatter_gather_ops": 0.07300000000000005, "test_schema_check": 20.91600000000379, "test_segment_reductions": 0.07400000000000005, "test_serialization": 0.12600000000000008, "test_set_default_mobile_cpu_allocator": 0.255, "test_shape_ops": 0.09500000000000007, "test_show_pickle": 0.209, "test_sort_and_select": 1.5639999999999914, "test_sparse": 318.64299999997166, "test_sparse_csr": 312.4579999999985, "test_sparse_semi_structured": 0.012, "test_spectral_ops": 0.34800000000000025, "test_stateless": 0.05700000000000004, "test_subclass": 0.32100000000000006, "test_sympy_utils": 0.1590000000000001, "test_tensor_creation_ops": 1.962999999999965, "test_tensorboard": 0.31000000000000005, "test_tensorexpr": 0.25200000000000006, "test_tensorexpr_pybind": 0.233, "test_testing": 2.300999999999978, "test_torch": 35.927999999998356, "test_transformers": 96.27600000001333, "test_type_hints": 0.248, "test_type_info": 0.363, "test_type_promotion": 0.4260000000000003, "test_typing": 55.24499999999998, "test_unary_ufuncs": 27.04100000000891, "test_utils": 7.544000000000917, "test_view_ops": 0.2790000000000002, "test_vulkan": 0.0, "test_weak": 0.275, "test_xnnpack_integration": 1364.0439999999999, "torch_np/numpy_tests/core/test_dlpack": 0.002, "torch_np/numpy_tests/core/test_dtype": 0.30000000000000004, "torch_np/numpy_tests/core/test_einsum": 0.258, "torch_np/numpy_tests/core/test_getlimits": 0.249, "torch_np/numpy_tests/core/test_indexing": 0.30900000000000005, "torch_np/numpy_tests/core/test_multiarray": 664.376, "torch_np/numpy_tests/core/test_numeric": 0.4670000000000002, "torch_np/numpy_tests/core/test_numerictypes": 0.28900000000000003, "torch_np/numpy_tests/core/test_scalar_ctors": 0.30600000000000005, "torch_np/numpy_tests/core/test_scalar_methods": 0.249, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 41.80599999999999, "torch_np/numpy_tests/core/test_shape_base": 0.31400000000000006, "torch_np/numpy_tests/fft/test_helper": 0.332, "torch_np/numpy_tests/fft/test_pocketfft": 0.32300000000000006, "torch_np/numpy_tests/lib/test_arraypad": 0.278, "torch_np/numpy_tests/lib/test_arraysetops": 0.28300000000000003, "torch_np/numpy_tests/lib/test_function_base": 0.5700000000000002, "torch_np/numpy_tests/lib/test_histograms": 0.5860000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.338, "torch_np/numpy_tests/lib/test_shape_base_": 0.3320000000000001, "torch_np/numpy_tests/lib/test_twodim_base": 0.277, "torch_np/numpy_tests/lib/test_type_check": 0.265, "torch_np/numpy_tests/linalg/test_linalg": 2.127, "torch_np/test_basic": 0.4560000000000003, "torch_np/test_binary_ufuncs": 0.30600000000000005, "torch_np/test_dtype": 0.28400000000000003, "torch_np/test_function_base": 0.256, "torch_np/test_ndarray_methods": 0.6370000000000001, "torch_np/test_nep50_examples": 0.01, "torch_np/test_random": 0.271, "torch_np/test_reductions": 1.2909999999999948, "torch_np/test_scalars_0D_arrays": 0.29000000000000004, "torch_np/test_ufuncs_basic": 0.5800000000000003, "torch_np/test_unary_ufuncs": 0.28600000000000003}}, "linux-jammy-cpu-py3.12-gcc11-inductor-halide": {"inductor-halide": {"inductor/test_halide": 1.8415}}, "linux-jammy-py3.10-clang15-asan": {"default": {"backends/xeon/test_launch": 5.786333333333334, "benchmark_utils/test_benchmark_utils": 1.1786666666666665, "distributions/test_constraints": 0.13666666666666677, "distributions/test_distributions": 130.124, "dynamo/test_activation_checkpointing": 0.5323333333333333, "dynamo/test_after_aot": 13.111333333333334, "dynamo/test_allow_inline_skip": 0.7493333333333334, "dynamo/test_aot_autograd": 27.391000000000002, "dynamo/test_aot_autograd_cache": 34.709, "dynamo/test_autograd_function": 3.9163333333333328, "dynamo/test_backends": 29.588000000000005, "dynamo/test_backward_higher_order_ops": 26.399333333333335, "dynamo/test_base_output": 0.004, "dynamo/test_bytecode_hook": 14.833333333333334, "dynamo/test_bytecode_utils": 15.222666666666669, "dynamo/test_compile": 15.812, "dynamo/test_comptime": 0.7266666666666667, "dynamo/test_config": 0.6663333333333333, "dynamo/test_cpp_guard_manager": 212.86166666666682, "dynamo/test_ctx_manager": 1.7386666666666668, "dynamo/test_debug_utils": 0.291, "dynamo/test_decorators": 14.650000000000004, "dynamo/test_deviceguard": 0.02366666666666667, "dynamo/test_dynamic_shapes": 644.6853333333335, "dynamo/test_exc": 2.3013333333333335, "dynamo/test_exceptions": 0.6250000000000001, "dynamo/test_export": 21.552666666666664, "dynamo/test_export_mutations": 0.6243333333333335, "dynamo/test_frame_init": 0.27166666666666667, "dynamo/test_functions": 36.28333333333334, "dynamo/test_fx_passes_pre_grad": 1.3923333333333332, "dynamo/test_global": 0.6806666666666668, "dynamo/test_guard_manager": 0.3056666666666667, "dynamo/test_higher_order_ops": 28.492333333333335, "dynamo/test_hooks": 44.481666666666676, "dynamo/test_inline_inbuilt_nn_modules": 168.51300000000018, "dynamo/test_input_attr_tracking": 17.287333333333333, "dynamo/test_interop": 0.7586666666666666, "dynamo/test_logging": 34.425666666666665, "dynamo/test_minifier": 1.7269999999999996, "dynamo/test_misc": 108.7656666666669, "dynamo/test_model_output": 0.006000000000000001, "dynamo/test_modules": 37.404666666666664, "dynamo/test_nops": 0.36466666666666664, "dynamo/test_optimizers": 0.8033333333333333, "dynamo/test_pre_dispatch": 0.5566666666666666, "dynamo/test_profiler": 2.188333333333333, "dynamo/test_python_autograd": 0.7680000000000001, "dynamo/test_recompile_ux": 1.0846666666666664, "dynamo/test_recompiles": 1.079, "dynamo/test_reorder_logs": 0.6090000000000001, "dynamo/test_replay_record": 1.1639999999999997, "dynamo/test_repros": 81.03233333333337, "dynamo/test_resume": 0.48500000000000004, "dynamo/test_sdpa": 0.574, "dynamo/test_skip_non_tensor": 0.626, "dynamo/test_sources": 0.5460000000000002, "dynamo/test_structured_trace": 22.74166666666667, "dynamo/test_subclasses": 33.095666666666666, "dynamo/test_subgraphs": 3.1630000000000003, "dynamo/test_trace_rules": 1.3993333333333335, "dynamo/test_triton_kernels": 0.09866666666666674, "dynamo/test_unspec": 23.60633333333334, "dynamo/test_verify_correctness": 1.0683333333333334, "dynamo/test_view": 0.7183333333333333, "export/test_converter": 12.88533333333333, "export/test_db": 4.581, "export/test_experimental": 1.8429999999999997, "export/test_export": 56.393, "export/test_export_nonstrict": 53.416000000000004, "export/test_export_predispatch": 54.398, "export/test_functionalized_assertions": 0.3993333333333333, "export/test_funtionalized_assertions": 0.8096666666666668, "export/test_hop": 4.158333333333334, "export/test_lift_unlift": 0.17333333333333334, "export/test_pass_infra": 1.335, "export/test_passes": 23.655999999999995, "export/test_retraceability": 71.81566666666666, "export/test_safeguard": 1.3633333333333333, "export/test_schema": 0.3153333333333333, "export/test_serdes": 56.47600000000002, "export/test_serialize": 15.036333333333333, "export/test_sparse": 145.4069999999999, "export/test_tools": 0.6569999999999999, "export/test_torchbind": 5.710666666666666, "export/test_tree_utils": 0.29000000000000004, "export/test_unflatten": 4.991333333333334, "export/test_upgrade": 0.5733333333333334, "export/test_verifier": 1.26, "functorch/test_aotdispatch": 5533.770333333331, "functorch/test_control_flow": 149.99900000000002, "functorch/test_dims": 37.96866666666667, "functorch/test_eager_transforms": 47.651666666666664, "functorch/test_logging": 0.37233333333333335, "functorch/test_memory_efficient_fusion": 0.7300000000000001, "functorch/test_minifier": 0.5433333333333333, "functorch/test_ops": 0.7083333333333335, "functorch/test_parsing": 0.2956666666666667, "functorch/test_rearrange": 0.4303333333333334, "functorch/test_vmap": 2203.1733333333327, "functorch/test_vmap_registrations": 2.956333333333216, "higher_order_ops/test_with_effects": 16.342000000000002, "inductor/test_benchmark_fusion": 13.406, "inductor/test_binary_folding": 61.687333333333335, "inductor/test_codecache": 82.28933333333337, "inductor/test_codegen_triton": 0.324, "inductor/test_compile_worker": 17.658666666666665, "inductor/test_compiled_autograd": 850.7863333333338, "inductor/test_compiled_optimizers": 1172.4736666666665, "inductor/test_config": 9.706666666666663, "inductor/test_control_flow": 0.011666666666666667, "inductor/test_cpp_wrapper": 1698.619, "inductor/test_cpu_cpp_wrapper": 4089.684999999999, "inductor/test_cpu_repro": 1196.888666666667, "inductor/test_cpu_select_algorithm": 7078.133999999999, "inductor/test_custom_lowering": 0.0033333333333333335, "inductor/test_custom_post_grad_passes": 16.597333333333335, "inductor/test_debug_trace": 3.8540000000000005, "inductor/test_decompose_mem_bound_mm": 0.0013333333333333333, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 64.53933333333335, "inductor/test_efficient_conv_bn_eval": 151.93166666666664, "inductor/test_extension_backend": 25.893666666666665, "inductor/test_flex_attention": 0.015000000000000006, "inductor/test_foreach": 28.616999999999905, "inductor/test_fused_attention": 258.35266666666666, "inductor/test_fx_fusion": 0.26199999999999996, "inductor/test_graph_transform_observer": 0.019666666666666666, "inductor/test_group_batch_fusion": 0.205, "inductor/test_indexing": 0.7646666666666667, "inductor/test_inductor_freezing": 84.492, "inductor/test_memory_planning": 0.001, "inductor/test_metrics": 0.164, "inductor/test_mkldnn_pattern_matcher": 1353.9089999999999, "inductor/test_mmdecomp": 0.02300000000000001, "inductor/test_profiler": 0.004, "inductor/test_standalone_compile": 29.467666666666663, "inductor/test_templated_attention": 0.013666666666666672, "inductor/test_torchbind": 22.415000000000003, "inductor/test_torchinductor": 2752.9499999999994, "inductor/test_torchinductor_codegen_dynamic_shapes": 2619.2919999999995, "inductor/test_torchinductor_opinfo": 2.1366666666665353, "inductor/test_triton_extension_backend": 0.8233333333333334, "inductor/test_triton_kernels": 0.07100000000000005, "inductor/test_utils": 0.2683333333333333, "lazy/test_debug_util": 0.649, "lazy/test_functionalization": 0.6509999999999999, "lazy/test_generator": 0.6296666666666667, "lazy/test_reuse_ir": 1.8966666666666665, "lazy/test_step_closures": 2.2606666666666664, "lazy/test_ts_opinfo": 34.2136666666667, "nn/test_convolution": 64.40533333333336, "nn/test_dropout": 1.2429999999999999, "nn/test_embedding": 23.299999999999997, "nn/test_init": 6.7876666666666665, "nn/test_lazy_modules": 0.9353333333333335, "nn/test_load_state_dict": 1.0763333333333331, "nn/test_module_hooks": 0.5566666666666668, "nn/test_multihead_attention": 12.579666666666668, "nn/test_packed_sequence": 1.3606666666666662, "nn/test_parametrization": 2.848999999999999, "nn/test_pooling": 84.0463333333333, "nn/test_pruning": 0.18533333333333343, "profiler/test_execution_trace": 0.35000000000000003, "profiler/test_memory_profiler": 17.455, "profiler/test_profiler": 34.66566666666666, "profiler/test_profiler_tree": 0.5203333333333334, "profiler/test_record_function": 0.5830000000000001, "profiler/test_torch_tidy": 6.865666666666667, "test_ao_sparsity": 28.676333333333332, "test_autocast": 3.323, "test_autograd": 107.93633333333342, "test_autograd_fallback": 0.4353333333333335, "test_binary_ufuncs": 354.73899999997775, "test_bundled_inputs": 3.6166666666666667, "test_comparison_utils": 0.28633333333333333, "test_compile_benchmark_util": 0.001, "test_complex": 0.14, "test_content_store": 11.947000000000001, "test_cpp_api_parity": 8.950666666666665, "test_cpp_extensions_aot_ninja": 0.04966666666666667, "test_cpp_extensions_aot_no_ninja": 0.050333333333333334, "test_cpp_extensions_jit": 52.108, "test_cpp_extensions_mtia_backend": 1.6526666666666667, "test_cpp_extensions_open_device_registration": 17.740333333333336, "test_cpp_extensions_stream_and_event": 1.6816666666666666, "test_custom_backend": 0.5493333333333333, "test_custom_ops": 14.551999999999998, "test_dataloader": 76.64533333333331, "test_datapipe": 19.81866666666666, "test_decomp": 5.171333333333407, "test_deploy": 0.2783333333333333, "test_dispatch": 95.0333333333333, "test_dlpack": 0.3040000000000002, "test_dynamic_shapes": 5.792333333333327, "test_expanded_weights": 32.14733333333333, "test_fake_tensor": 3.9203333333333332, "test_flop_counter": 1.338333333333333, "test_foreach": 151.3909999999959, "test_function_schema": 1.1066666666666667, "test_functional_autograd_benchmark": 67.543, "test_functional_optim": 0.628, "test_functionalization": 12.676666666666662, "test_functionalization_of_rng_ops": 0.04966666666666667, "test_futures": 0.9943333333333334, "test_fx": 784.7366666666666, "test_fx_experimental": 111.45466666666675, "test_fx_passes": 1.0123333333333335, "test_fx_reinplace_pass": 0.614, "test_import_stats": 8.818, "test_indexing": 4.331999999999995, "test_itt": 0.27099999999999996, "test_jit": 439.4350000000001, "test_jit_autocast": 46.796666666666674, "test_jit_disabled": 0.3956666666666666, "test_jit_fuser_te": 1646.8523333333326, "test_jit_llga_fuser": 208.7396666666667, "test_legacy_vmap": 11.37633333333333, "test_license": 0.3216666666666666, "test_linalg": 436.65100000000047, "test_logging": 8.332666666666666, "test_masked": 50.425333333333356, "test_maskedtensor": 10.825666666666656, "test_meta": 25.36133333333696, "test_mkl_verbose": 10.095666666666666, "test_mkldnn": 292.7086666666666, "test_mkldnn_fusion": 1552.207, "test_mkldnn_verbose": 10.118, "test_mobile_optimizer": 9.999666666666668, "test_model_dump": 0.8933333333333334, "test_model_exports_to_core_aten": 0.15566666666666665, "test_module_init": 6.466999999999999, "test_module_tracker": 0.2946666666666667, "test_modules": 2254.170999999979, "test_monitor": 0.5093333333333333, "test_multiprocessing": 22.82366666666667, "test_multiprocessing_spawn": 53.671666666666674, "test_namedtensor": 0.8896666666666668, "test_namedtuple_return_api": 1.6503333333333332, "test_native_functions": 0.8060000000000002, "test_native_mha": 0.7500000000000003, "test_nestedtensor": 35.18633333333333, "test_nn": 475.0746666666662, "test_numba_integration": 0.005333333333333333, "test_numpy_interop": 0.34066666666666673, "test_openmp": 0.001, "test_ops": 6090.7143333332815, "test_ops_fwd_gradients": 2536.535333333321, "test_ops_gradients": 3912.6639999999456, "test_ops_jit": 6070.545666666666, "test_optim": 133.7073333333332, "test_out_dtype_op": 0.3166666666666667, "test_overrides": 2.2299999999999116, "test_package": 8.113999999999999, "test_per_overload_api": 0.322, "test_prims": 0.2886666666666667, "test_proxy_tensor": 1029.775333333332, "test_pruning_op": 1.053, "test_public_bindings": 8.993333333333334, "test_python_dispatch": 0.7310000000000002, "test_pytree": 0.5446666666666667, "test_quantization": 4387.2080000000005, "test_reductions": 146.43033333333565, "test_scatter_gather_ops": 22.96133333333333, "test_schema_check": 444.242999999996, "test_segment_reductions": 3.4106666666666654, "test_serialization": 82.35600000000001, "test_set_default_mobile_cpu_allocator": 0.27499999999999997, "test_shape_ops": 5.353999999999996, "test_show_pickle": 0.28833333333333333, "test_sort_and_select": 5.263999999999997, "test_sparse": 2547.2826666666674, "test_sparse_csr": 462.01599999999775, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 30.857333333333326, "test_stateless": 12.372666666666666, "test_subclass": 0.6963333333333336, "test_sympy_utils": 15.250666666666667, "test_tensor_creation_ops": 69.63233333333345, "test_tensorboard": 123.88866666666667, "test_tensorexpr": 226.83333333333334, "test_tensorexpr_pybind": 0.401, "test_testing": 60.607333333333315, "test_torch": 47.65100000000007, "test_transformers": 933.5656666666665, "test_type_hints": 0.332, "test_type_info": 0.4126666666666667, "test_type_promotion": 10.131333333333318, "test_typing": 80.85633333333332, "test_unary_ufuncs": 1069.49366666659, "test_utils": 59.04333333333409, "test_view_ops": 44.33433333333331, "test_vulkan": 0.001, "test_weak": 4.251333333333332, "test_xnnpack_integration": 189.55066666666664, "torch_np/numpy_tests/core/test_dlpack": 0.0033333333333333335, "torch_np/numpy_tests/core/test_dtype": 0.4973333333333334, "torch_np/numpy_tests/core/test_einsum": 23.083333333333332, "torch_np/numpy_tests/core/test_getlimits": 0.29633333333333334, "torch_np/numpy_tests/core/test_indexing": 0.731666666666667, "torch_np/numpy_tests/core/test_multiarray": 52.946666666666665, "torch_np/numpy_tests/core/test_numeric": 8.238666666666665, "torch_np/numpy_tests/core/test_numerictypes": 0.3906666666666667, "torch_np/numpy_tests/core/test_scalar_ctors": 0.44200000000000017, "torch_np/numpy_tests/core/test_scalar_methods": 0.02033333333333333, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 36.426666666666655, "torch_np/numpy_tests/core/test_shape_base": 0.7810000000000002, "torch_np/numpy_tests/fft/test_helper": 10.248666666666667, "torch_np/numpy_tests/fft/test_pocketfft": 10.217, "torch_np/numpy_tests/lib/test_arraypad": 0.323, "torch_np/numpy_tests/lib/test_arraysetops": 0.6323333333333334, "torch_np/numpy_tests/lib/test_function_base": 2.8753333333333337, "torch_np/numpy_tests/lib/test_histograms": 0.7933333333333336, "torch_np/numpy_tests/lib/test_index_tricks": 0.5143333333333334, "torch_np/numpy_tests/lib/test_shape_base_": 1.2666666666666668, "torch_np/numpy_tests/lib/test_twodim_base": 1.0333333333333334, "torch_np/numpy_tests/lib/test_type_check": 0.5453333333333336, "torch_np/numpy_tests/linalg/test_linalg": 8.682333333333329, "torch_np/test_basic": 0.8706666666666673, "torch_np/test_binary_ufuncs": 0.49366666666666686, "torch_np/test_dtype": 0.37333333333333335, "torch_np/test_function_base": 0.3713333333333333, "torch_np/test_ndarray_methods": 7.706666666666666, "torch_np/test_nep50_examples": 0.016666666666666666, "torch_np/test_random": 0.3783333333333334, "torch_np/test_reductions": 3.8533333333333033, "torch_np/test_scalars_0D_arrays": 0.3950000000000001, "torch_np/test_ufuncs_basic": 1.4963333333333333, "torch_np/test_unary_ufuncs": 0.4440000000000001}, "slow": {"backends/xeon/test_launch": 5.613, "benchmark_utils/test_benchmark_utils": 0.193, "distributions/test_constraints": 0.2530000000000001, "distributions/test_distributions": 0.23300000000000018, "dynamo/test_activation_checkpointing": 0.36200000000000004, "dynamo/test_after_aot": 0.176, "dynamo/test_allow_inline_skip": 0.253, "dynamo/test_aot_autograd": 0.29700000000000004, "dynamo/test_aot_autograd_cache": 0.276, "dynamo/test_autograd_function": 0.376, "dynamo/test_backends": 0.28800000000000003, "dynamo/test_backward_higher_order_ops": 0.182, "dynamo/test_base_output": 0.005, "dynamo/test_bytecode_hook": 0.168, "dynamo/test_bytecode_utils": 0.186, "dynamo/test_compile": 0.233, "dynamo/test_comptime": 0.183, "dynamo/test_config": 0.18, "dynamo/test_cpp_guard_manager": 1.2990000000000006, "dynamo/test_ctx_manager": 0.134, "dynamo/test_debug_utils": 0.275, "dynamo/test_decorators": 0.193, "dynamo/test_deviceguard": 0.013000000000000001, "dynamo/test_dynamic_shapes": 2656.0449999999987, "dynamo/test_exc": 0.012, "dynamo/test_exceptions": 0.184, "dynamo/test_export": 0.23100000000000018, "dynamo/test_export_mutations": 0.179, "dynamo/test_frame_init": 0.175, "dynamo/test_functions": 0.5990000000000003, "dynamo/test_fx_passes_pre_grad": 0.263, "dynamo/test_global": 0.259, "dynamo/test_guard_manager": 0.2, "dynamo/test_higher_order_ops": 0.5760000000000002, "dynamo/test_hooks": 0.29400000000000004, "dynamo/test_inline_inbuilt_nn_modules": 1.399000000000001, "dynamo/test_input_attr_tracking": 0.184, "dynamo/test_interop": 0.183, "dynamo/test_logging": 0.34700000000000003, "dynamo/test_minifier": 0.182, "dynamo/test_misc": 0.46100000000000035, "dynamo/test_model_output": 0.004, "dynamo/test_modules": 0.3670000000000001, "dynamo/test_nops": 0.272, "dynamo/test_optimizers": 0.175, "dynamo/test_pre_dispatch": 0.182, "dynamo/test_profiler": 0.201, "dynamo/test_python_autograd": 0.168, "dynamo/test_recompile_ux": 0.182, "dynamo/test_recompiles": 0.181, "dynamo/test_reorder_logs": 0.18, "dynamo/test_replay_record": 0.17600000000000002, "dynamo/test_repros": 0.2710000000000002, "dynamo/test_resume": 0.207, "dynamo/test_sdpa": 0.266, "dynamo/test_skip_non_tensor": 0.184, "dynamo/test_sources": 0.246, "dynamo/test_structured_trace": 0.276, "dynamo/test_subclasses": 0.43100000000000005, "dynamo/test_subgraphs": 0.3320000000000001, "dynamo/test_trace_rules": 0.181, "dynamo/test_triton_kernels": 0.04900000000000002, "dynamo/test_unspec": 0.21700000000000003, "dynamo/test_verify_correctness": 0.256, "dynamo/test_view": 0.175, "export/test_converter": 0.378, "export/test_db": 0.28600000000000003, "export/test_experimental": 0.28500000000000003, "export/test_export": 0.6040000000000001, "export/test_export_nonstrict": 0.1560000000000001, "export/test_export_predispatch": 0.1450000000000001, "export/test_functionalized_assertions": 0.175, "export/test_funtionalized_assertions": 0.835, "export/test_hop": 0.022000000000000013, "export/test_lift_unlift": 0.16599999999999998, "export/test_pass_infra": 0.271, "export/test_passes": 0.28400000000000003, "export/test_retraceability": 0.18500000000000014, "export/test_safeguard": 0.166, "export/test_schema": 0.264, "export/test_serdes": 0.1570000000000001, "export/test_serialize": 0.43200000000000005, "export/test_sparse": 0.5030000000000001, "export/test_tools": 0.28200000000000003, "export/test_torchbind": 5.175, "export/test_tree_utils": 0.175, "export/test_unflatten": 0.301, "export/test_upgrade": 0.17400000000000002, "export/test_verifier": 0.273, "functorch/test_aotdispatch": 2452.8789999999917, "functorch/test_control_flow": 0.5010000000000002, "functorch/test_dims": 0.43300000000000005, "functorch/test_eager_transforms": 0.5930000000000003, "functorch/test_logging": 0.19, "functorch/test_memory_efficient_fusion": 0.25, "functorch/test_minifier": 0.197, "functorch/test_ops": 0.7420000000000002, "functorch/test_parsing": 0.261, "functorch/test_rearrange": 0.189, "functorch/test_vmap": 4.623999999999876, "functorch/test_vmap_registrations": 2.0079999999999028, "higher_order_ops/test_with_effects": 14.282, "inductor/test_benchmark_fusion": 15.716, "inductor/test_binary_folding": 0.003, "inductor/test_codecache": 0.03700000000000001, "inductor/test_codegen_triton": 0.281, "inductor/test_compile_worker": 0.305, "inductor/test_compiled_autograd": 0.4990000000000004, "inductor/test_compiled_optimizers": 0.3810000000000003, "inductor/test_config": 0.314, "inductor/test_control_flow": 0.011, "inductor/test_cpp_wrapper": 118.8045000000002, "inductor/test_cpu_cpp_wrapper": 2298.449999999999, "inductor/test_cpu_repro": 3361.207000000002, "inductor/test_cpu_select_algorithm": 0.2760000000000002, "inductor/test_custom_lowering": 0.003, "inductor/test_custom_post_grad_passes": 0.203, "inductor/test_debug_trace": 0.002, "inductor/test_decompose_mem_bound_mm": 0.004, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 0.28700000000000003, "inductor/test_efficient_conv_bn_eval": 428.622, "inductor/test_extension_backend": 2.636, "inductor/test_flex_attention": 0.014000000000000005, "inductor/test_foreach": 0.04600000000000003, "inductor/test_fused_attention": 0.050000000000000024, "inductor/test_fx_fusion": 0.17200000000000001, "inductor/test_graph_transform_observer": 0.016, "inductor/test_group_batch_fusion": 0.178, "inductor/test_indexing": 0.314, "inductor/test_inductor_freezing": 0.023000000000000013, "inductor/test_memory_planning": 0.001, "inductor/test_mkldnn_pattern_matcher": 0.25000000000000006, "inductor/test_mmdecomp": 0.11600000000000002, "inductor/test_profiler": 0.005, "inductor/test_standalone_compile": 0.394, "inductor/test_templated_attention": 0.007, "inductor/test_torchbind": 0.278, "inductor/test_torchinductor": 377.5739999999925, "inductor/test_torchinductor_codegen_dynamic_shapes": 332.6649999999927, "inductor/test_torchinductor_opinfo": 0.8400000000000005, "inductor/test_triton_extension_backend": 0.002, "inductor/test_triton_kernels": 0.03700000000000002, "inductor/test_utils": 0.279, "lazy/test_debug_util": 0.185, "lazy/test_functionalization": 0.17, "lazy/test_generator": 0.173, "lazy/test_reuse_ir": 0.253, "lazy/test_step_closures": 0.167, "lazy/test_ts_opinfo": 0.2570000000000002, "nn/test_convolution": 0.6720000000000005, "nn/test_dropout": 0.10900000000000001, "nn/test_embedding": 0.17500000000000013, "nn/test_init": 0.468, "nn/test_lazy_modules": 0.16100000000000003, "nn/test_load_state_dict": 0.16300000000000003, "nn/test_module_hooks": 0.16300000000000003, "nn/test_multihead_attention": 0.11100000000000002, "nn/test_packed_sequence": 0.17400000000000002, "nn/test_parametrization": 0.059000000000000045, "nn/test_pooling": 19.05300000000006, "nn/test_pruning": 0.14600000000000002, "profiler/test_execution_trace": 0.022000000000000006, "profiler/test_memory_profiler": 0.29400000000000004, "profiler/test_profiler": 0.07700000000000004, "profiler/test_profiler_tree": 0.17300000000000001, "profiler/test_record_function": 0.168, "profiler/test_torch_tidy": 0.18600000000000003, "test_ao_sparsity": 0.3640000000000001, "test_autocast": 0.18100000000000002, "test_autograd": 21.73600000000032, "test_autograd_fallback": 0.19700000000000004, "test_binary_ufuncs": 17.523999999998665, "test_bundled_inputs": 0.17800000000000002, "test_comparison_utils": 0.17300000000000001, "test_compile_benchmark_util": 0.001, "test_complex": 0.015000000000000006, "test_content_store": 0.004, "test_cpp_api_parity": 0.3110000000000002, "test_cpp_extensions_aot_ninja": 0.022000000000000002, "test_cpp_extensions_aot_no_ninja": 0.021000000000000005, "test_cpp_extensions_jit": 0.031000000000000017, "test_cpp_extensions_mtia_backend": 1.5239999999999996, "test_cpp_extensions_open_device_registration": 2.954999999999998, "test_cpp_extensions_stream_and_event": 1.562, "test_custom_backend": 0.534, "test_custom_ops": 0.9710000000000003, "test_dataloader": 167.387, "test_datapipe": 0.56, "test_decomp": 5.479000000000152, "test_deploy": 0.174, "test_dispatch": 0.19000000000000003, "test_dlpack": 0.11800000000000009, "test_dynamic_shapes": 0.5300000000000002, "test_expanded_weights": 0.22000000000000014, "test_fake_tensor": 0.1870000000000001, "test_flop_counter": 0.027000000000000014, "test_foreach": 3.6199999999997154, "test_function_schema": 0.203, "test_functional_autograd_benchmark": 224.21, "test_functional_optim": 0.298, "test_functionalization": 0.3750000000000001, "test_functionalization_of_rng_ops": 0.001, "test_futures": 0.196, "test_fx": 738.5570000000004, "test_fx_experimental": 1.054, "test_fx_passes": 0.31400000000000006, "test_fx_reinplace_pass": 0.185, "test_import_stats": 0.25, "test_indexing": 0.08700000000000005, "test_itt": 0.166, "test_jit": 136.0550000000003, "test_jit_autocast": 0.055000000000000035, "test_jit_disabled": 0.158, "test_jit_fuser_te": 9810.883000000033, "test_jit_llga_fuser": 182.67999999999995, "test_legacy_vmap": 0.12400000000000008, "test_license": 0.173, "test_linalg": 147.36800000000193, "test_logging": 0.167, "test_masked": 0.17000000000000012, "test_maskedtensor": 1.342999999999994, "test_meta": 7.258000000000433, "test_mkl_verbose": 0.171, "test_mkldnn": 0.08500000000000006, "test_mkldnn_fusion": 0.17500000000000002, "test_mkldnn_verbose": 0.171, "test_mobile_optimizer": 0.244, "test_model_dump": 0.24200000000000002, "test_model_exports_to_core_aten": 0.259, "test_module_init": 0.3890000000000003, "test_module_tracker": 0.176, "test_modules": 3.9709999999996906, "test_monitor": 0.505, "test_multiprocessing": 0.10900000000000001, "test_multiprocessing_spawn": 0.18400000000000002, "test_namedtensor": 0.08700000000000006, "test_namedtuple_return_api": 0.144, "test_native_functions": 0.17900000000000002, "test_native_mha": 0.02900000000000002, "test_nestedtensor": 0.5560000000000004, "test_nn": 2.2589999999999693, "test_numba_integration": 0.008, "test_numpy_interop": 0.136, "test_openmp": 0.002, "test_ops": 2225.696999999944, "test_ops_fwd_gradients": 50.258999999994074, "test_ops_gradients": 1804.7799999999388, "test_ops_jit": 679.4329999999909, "test_optim": 1.1640000000000008, "test_out_dtype_op": 0.022000000000000006, "test_overrides": 1.7379999999999256, "test_package": 0.43800000000000006, "test_per_overload_api": 0.251, "test_prims": 0.022000000000000006, "test_proxy_tensor": 10.793999999999839, "test_pruning_op": 0.162, "test_public_bindings": 0.168, "test_python_dispatch": 0.11200000000000007, "test_pytree": 0.4050000000000001, "test_quantization": 1715.1889999999999, "test_reductions": 29.649999999999945, "test_scatter_gather_ops": 0.17800000000000005, "test_schema_check": 9.619999999999783, "test_segment_reductions": 0.17100000000000007, "test_serialization": 0.12700000000000009, "test_set_default_mobile_cpu_allocator": 0.241, "test_shape_ops": 0.1930000000000001, "test_show_pickle": 0.156, "test_sort_and_select": 84.15800000000031, "test_sparse": 3.3369999999999216, "test_sparse_csr": 4.957999999999681, "test_sparse_semi_structured": 0.003, "test_spectral_ops": 0.2820000000000002, "test_stateless": 0.06200000000000004, "test_subclass": 0.28600000000000003, "test_sympy_utils": 0.1580000000000001, "test_tensor_creation_ops": 3.972999999999966, "test_tensorboard": 0.437, "test_tensorexpr": 0.30700000000000005, "test_tensorexpr_pybind": 0.17700000000000002, "test_testing": 2.385999999999964, "test_torch": 31.31600000000094, "test_transformers": 2.992999999999964, "test_type_hints": 0.166, "test_type_info": 0.327, "test_type_promotion": 0.45200000000000035, "test_typing": 83.31800000000005, "test_unary_ufuncs": 25.87400000000712, "test_utils": 6.213000000000335, "test_view_ops": 0.5800000000000004, "test_vulkan": 0.001, "test_weak": 0.275, "test_xnnpack_integration": 1466.694, "torch_np/numpy_tests/core/test_dlpack": 0.007, "torch_np/numpy_tests/core/test_dtype": 0.35400000000000004, "torch_np/numpy_tests/core/test_einsum": 0.30000000000000004, "torch_np/numpy_tests/core/test_getlimits": 0.24500000000000002, "torch_np/numpy_tests/core/test_indexing": 0.43200000000000005, "torch_np/numpy_tests/core/test_multiarray": 1114.0829999999996, "torch_np/numpy_tests/core/test_numeric": 0.5740000000000003, "torch_np/numpy_tests/core/test_numerictypes": 0.29600000000000004, "torch_np/numpy_tests/core/test_scalar_ctors": 0.32200000000000006, "torch_np/numpy_tests/core/test_scalar_methods": 0.012, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 73.026, "torch_np/numpy_tests/core/test_shape_base": 0.5770000000000001, "torch_np/numpy_tests/fft/test_helper": 0.171, "torch_np/numpy_tests/fft/test_pocketfft": 0.3380000000000001, "torch_np/numpy_tests/lib/test_arraypad": 0.17200000000000001, "torch_np/numpy_tests/lib/test_arraysetops": 0.267, "torch_np/numpy_tests/lib/test_function_base": 0.6530000000000002, "torch_np/numpy_tests/lib/test_histograms": 1.2259999999999978, "torch_np/numpy_tests/lib/test_index_tricks": 0.31600000000000006, "torch_np/numpy_tests/lib/test_shape_base_": 0.33100000000000007, "torch_np/numpy_tests/lib/test_twodim_base": 0.29400000000000004, "torch_np/numpy_tests/lib/test_type_check": 0.42100000000000004, "torch_np/numpy_tests/linalg/test_linalg": 3.1930000000000005, "torch_np/test_basic": 0.5090000000000003, "torch_np/test_binary_ufuncs": 0.343, "torch_np/test_dtype": 0.21400000000000005, "torch_np/test_function_base": 0.167, "torch_np/test_ndarray_methods": 0.47600000000000015, "torch_np/test_nep50_examples": 0.012, "torch_np/test_random": 0.30800000000000005, "torch_np/test_reductions": 1.2150000000000007, "torch_np/test_scalars_0D_arrays": 0.20500000000000002, "torch_np/test_ufuncs_basic": 0.6150000000000002, "torch_np/test_unary_ufuncs": 0.30700000000000005}}, "linux-jammy-py3.8-gcc11": {"default": {"backends/xeon/test_launch": 1.6506666666666667, "benchmark_utils/test_benchmark_utils": 0.8749999999999999, "distributions/test_constraints": 0.07300000000000005, "distributions/test_distributions": 60.57200000000001, "dynamo/test_activation_checkpointing": 0.5663333333333332, "dynamo/test_after_aot": 6.349333333333334, "dynamo/test_allow_inline_skip": 0.785, "dynamo/test_aot_autograd": 11.405000000000001, "dynamo/test_aot_autograd_cache": 16.369, "dynamo/test_autograd_function": 2.946999999999999, "dynamo/test_backends": 14.035666666666666, "dynamo/test_backward_higher_order_ops": 12.913000000000002, "dynamo/test_base_output": 0.004333333333333334, "dynamo/test_bytecode_hook": 6.102666666666667, "dynamo/test_bytecode_utils": 6.321000000000001, "dynamo/test_compile": 7.578666666666667, "dynamo/test_comptime": 0.6303333333333335, "dynamo/test_config": 0.5673333333333334, "dynamo/test_cpp_guard_manager": 120.6973333333334, "dynamo/test_ctx_manager": 1.2663333333333335, "dynamo/test_debug_utils": 0.2866666666666667, "dynamo/test_decorators": 7.222666666666666, "dynamo/test_deviceguard": 0.017, "dynamo/test_dynamic_shapes": 457.01600000000025, "dynamo/test_exc": 1.9636666666666667, "dynamo/test_exceptions": 0.5073333333333334, "dynamo/test_export": 17.376999999999995, "dynamo/test_export_mutations": 0.531, "dynamo/test_frame_init": 0.26866666666666666, "dynamo/test_functions": 17.775333333333336, "dynamo/test_fx_passes_pre_grad": 1.417, "dynamo/test_global": 0.5153333333333334, "dynamo/test_guard_manager": 0.31333333333333335, "dynamo/test_higher_order_ops": 22.944999999999997, "dynamo/test_hooks": 24.817333333333334, "dynamo/test_inline_inbuilt_nn_modules": 110.91966666666674, "dynamo/test_input_attr_tracking": 8.607333333333331, "dynamo/test_interop": 0.5376666666666666, "dynamo/test_logging": 17.450333333333337, "dynamo/test_minifier": 1.434333333333333, "dynamo/test_misc": 53.76966666666675, "dynamo/test_model_output": 0.004, "dynamo/test_modules": 21.036666666666665, "dynamo/test_nops": 0.35100000000000003, "dynamo/test_optimizers": 0.6083333333333333, "dynamo/test_pre_dispatch": 0.4613333333333334, "dynamo/test_profiler": 1.329, "dynamo/test_python_autograd": 0.6526666666666667, "dynamo/test_recompile_ux": 0.8130000000000002, "dynamo/test_recompiles": 0.8326666666666668, "dynamo/test_reorder_logs": 0.49666666666666676, "dynamo/test_replay_record": 0.7696666666666667, "dynamo/test_repros": 48.22366666666672, "dynamo/test_resume": 0.413, "dynamo/test_sdpa": 0.44733333333333336, "dynamo/test_skip_non_tensor": 0.509, "dynamo/test_sources": 0.4713333333333334, "dynamo/test_structured_trace": 15.021333333333333, "dynamo/test_subclasses": 15.686999999999998, "dynamo/test_subgraphs": 2.3126666666666655, "dynamo/test_trace_rules": 1.2283333333333333, "dynamo/test_triton_kernels": 0.047333333333333345, "dynamo/test_unspec": 13.139000000000001, "dynamo/test_verify_correctness": 0.5493333333333333, "dynamo/test_view": 0.6070000000000001, "export/test_converter": 7.142, "export/test_db": 3.1686666666666663, "export/test_experimental": 0.9126666666666665, "export/test_export": 28.024333333333335, "export/test_export_nonstrict": 27.338999999999995, "export/test_export_predispatch": 27.74666666666667, "export/test_functionalized_assertions": 0.25533333333333336, "export/test_funtionalized_assertions": 0.6876666666666668, "export/test_hop": 2.8186666666666667, "export/test_lift_unlift": 0.20100000000000004, "export/test_pass_infra": 0.9976666666666669, "export/test_passes": 12.277666666666667, "export/test_retraceability": 41.035666666666664, "export/test_safeguard": 0.9286666666666669, "export/test_schema": 0.29066666666666663, "export/test_serdes": 29.30366666666666, "export/test_serialize": 8.941666666666668, "export/test_sparse": 64.2263333333333, "export/test_tools": 0.5026666666666667, "export/test_torchbind": 3.0316666666666663, "export/test_tree_utils": 0.268, "export/test_unflatten": 3.125666666666667, "export/test_upgrade": 0.41875000000000007, "export/test_verifier": 0.8543333333333334, "functorch/test_aotdispatch": 2989.7383333333323, "functorch/test_control_flow": 106.17466666666667, "functorch/test_dims": 30.433999999999994, "functorch/test_eager_transforms": 18.802000000000003, "functorch/test_logging": 0.3013333333333333, "functorch/test_memory_efficient_fusion": 0.5866666666666668, "functorch/test_minifier": 0.4553333333333333, "functorch/test_ops": 3327.4426666666463, "functorch/test_parsing": 0.31, "functorch/test_rearrange": 0.30433333333333334, "functorch/test_vmap": 504.2439999999988, "functorch/test_vmap_registrations": 2.6569999999998806, "higher_order_ops/test_with_effects": 7.937333333333332, "inductor/test_benchmark_fusion": 7.8563333333333345, "inductor/test_binary_folding": 34.327666666666666, "inductor/test_codecache": 40.95199999999999, "inductor/test_codegen_triton": 0.261, "inductor/test_compile_worker": 10.296333333333333, "inductor/test_compiled_autograd": 462.2390000000003, "inductor/test_compiled_optimizers": 714.7523333333339, "inductor/test_config": 5.5, "inductor/test_control_flow": 0.008, "inductor/test_cpp_wrapper": 1124.6383333333333, "inductor/test_cpu_cpp_wrapper": 2670.7953333333335, "inductor/test_cpu_repro": 654.2139999999999, "inductor/test_cpu_select_algorithm": 2886.5056666666674, "inductor/test_custom_lowering": 0.0030000000000000005, "inductor/test_custom_post_grad_passes": 10.063666666666665, "inductor/test_debug_trace": 2.8190000000000004, "inductor/test_decompose_mem_bound_mm": 0.01, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 32.66466666666667, "inductor/test_efficient_conv_bn_eval": 73.56966666666666, "inductor/test_extension_backend": 17.308333333333334, "inductor/test_flex_attention": 0.014333333333333339, "inductor/test_foreach": 16.663333333333355, "inductor/test_fused_attention": 143.19966666666667, "inductor/test_fx_fusion": 0.215, "inductor/test_graph_transform_observer": 0.015666666666666666, "inductor/test_group_batch_fusion": 0.19099999999999998, "inductor/test_indexing": 0.549, "inductor/test_inductor_freezing": 48.580999999999996, "inductor/test_memory_planning": 0.0, "inductor/test_metrics": 0.262, "inductor/test_minifier": 22.84833333333334, "inductor/test_minifier_isolate": 47.472, "inductor/test_mkldnn_pattern_matcher": 725.7026666666666, "inductor/test_mmdecomp": 0.014666666666666673, "inductor/test_profiler": 0.002, "inductor/test_standalone_compile": 16.041666666666668, "inductor/test_templated_attention": 0.006500000000000001, "inductor/test_torchbind": 9.342333333333334, "inductor/test_torchinductor": 1496.0109999999993, "inductor/test_torchinductor_codegen_dynamic_shapes": 1491.1129999999991, "inductor/test_torchinductor_dynamic_shapes": 1573.1783333333326, "inductor/test_torchinductor_opinfo": 24735.035000000007, "inductor/test_triton_extension_backend": 1.5436666666666667, "inductor/test_triton_kernels": 0.10333333333333339, "inductor/test_utils": 0.25933333333333336, "lazy/test_debug_util": 0.3213333333333333, "lazy/test_functionalization": 0.31833333333333336, "lazy/test_generator": 0.306, "lazy/test_reuse_ir": 0.638, "lazy/test_step_closures": 2.2586666666666666, "lazy/test_ts_opinfo": 7.3409999999999735, "nn/test_convolution": 20.53266666666663, "nn/test_dropout": 0.32233333333333336, "nn/test_embedding": 6.333666666666666, "nn/test_init": 3.815333333333333, "nn/test_lazy_modules": 0.3983333333333335, "nn/test_load_state_dict": 0.7036666666666668, "nn/test_module_hooks": 0.18733333333333335, "nn/test_multihead_attention": 5.207, "nn/test_packed_sequence": 0.48066666666666674, "nn/test_parametrization": 0.9476666666666663, "nn/test_pooling": 32.98533333333334, "nn/test_pruning": 0.1223333333333334, "profiler/test_execution_trace": 0.205, "profiler/test_memory_profiler": 4.113666666666667, "profiler/test_profiler": 21.665333333333336, "profiler/test_profiler_tree": 0.34133333333333343, "profiler/test_record_function": 0.33666666666666667, "profiler/test_torch_tidy": 4.369333333333333, "test_ao_sparsity": 7.128666666666665, "test_autocast": 0.8700000000000001, "test_autograd": 35.96599999999996, "test_autograd_fallback": 0.34933333333333344, "test_binary_ufuncs": 108.02000000000112, "test_bundled_inputs": 1.146333333333333, "test_comparison_utils": 0.25866666666666666, "test_compile_benchmark_util": 0.001, "test_complex": 0.057000000000000016, "test_content_store": 5.7076666666666656, "test_cpp_api_parity": 3.6033333333333197, "test_cpp_extensions_aot_ninja": 0.03533333333333335, "test_cpp_extensions_aot_no_ninja": 0.035, "test_cpp_extensions_jit": 39.81833333333334, "test_cpp_extensions_mtia_backend": 0.7573333333333334, "test_cpp_extensions_open_device_registration": 8.550666666666666, "test_cpp_extensions_stream_and_event": 0.775, "test_custom_backend": 0.07466666666666666, "test_custom_ops": 7.63633333333333, "test_dataloader": 116.52466666666665, "test_datapipe": 10.600999999999996, "test_decomp": 4804.520000000007, "test_deploy": 0.277, "test_dispatch": 27.065333333333328, "test_dlpack": 0.19333333333333347, "test_dynamic_shapes": 5.299333333333327, "test_expanded_weights": 8.287666666666665, "test_fake_tensor": 1.6159999999999999, "test_flop_counter": 0.6623333333333332, "test_foreach": 54.34300000000051, "test_function_schema": 0.5983333333333333, "test_functional_autograd_benchmark": 29.000666666666664, "test_functional_optim": 0.36900000000000005, "test_functionalization": 4.764666666666664, "test_functionalization_of_rng_ops": 0.02, "test_futures": 0.9416666666666668, "test_fx": 241.04433333333327, "test_fx_experimental": 56.190666666666665, "test_fx_passes": 0.6943333333333336, "test_fx_reinplace_pass": 0.4150000000000002, "test_import_stats": 3.1953333333333336, "test_indexing": 1.7543333333333317, "test_itt": 0.306, "test_jit": 82.98233333333333, "test_jit_autocast": 14.996333333333334, "test_jit_cuda_fuser": 0.021000000000000005, "test_jit_disabled": 0.391, "test_jit_fuser_te": 187.22833333333446, "test_jit_llga_fuser": 50.03133333333333, "test_legacy_vmap": 2.896666666666666, "test_license": 0.25433333333333336, "test_linalg": 130.0149999999997, "test_logging": 2.1363333333333334, "test_masked": 15.760333333333335, "test_maskedtensor": 9.226666666666608, "test_meta": 1482.5466666666332, "test_mkl_verbose": 3.3523333333333327, "test_mkldnn": 94.96999999999998, "test_mkldnn_fusion": 56.282000000000004, "test_mkldnn_verbose": 3.1793333333333336, "test_mobile_optimizer": 2.396, "test_model_dump": 0.9003333333333333, "test_model_exports_to_core_aten": 0.166, "test_module_init": 2.255999999999993, "test_module_tracker": 0.262, "test_modules": 472.87199999999785, "test_monitor": 0.47900000000000004, "test_multiprocessing": 45.02166666666667, "test_multiprocessing_spawn": 25.263666666666666, "test_namedtensor": 0.3920000000000001, "test_namedtuple_return_api": 1.8020000000000003, "test_native_functions": 0.3763333333333334, "test_native_mha": 0.19400000000000006, "test_nestedtensor": 17.163333333333345, "test_nn": 148.41833333333398, "test_numba_integration": 0.004666666666666667, "test_numpy_interop": 0.15633333333333338, "test_nvfuser_frontend": 0.0, "test_openmp": 4.9303333333333335, "test_ops": 2084.5189999999834, "test_ops_fwd_gradients": 597.9153333333227, "test_ops_gradients": 1041.0236666666212, "test_ops_jit": 845.8089999999994, "test_optim": 38.52133333333336, "test_out_dtype_op": 0.403, "test_overrides": 1.914333333333255, "test_package": 2.258666666666666, "test_per_overload_api": 0.26733333333333337, "test_prims": 0.17633333333333337, "test_proxy_tensor": 618.274333333332, "test_pruning_op": 0.446, "test_public_bindings": 6.362333333333333, "test_python_dispatch": 0.5746666666666669, "test_pytree": 0.43600000000000017, "test_quantization": 1833.0486666666668, "test_reductions": 213.6280000000027, "test_scatter_gather_ops": 3.9643333333333346, "test_schema_check": 191.7626666666648, "test_segment_reductions": 0.9600000000000003, "test_serialization": 35.10166666666667, "test_set_default_mobile_cpu_allocator": 0.30633333333333335, "test_shape_ops": 0.9893333333333328, "test_show_pickle": 0.249, "test_sort_and_select": 1.9783333333333306, "test_sparse": 421.5949999999989, "test_sparse_csr": 158.4926666666671, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 6.143999999999985, "test_stateless": 4.951666666666667, "test_subclass": 0.4290000000000001, "test_sympy_utils": 16.301333333333336, "test_tensor_creation_ops": 23.105666666666703, "test_tensorboard": 34.729, "test_tensorexpr": 45.44566666666666, "test_tensorexpr_pybind": 0.8696666666666668, "test_testing": 33.56566666666665, "test_torch": 14.58300000000006, "test_transformers": 297.6189999999994, "test_type_hints": 0.26933333333333337, "test_type_info": 0.2966666666666667, "test_type_promotion": 2.6723333333333206, "test_typing": 73.00233333333335, "test_unary_ufuncs": 339.34199999987646, "test_utils": 35.065333333333996, "test_view_ops": 12.371333333333348, "test_vulkan": 0.001, "test_weak": 4.083333333333333, "test_xnnpack_integration": 35.833999999999996, "torch_np/numpy_tests/core/test_dlpack": 0.0026666666666666666, "torch_np/numpy_tests/core/test_dtype": 0.43100000000000005, "torch_np/numpy_tests/core/test_einsum": 12.476333333333331, "torch_np/numpy_tests/core/test_getlimits": 0.28400000000000003, "torch_np/numpy_tests/core/test_indexing": 0.46300000000000013, "torch_np/numpy_tests/core/test_multiarray": 24.384666666666664, "torch_np/numpy_tests/core/test_numeric": 3.8643333333333323, "torch_np/numpy_tests/core/test_numerictypes": 0.31633333333333336, "torch_np/numpy_tests/core/test_scalar_ctors": 0.32700000000000007, "torch_np/numpy_tests/core/test_scalar_methods": 0.298, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 19.971, "torch_np/numpy_tests/core/test_shape_base": 0.47166666666666685, "torch_np/numpy_tests/fft/test_helper": 4.776000000000001, "torch_np/numpy_tests/fft/test_pocketfft": 4.008333333333333, "torch_np/numpy_tests/lib/test_arraypad": 0.3076666666666667, "torch_np/numpy_tests/lib/test_arraysetops": 0.38933333333333336, "torch_np/numpy_tests/lib/test_function_base": 1.6883333333333335, "torch_np/numpy_tests/lib/test_histograms": 0.5220000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.4520000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.6246666666666668, "torch_np/numpy_tests/lib/test_twodim_base": 0.5040000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.3866666666666667, "torch_np/numpy_tests/linalg/test_linalg": 4.3693333333333335, "torch_np/test_basic": 0.5966666666666671, "torch_np/test_binary_ufuncs": 0.3616666666666668, "torch_np/test_dtype": 0.319, "torch_np/test_function_base": 0.32233333333333336, "torch_np/test_ndarray_methods": 2.539666666666667, "torch_np/test_nep50_examples": 0.1496666666666667, "torch_np/test_random": 0.3620000000000001, "torch_np/test_reductions": 2.4663333333332944, "torch_np/test_scalars_0D_arrays": 0.2986666666666667, "torch_np/test_ufuncs_basic": 1.0353333333333339, "torch_np/test_unary_ufuncs": 0.38466666666666677}, "distributed": {"distributed/_composable/fsdp/test_fully_shard_autograd": 0.24933333333333332, "distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 0.24566666666666667, "distributed/_composable/fsdp/test_fully_shard_collectives": 0.002, "distributed/_composable/fsdp/test_fully_shard_comm": 0.024333333333333335, "distributed/_composable/fsdp/test_fully_shard_compile": 3.8813333333333335, "distributed/_composable/fsdp/test_fully_shard_extensions": 2.933, "distributed/_composable/fsdp/test_fully_shard_frozen": 0.24666666666666667, "distributed/_composable/fsdp/test_fully_shard_init": 0.012666666666666668, "distributed/_composable/fsdp/test_fully_shard_memory": 0.24766666666666667, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 0.26133333333333336, "distributed/_composable/fsdp/test_fully_shard_overlap": 0.248, "distributed/_composable/fsdp/test_fully_shard_state": 0.0033333333333333335, "distributed/_composable/fsdp/test_fully_shard_state_dict": 0.016333333333333335, "distributed/_composable/fsdp/test_fully_shard_training": 0.04166666666666668, "distributed/_composable/fully_shard/test_fully_shard_compile": 0.001, "distributed/_composable/fully_shard/test_fully_shard_init": 15.950333333333333, "distributed/_composable/fully_shard/test_fully_shard_mixed_precision": 2.8313333333333333, "distributed/_composable/fully_shard/test_fully_shard_model_checkpoint": 10.583666666666666, "distributed/_composable/fully_shard/test_fully_shard_optim_checkpoint": 5.416333333333334, "distributed/_composable/fully_shard/test_fully_shard_runtime": 0.243, "distributed/_composable/fully_shard/test_fully_shard_util": 2.8299999999999996, "distributed/_composable/test_checkpoint": 0.06366666666666668, "distributed/_composable/test_compose": 24.169333333333338, "distributed/_composable/test_contract": 0.25166666666666665, "distributed/_composable/test_replicate": 23.845333333333333, "distributed/_composable/test_replicate_with_compiler": 0.24566666666666667, "distributed/_shard/sharded_optim/test_sharded_optim": 0.002, "distributed/_shard/sharded_tensor/ops/test_binary_cmp": 0.0026666666666666666, "distributed/_shard/sharded_tensor/ops/test_embedding": 0.002, "distributed/_shard/sharded_tensor/ops/test_embedding_bag": 0.002, "distributed/_shard/sharded_tensor/ops/test_init": 0.0026666666666666666, "distributed/_shard/sharded_tensor/ops/test_tensor_ops": 0.0023333333333333335, "distributed/_shard/sharded_tensor/test_logger": 0.24466666666666667, "distributed/_shard/sharded_tensor/test_sharded_tensor": 5.7363333333333335, "distributed/_shard/sharded_tensor/test_sharded_tensor_reshard": 0.002, "distributed/_shard/sharding_plan/test_sharding_plan": 0.0026666666666666666, "distributed/_shard/sharding_spec/test_sharding_spec": 3.0216666666666665, "distributed/_shard/test_sharder": 0.002, "distributed/_tensor/debug/test_comm_mode": 0.26533333333333337, "distributed/_tensor/debug/test_op_coverage": 0.35766666666666663, "distributed/_tensor/experimental/test_local_map": 10.617666666666667, "distributed/_tensor/experimental/test_tp_transform": 10.492666666666665, "distributed/_tensor/test_api": 22.206333333333333, "distributed/_tensor/test_attention": 2.7996666666666665, "distributed/_tensor/test_basic_strategy": 0.305, "distributed/_tensor/test_common_rules": 27.44666666666667, "distributed/_tensor/test_convolution_ops": 63.55533333333333, "distributed/_tensor/test_device_mesh": 65.558, "distributed/_tensor/test_dtensor": 97.69133333333333, "distributed/_tensor/test_dtensor_compile": 17.672666666666668, "distributed/_tensor/test_dtensor_ops": 62.59200000000002, "distributed/_tensor/test_embedding_ops": 8.983333333333333, "distributed/_tensor/test_experimental_ops": 8.064, "distributed/_tensor/test_init": 19.447999999999997, "distributed/_tensor/test_math_ops": 30.28933333333333, "distributed/_tensor/test_matrix_ops": 24.716333333333335, "distributed/_tensor/test_op_strategy": 0.3506666666666667, "distributed/_tensor/test_optimizers": 35.166, "distributed/_tensor/test_pointwise_ops": 0.3866666666666667, "distributed/_tensor/test_random_ops": 19.327666666666662, "distributed/_tensor/test_redistribute": 33.595666666666666, "distributed/_tensor/test_tensor_ops": 73.50866666666666, "distributed/_tensor/test_utils": 20.606333333333335, "distributed/_tensor/test_view_ops": 27.907, "distributed/_tensor/test_xla_integration": 0.25766666666666665, "distributed/_tools/test_memory_tracker": 0.001, "distributed/_tools/test_mod_tracker": 0.25933333333333336, "distributed/algorithms/ddp_comm_hooks/test_ddp_hooks": 0.0030000000000000005, "distributed/algorithms/quantization/test_quantization": 11.779666666666666, "distributed/algorithms/test_join": 23.700666666666667, "distributed/checkpoint/e2e/test_e2e_save_and_load": 35.36533333333334, "distributed/checkpoint/e2e/test_fine_tuning": 0.253, "distributed/checkpoint/e2e/test_fsdp_ep": 0.249, "distributed/checkpoint/e2e/test_pipeline": 0.24300000000000002, "distributed/checkpoint/fsdp/test_fsdp_dsd": 0.23933333333333331, "distributed/checkpoint/test_checkpoint": 5.596, "distributed/checkpoint/test_compatibility": 0.256, "distributed/checkpoint/test_dedup_tensors": 0.33433333333333337, "distributed/checkpoint/test_dtensor_checkpoint": 2.9746666666666672, "distributed/checkpoint/test_dtensor_resharding": 13.995666666666667, "distributed/checkpoint/test_file_system_checkpoint": 0.27366666666666667, "distributed/checkpoint/test_file_system_checkpoint_cpu": 27.310333333333336, "distributed/checkpoint/test_format_utils": 8.592, "distributed/checkpoint/test_fsdp_model_state": 5.668666666666667, "distributed/checkpoint/test_fsdp_optim_state": 5.624, "distributed/checkpoint/test_fsdp_tp_checkpoint_conversion": 2.962666666666667, "distributed/checkpoint/test_fsspec": 0.261, "distributed/checkpoint/test_hsdp_checkpoint": 11.121666666666668, "distributed/checkpoint/test_nested_dict": 0.253, "distributed/checkpoint/test_planner": 0.2843333333333334, "distributed/checkpoint/test_save_load_api": 2.834, "distributed/checkpoint/test_state_dict": 3.2379999999999995, "distributed/checkpoint/test_state_dict_utils": 0.26633333333333337, "distributed/checkpoint/test_torch_save_to_dcp": 5.081333333333333, "distributed/checkpoint/test_tp_checkpoint": 5.864666666666667, "distributed/checkpoint/test_traverse": 0.25633333333333336, "distributed/checkpoint/test_utils": 0.26266666666666666, "distributed/elastic/events/lib_test": 0.3096666666666667, "distributed/elastic/metrics/api_test": 0.2703333333333333, "distributed/elastic/multiprocessing/api_test": 27.534000000000002, "distributed/elastic/test_control_plane": 3.3689999999999998, "distributed/elastic/timer/local_timer_example": 14.417333333333334, "distributed/elastic/timer/local_timer_test": 4.449666666666666, "distributed/elastic/utils/distributed_test": 2.2866666666666666, "distributed/elastic/utils/logging_test": 0.27899999999999997, "distributed/elastic/utils/util_test": 0.2846666666666667, "distributed/fsdp/test_checkpoint_wrapper": 0.327, "distributed/fsdp/test_distributed_checkpoint": 0.244, "distributed/fsdp/test_fsdp_apply": 7.997000000000001, "distributed/fsdp/test_fsdp_backward_prefetch": 2.834, "distributed/fsdp/test_fsdp_checkpoint": 46.258, "distributed/fsdp/test_fsdp_clip_grad_norm": 11.315666666666667, "distributed/fsdp/test_fsdp_comm": 22.214, "distributed/fsdp/test_fsdp_comm_hooks": 44.17533333333333, "distributed/fsdp/test_fsdp_core": 165.46466666666666, "distributed/fsdp/test_fsdp_dtensor_state_dict": 41.288000000000004, "distributed/fsdp/test_fsdp_exec_order": 22.683666666666664, "distributed/fsdp/test_fsdp_fine_tune": 0.24666666666666667, "distributed/fsdp/test_fsdp_flatten_params": 27.91366666666667, "distributed/fsdp/test_fsdp_freezing_weights": 88.51466666666668, "distributed/fsdp/test_fsdp_fx": 0.261, "distributed/fsdp/test_fsdp_grad_acc": 15.918333333333331, "distributed/fsdp/test_fsdp_hybrid_shard": 15.884666666666668, "distributed/fsdp/test_fsdp_ignored_modules": 0.27466666666666667, "distributed/fsdp/test_fsdp_input": 5.238333333333333, "distributed/fsdp/test_fsdp_memory": 5.483, "distributed/fsdp/test_fsdp_meta": 21.017333333333337, "distributed/fsdp/test_fsdp_misc": 36.638333333333335, "distributed/fsdp/test_fsdp_mixed_precision": 145.8686666666667, "distributed/fsdp/test_fsdp_multiple_forward": 3.003, "distributed/fsdp/test_fsdp_multiple_wrapping": 2.9446666666666665, "distributed/fsdp/test_fsdp_optim_state": 177.18200000000013, "distributed/fsdp/test_fsdp_overlap": 5.380333333333333, "distributed/fsdp/test_fsdp_pure_fp16": 5.8709999999999996, "distributed/fsdp/test_fsdp_sharded_grad_scaler": 47.134666666666675, "distributed/fsdp/test_fsdp_state_dict": 0.542666666666667, "distributed/fsdp/test_fsdp_tp_integration": 8.491999999999999, "distributed/fsdp/test_fsdp_traversal": 2.83, "distributed/fsdp/test_fsdp_uneven": 2.971, "distributed/fsdp/test_fsdp_unshard_params": 38.617666666666665, "distributed/fsdp/test_fsdp_use_orig_params": 58.079, "distributed/fsdp/test_hsdp_dtensor_state_dict": 21.977333333333334, "distributed/fsdp/test_shard_utils": 5.4126666666666665, "distributed/fsdp/test_utils": 0.256, "distributed/fsdp/test_wrap": 71.35133333333334, "distributed/launcher/test_run": 35.296, "distributed/nn/jit/test_instantiator": 0.26566666666666666, "distributed/optim/test_zero_redundancy_optimizer": 67.80133333333332, "distributed/pipeline/sync/skip/test_api": 0.005, "distributed/pipeline/sync/skip/test_gpipe": 0.325, "distributed/pipeline/sync/skip/test_inspect_skip_layout": 0.007, "distributed/pipeline/sync/skip/test_leak": 0.44900000000000007, "distributed/pipeline/sync/skip/test_portal": 0.012000000000000002, "distributed/pipeline/sync/skip/test_stash_pop": 0.009000000000000001, "distributed/pipeline/sync/skip/test_tracker": 0.006666666666666667, "distributed/pipeline/sync/skip/test_verify_skippables": 0.010000000000000002, "distributed/pipeline/sync/test_balance": 4.022333333333333, "distributed/pipeline/sync/test_bugs": 0.4789999999999999, "distributed/pipeline/sync/test_checkpoint": 0.219, "distributed/pipeline/sync/test_copy": 0.005333333333333333, "distributed/pipeline/sync/test_deferred_batch_norm": 1.206, "distributed/pipeline/sync/test_dependency": 0.007, "distributed/pipeline/sync/test_inplace": 0.11733333333333333, "distributed/pipeline/sync/test_microbatch": 0.013000000000000003, "distributed/pipeline/sync/test_phony": 0.005, "distributed/pipeline/sync/test_pipe": 1.460333333333333, "distributed/pipeline/sync/test_pipeline": 0.005, "distributed/pipeline/sync/test_stream": 0.009000000000000001, "distributed/pipeline/sync/test_transparency": 0.26033333333333336, "distributed/pipeline/sync/test_worker": 0.008666666666666668, "distributed/pipelining/test_backward": 0.26333333333333336, "distributed/pipelining/test_chunkspec": 0.6426666666666666, "distributed/pipelining/test_microbatch": 0.598, "distributed/pipelining/test_pipe": 0.9463333333333334, "distributed/pipelining/test_stage_backward": 0.2765, "distributed/pipelining/test_transformer": 0.8466666666666667, "distributed/pipelining/test_unflatten": 0.7200000000000001, "distributed/rpc/cuda/test_tensorpipe_agent": 318.02333333333337, "distributed/rpc/test_faulty_agent": 246.30000000000004, "distributed/rpc/test_share_memory": 3.1310000000000002, "distributed/rpc/test_tensorpipe_agent": 1606.172666666667, "distributed/tensor/parallel/test_ddp_2d_parallel": 2.94, "distributed/tensor/parallel/test_fsdp_2d_parallel": 33.717000000000006, "distributed/tensor/parallel/test_micro_pipeline_tp": 0.0030000000000000005, "distributed/tensor/parallel/test_parallelize_api": 28.285333333333337, "distributed/tensor/parallel/test_tp_examples": 20.049666666666667, "distributed/tensor/parallel/test_tp_random_state": 3.0400000000000005, "distributed/tensor/parallel/test_tp_style": 25.80033333333333, "distributed/tensor/parallel/test_view_sharding_dim_change": 2.365, "distributed/test_c10d_common": 75.00266666666666, "distributed/test_c10d_functional_native": 0.004666666666666667, "distributed/test_c10d_gloo": 364.03099999999995, "distributed/test_c10d_logger": 7.825333333333333, "distributed/test_c10d_object_collectives": 24.033666666666665, "distributed/test_c10d_pypg": 105.30500000000002, "distributed/test_c10d_spawn_gloo": 22.416666666666668, "distributed/test_c10d_spawn_nccl": 0.013000000000000003, "distributed/test_c10d_spawn_ucc": 0.009000000000000001, "distributed/test_compute_comm_reordering": 0.0013333333333333333, "distributed/test_control_collectives": 0.2956666666666667, "distributed/test_cuda_p2p": 0.001, "distributed/test_data_parallel": 0.026333333333333337, "distributed/test_device_mesh": 129.367, "distributed/test_distributed_spawn": 1384.9206666666644, "distributed/test_dynamo_distributed": 14.193, "distributed/test_fake_pg": 0.26466666666666666, "distributed/test_functional_api": 29.76466666666666, "distributed/test_inductor_collectives": 0.0030000000000000005, "distributed/test_launcher": 1.287, "distributed/test_multi_threaded_pg": 0.36900000000000005, "distributed/test_pg_wrapper": 29.292666666666662, "distributed/test_store": 58.43066666666667, "distributed/test_symmetric_memory": 0.0003333333333333333}, "jit_legacy": {"test_jit_fuser_legacy": 0.0016666666666666668, "test_jit_legacy": 63.16666666666663}}, "linux-jammy-py3.9-clang12-asan": {"default": {"backends/xeon/test_launch": 5.648, "benchmark_utils/test_benchmark_utils": 0.901, "distributions/test_constraints": 0.11600000000000009, "distributions/test_distributions": 135.798, "dynamo/test_activation_checkpointing": 1.7749999999999995, "dynamo/test_after_aot": 22.499000000000002, "dynamo/test_aot_autograd": 8.647, "dynamo/test_autograd_function": 1.5479999999999998, "dynamo/test_backends": 38.951, "dynamo/test_comptime": 0.532, "dynamo/test_config": 0.599, "dynamo/test_ctx_manager": 1.551, "dynamo/test_decorators": 0.6850000000000002, "dynamo/test_dynamic_shapes": 487.49799999999993, "dynamo/test_exc": 2.6710000000000003, "dynamo/test_export": 22.624000000000002, "dynamo/test_export_mutations": 0.43300000000000005, "dynamo/test_functions": 23.04699999999998, "dynamo/test_global": 0.5740000000000002, "dynamo/test_higher_order_ops": 7.728999999999999, "dynamo/test_interop": 0.528, "dynamo/test_logging": 29.54700000000002, "dynamo/test_minifier": 2.029, "dynamo/test_misc": 81.50700000000012, "dynamo/test_model_output": 0.002, "dynamo/test_modules": 27.433, "dynamo/test_nops": 0.396, "dynamo/test_optimizers": 3.2960000000000003, "dynamo/test_pre_dispatch": 0.5840000000000001, "dynamo/test_profiler": 1.2850000000000001, "dynamo/test_python_autograd": 1.191, "dynamo/test_recompiles": 1.0210000000000001, "dynamo/test_replay_record": 0.003, "dynamo/test_repros": 48.71400000000003, "dynamo/test_skip_non_tensor": 0.516, "dynamo/test_subclasses": 1.256, "dynamo/test_subgraphs": 3.8419999999999983, "dynamo/test_unspec": 22.685999999999996, "dynamo/test_verify_correctness": 1.032, "export/test_db": 3.472000000000001, "export/test_export": 15.747, "export/test_funtionalized_assertions": 0.271, "export/test_pass_infra": 0.842, "export/test_passes": 1.9099999999999997, "export/test_serialize": 5.976, "export/test_upgrade": 0.447, "export/test_verifier": 0.9940000000000002, "functorch/test_aotdispatch": 5137.8619999999955, "functorch/test_control_flow": 14.784999999999997, "functorch/test_dims": 28.496999999999996, "functorch/test_eager_transforms": 64.51499999999999, "functorch/test_memory_efficient_fusion": 0.546, "functorch/test_minifier": 0.495, "functorch/test_ops": 0.8640000000000003, "functorch/test_parsing": 0.271, "functorch/test_rearrange": 0.337, "functorch/test_vmap": 2003.1879999999987, "functorch/test_vmap_registrations": 2.02499999999989, "inductor/test_binary_folding": 53.007999999999996, "inductor/test_codegen_triton": 0.359, "inductor/test_compiled_autograd": 444.0789999999996, "inductor/test_compiled_optimizers": 0.006, "inductor/test_config": 7.606, "inductor/test_cpp_wrapper": 239.18199999999996, "inductor/test_cpu_repro": 599.186, "inductor/test_custom_lowering": 0.004, "inductor/test_custom_post_grad_passes": 4.567, "inductor/test_dependencies": 0.001, "inductor/test_efficient_conv_bn_eval": 383.265, "inductor/test_extension_backend": 5.542, "inductor/test_foreach": 18.57400000000001, "inductor/test_fused_attention": 74.75200000000001, "inductor/test_fx_fusion": 0.329, "inductor/test_group_batch_fusion": 0.001, "inductor/test_indexing": 0.542, "inductor/test_inductor_freezing": 46.744, "inductor/test_mkldnn_pattern_matcher": 474.47499999999997, "inductor/test_mmdecomp": 46.93300000000001, "inductor/test_profiler": 0.002, "inductor/test_standalone_compile": 13.423000000000002, "inductor/test_torchinductor": 1593.039, "inductor/test_torchinductor_codegen_dynamic_shapes": 1504.7639999999988, "inductor/test_torchinductor_opinfo": 2.5099999999998457, "lazy/test_debug_util": 0.627, "lazy/test_reuse_ir": 2.2270000000000003, "lazy/test_step_closures": 2.263, "lazy/test_ts_opinfo": 36.759, "nn/test_convolution": 51.286999999999935, "nn/test_dropout": 1.208, "nn/test_embedding": 30.126, "nn/test_lazy_modules": 0.9730000000000003, "nn/test_module_hooks": 0.312, "nn/test_multihead_attention": 8.916000000000002, "nn/test_packed_sequence": 1.5010000000000001, "nn/test_parametrization": 1.4380000000000002, "nn/test_pooling": 116.87100000000001, "nn/test_pruning": 0.18400000000000008, "profiler/test_memory_profiler": 13.652999999999999, "profiler/test_profiler": 23.106999999999996, "profiler/test_profiler_tree": 0.7500000000000002, "test_ao_sparsity": 33.913000000000004, "test_autocast": 0.46100000000000013, "test_autograd": 86.39800000000005, "test_autograd_fallback": 0.3900000000000001, "test_binary_ufuncs": 353.67499999999194, "test_bundled_inputs": 3.9119999999999995, "test_comparison_utils": 0.29700000000000004, "test_compile_benchmark_util": 0.001, "test_complex": 0.11499999999999999, "test_content_store": 19.153000000000002, "test_cpp_api_parity": 11.605999999999993, "test_cpp_extensions_aot_ninja": 0.05499999999999999, "test_cpp_extensions_aot_no_ninja": 0.055, "test_cpp_extensions_jit": 42.60000000000001, "test_cpp_extensions_open_device_registration": 2.355, "test_custom_backend": 0.5289999999999999, "test_custom_ops": 4.516, "test_dataloader": 0.529, "test_datapipe": 3.4279999999999995, "test_decomp": 1.9049999999999832, "test_deploy": 0.26, "test_dispatch": 97.39999999999999, "test_dlpack": 0.1570000000000001, "test_dynamic_shapes": 4.897000000000001, "test_expanded_weights": 38.043000000000006, "test_fake_tensor": 1.3270000000000002, "test_flop_counter": 1.254, "test_foreach": 247.88900000000106, "test_function_schema": 1.0939999999999999, "test_functional_autograd_benchmark": 70.003, "test_functional_optim": 0.47600000000000003, "test_functionalization": 15.767999999999995, "test_functionalization_of_rng_ops": 0.051, "test_futures": 0.918, "test_fx": 897.2119999999999, "test_fx_experimental": 105.88, "test_fx_passes": 0.5850000000000003, "test_fx_reinplace_pass": 0.9210000000000002, "test_import_stats": 7.9190000000000005, "test_indexing": 3.9849999999999954, "test_itt": 0.261, "test_jit": 483.3900000000005, "test_jit_autocast": 59.206999999999994, "test_jit_cuda_fuser": 0.14, "test_jit_disabled": 0.598, "test_jit_fuser_te": 1598.1539999999993, "test_jit_llga_fuser": 362.95399999999995, "test_legacy_vmap": 9.205999999999998, "test_license": 0.265, "test_linalg": 547.1699999999996, "test_logging": 6.574, "test_masked": 44.608000000000054, "test_maskedtensor": 7.075999999999887, "test_meta": 7.142000000000169, "test_mkl_verbose": 12.339, "test_mkldnn": 315.32999999999987, "test_mkldnn_fusion": 1923.044, "test_mkldnn_verbose": 7.935, "test_mobile_optimizer": 10.636999999999999, "test_model_dump": 0.7850000000000001, "test_module_init": 7.62299999999999, "test_modules": 1830.7279999999892, "test_monitor": 0.667, "test_multiprocessing": 17.880000000000006, "test_multiprocessing_spawn": 42.677, "test_namedtensor": 1.9549999999999983, "test_namedtuple_return_api": 1.847, "test_native_functions": 0.8080000000000002, "test_native_mha": 0.8750000000000004, "test_nestedtensor": 9.013999999999996, "test_nn": 499.0779999999986, "test_numba_integration": 0.003, "test_numpy_interop": 0.20400000000000001, "test_nvfuser_frontend": 0.001, "test_openmp": 0.0, "test_ops": 7685.825999999945, "test_ops_fwd_gradients": 2161.9189999999653, "test_ops_gradients": 3360.062999999963, "test_ops_jit": 6298.512, "test_optim": 335.9100000000001, "test_out_dtype_op": 0.309, "test_overrides": 1.9069999999999285, "test_package": 7.296999999999999, "test_per_overload_api": 0.27, "test_prims": 0.48800000000000004, "test_proxy_tensor": 1029.0430000000017, "test_pruning_op": 0.778, "test_public_bindings": 2.965, "test_python_dispatch": 0.5470000000000002, "test_pytree": 0.3890000000000001, "test_quantization": 4662.958, "test_reductions": 142.0729999999988, "test_scatter_gather_ops": 28.996000000000006, "test_schema_check": 1079.276999999995, "test_segment_reductions": 2.6980000000000013, "test_serialization": 94.20400000000001, "test_set_default_mobile_cpu_allocator": 0.265, "test_shape_ops": 6.209999999999995, "test_show_pickle": 0.292, "test_sort_and_select": 6.164000000000004, "test_sparse": 2390.532, "test_sparse_csr": 668.7529999999972, "test_spectral_ops": 33.25799999999998, "test_stateless": 12.8, "test_subclass": 0.7200000000000002, "test_sympy_utils": 20.079000000000004, "test_tensor_creation_ops": 81.33200000000004, "test_tensorboard": 112.03999999999999, "test_tensorexpr": 247.464, "test_tensorexpr_pybind": 0.337, "test_testing": 46.185999999999964, "test_torch": 49.76000000000004, "test_transformers": 84.37099999999997, "test_type_hints": 0.229, "test_type_info": 0.272, "test_type_promotion": 21.62699999999995, "test_unary_ufuncs": 1134.4409999999464, "test_utils": 50.27800000000036, "test_view_ops": 39.872, "test_vulkan": 0.001, "test_weak": 8.900999999999996, "test_xnnpack_integration": 28.052, "torch_np/numpy_tests/core/test_dlpack": 0.56, "torch_np/numpy_tests/core/test_dtype": 0.40700000000000003, "torch_np/numpy_tests/core/test_einsum": 22.614, "torch_np/numpy_tests/core/test_getlimits": 0.498, "torch_np/numpy_tests/core/test_indexing": 0.8850000000000001, "torch_np/numpy_tests/core/test_multiarray": 45.057, "torch_np/numpy_tests/core/test_numeric": 7.358999999999998, "torch_np/numpy_tests/core/test_numerictypes": 0.30500000000000005, "torch_np/numpy_tests/core/test_scalar_ctors": 0.536, "torch_np/numpy_tests/core/test_scalar_methods": 0.536, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 37.739, "torch_np/numpy_tests/core/test_shape_base": 1.0390000000000001, "torch_np/numpy_tests/fft/test_helper": 8.528, "torch_np/numpy_tests/fft/test_pocketfft": 10.007, "torch_np/numpy_tests/lib/test_arraypad": 0.47900000000000004, "torch_np/numpy_tests/lib/test_arraysetops": 0.551, "torch_np/numpy_tests/lib/test_function_base": 3.808, "torch_np/numpy_tests/lib/test_histograms": 1.12, "torch_np/numpy_tests/lib/test_index_tricks": 0.5830000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 1.0870000000000002, "torch_np/numpy_tests/lib/test_twodim_base": 0.8210000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.5910000000000001, "torch_np/numpy_tests/linalg/test_linalg": 19.519000000000005, "torch_np/test_basic": 0.7530000000000004, "torch_np/test_binary_ufuncs": 0.6170000000000001, "torch_np/test_dtype": 0.29300000000000004, "torch_np/test_function_base": 0.485, "torch_np/test_ndarray_methods": 6.433999999999998, "torch_np/test_nep50_examples": 0.101, "torch_np/test_random": 0.28500000000000003, "torch_np/test_reductions": 4.387999999999955, "torch_np/test_scalars_0D_arrays": 0.30300000000000005, "torch_np/test_ufuncs_basic": 1.4170000000000007, "torch_np/test_unary_ufuncs": 0.5860000000000001}, "slow": {"backends/xeon/test_launch": 6.418, "benchmark_utils/test_benchmark_utils": 0.20500000000000002, "distributions/test_constraints": 0.12400000000000008, "distributions/test_distributions": 0.22700000000000015, "dynamo/test_activation_checkpointing": 0.28500000000000003, "dynamo/test_after_aot": 0.241, "dynamo/test_allow_inline_skip": 0.262, "dynamo/test_aot_autograd": 0.264, "dynamo/test_autograd_function": 0.258, "dynamo/test_backends": 0.302, "dynamo/test_comptime": 0.254, "dynamo/test_config": 0.231, "dynamo/test_ctx_manager": 0.03700000000000002, "dynamo/test_debug_utils": 0.229, "dynamo/test_decorators": 0.247, "dynamo/test_dynamic_shapes": 174.42000000000013, "dynamo/test_exc": 0.01, "dynamo/test_export": 0.3910000000000001, "dynamo/test_export_mutations": 0.262, "dynamo/test_functions": 0.44200000000000017, "dynamo/test_global": 0.24000000000000002, "dynamo/test_higher_order_ops": 0.45900000000000013, "dynamo/test_hooks": 0.28, "dynamo/test_interop": 0.247, "dynamo/test_logging": 0.28600000000000003, "dynamo/test_minifier": 0.244, "dynamo/test_misc": 0.33700000000000024, "dynamo/test_model_output": 0.003, "dynamo/test_modules": 0.3420000000000001, "dynamo/test_nops": 0.23600000000000002, "dynamo/test_optimizers": 0.24100000000000002, "dynamo/test_pre_dispatch": 0.272, "dynamo/test_profiler": 0.27, "dynamo/test_python_autograd": 0.242, "dynamo/test_recompiles": 0.29, "dynamo/test_replay_record": 0.002, "dynamo/test_repros": 0.3700000000000001, "dynamo/test_skip_non_tensor": 0.265, "dynamo/test_subclasses": 0.28, "dynamo/test_subgraphs": 0.28700000000000003, "dynamo/test_unspec": 0.24900000000000003, "dynamo/test_verify_correctness": 0.23500000000000001, "export/test_db": 0.275, "export/test_export": 0.23700000000000004, "export/test_funtionalized_assertions": 0.276, "export/test_pass_infra": 0.229, "export/test_passes": 0.184, "export/test_serialize": 0.52, "export/test_upgrade": 0.166, "export/test_verifier": 0.265, "functorch/test_aotdispatch": 1903.4129999999848, "functorch/test_control_flow": 0.43100000000000016, "functorch/test_dims": 0.25500000000000006, "functorch/test_eager_transforms": 0.34900000000000025, "functorch/test_memory_efficient_fusion": 0.274, "functorch/test_minifier": 0.23500000000000001, "functorch/test_ops": 0.4360000000000001, "functorch/test_parsing": 0.264, "functorch/test_rearrange": 0.28200000000000003, "functorch/test_vmap": 4.917999999999938, "functorch/test_vmap_registrations": 2.193999999999884, "inductor/test_binary_folding": 0.002, "inductor/test_codecache": 0.019000000000000003, "inductor/test_codegen_triton": 0.193, "inductor/test_compiled_autograd": 0.33000000000000024, "inductor/test_compiled_optimizers": 0.006, "inductor/test_config": 0.203, "inductor/test_cpp_wrapper": 138.79000000000016, "inductor/test_cpu_repro": 387.65099999999785, "inductor/test_custom_lowering": 0.004, "inductor/test_custom_post_grad_passes": 0.281, "inductor/test_dependencies": 0.001, "inductor/test_efficient_conv_bn_eval": 290.795, "inductor/test_extension_backend": 2.735, "inductor/test_foreach": 0.03300000000000002, "inductor/test_fused_attention": 0.02300000000000001, "inductor/test_fx_fusion": 0.352, "inductor/test_group_batch_fusion": 0.001, "inductor/test_indexing": 0.195, "inductor/test_inductor_freezing": 0.016000000000000007, "inductor/test_mkldnn_pattern_matcher": 0.22900000000000004, "inductor/test_mmdecomp": 0.028000000000000014, "inductor/test_profiler": 0.002, "inductor/test_standalone_compile": 0.195, "inductor/test_torchinductor": 105.26100000000152, "inductor/test_torchinductor_codegen_dynamic_shapes": 1.3539999999999677, "inductor/test_torchinductor_opinfo": 0.6420000000000003, "lazy/test_debug_util": 0.278, "lazy/test_reuse_ir": 0.244, "lazy/test_step_closures": 0.253, "lazy/test_ts_opinfo": 0.2570000000000002, "nn/test_convolution": 0.5790000000000004, "nn/test_dropout": 0.009000000000000001, "nn/test_embedding": 0.16000000000000011, "nn/test_lazy_modules": 0.07000000000000005, "nn/test_module_hooks": 0.049000000000000016, "nn/test_multihead_attention": 0.019000000000000003, "nn/test_packed_sequence": 0.256, "nn/test_parametrization": 0.03800000000000002, "nn/test_pooling": 21.153000000000056, "nn/test_pruning": 0.04700000000000003, "profiler/test_memory_profiler": 0.29600000000000004, "profiler/test_profiler": 0.08700000000000004, "profiler/test_profiler_tree": 0.267, "test_ao_sparsity": 0.3340000000000001, "test_autocast": 0.26, "test_autograd": 22.639000000000323, "test_autograd_fallback": 0.281, "test_binary_ufuncs": 14.498999999998514, "test_bundled_inputs": 0.274, "test_comparison_utils": 0.255, "test_compile_benchmark_util": 0.0, "test_complex": 0.010000000000000002, "test_content_store": 0.003, "test_cpp_api_parity": 0.3810000000000003, "test_cpp_extensions_aot_ninja": 0.028000000000000008, "test_cpp_extensions_aot_no_ninja": 0.026000000000000006, "test_cpp_extensions_jit": 0.034000000000000016, "test_cpp_extensions_open_device_registration": 2.347, "test_custom_backend": 0.546, "test_custom_ops": 5.691999999999999, "test_dataloader": 142.26600000000002, "test_datapipe": 0.3340000000000001, "test_decomp": 1.1829999999999876, "test_deploy": 0.281, "test_dispatch": 0.19600000000000004, "test_dlpack": 0.10500000000000008, "test_dynamic_shapes": 0.42800000000000016, "test_expanded_weights": 0.17700000000000013, "test_fake_tensor": 0.07100000000000004, "test_flop_counter": 0.022000000000000006, "test_foreach": 2.1559999999998882, "test_function_schema": 0.281, "test_functional_autograd_benchmark": 308.843, "test_functional_optim": 0.181, "test_functionalization": 0.3530000000000001, "test_functionalization_of_rng_ops": 0.001, "test_futures": 0.28, "test_fx": 847.646, "test_fx_experimental": 1.3179999999999708, "test_fx_passes": 0.23500000000000004, "test_fx_reinplace_pass": 0.262, "test_import_stats": 0.265, "test_indexing": 0.08900000000000005, "test_itt": 0.29, "test_jit": 131.77100000000033, "test_jit_autocast": 0.017, "test_jit_cuda_fuser": 0.132, "test_jit_disabled": 0.249, "test_jit_fuser_te": 9145.708000000037, "test_jit_llga_fuser": 458.1189999999999, "test_legacy_vmap": 0.1290000000000001, "test_license": 0.269, "test_linalg": 125.10500000000175, "test_logging": 0.234, "test_masked": 0.2610000000000001, "test_maskedtensor": 0.9340000000000007, "test_meta": 8.067000000000883, "test_mkl_verbose": 0.254, "test_mkldnn": 0.08300000000000006, "test_mkldnn_fusion": 0.262, "test_mkldnn_verbose": 0.278, "test_mobile_optimizer": 0.196, "test_model_dump": 0.258, "test_module_init": 0.3870000000000003, "test_modules": 2.579999999999829, "test_monitor": 0.483, "test_multiprocessing": 0.272, "test_multiprocessing_spawn": 0.268, "test_namedtensor": 0.08200000000000006, "test_namedtuple_return_api": 0.23500000000000001, "test_native_functions": 0.267, "test_native_mha": 0.028000000000000018, "test_nestedtensor": 0.2660000000000002, "test_nn": 2.771999999999931, "test_numba_integration": 0.002, "test_numpy_interop": 0.027000000000000017, "test_nvfuser_frontend": 0.001, "test_openmp": 0.001, "test_ops": 1848.6809999999673, "test_ops_fwd_gradients": 53.82799999999404, "test_ops_gradients": 721.2479999999275, "test_ops_jit": 616.0379999999924, "test_optim": 0.18300000000000013, "test_out_dtype_op": 0.10300000000000001, "test_overrides": 1.6949999999999288, "test_package": 0.31500000000000006, "test_per_overload_api": 0.274, "test_prims": 0.022000000000000006, "test_proxy_tensor": 10.163999999999781, "test_pruning_op": 0.25, "test_public_bindings": 0.261, "test_python_dispatch": 0.11000000000000007, "test_pytree": 0.31900000000000006, "test_quantization": 1.16, "test_reductions": 32.374999999999744, "test_scatter_gather_ops": 0.08100000000000006, "test_schema_check": 7.7890000000008826, "test_segment_reductions": 0.07400000000000005, "test_serialization": 0.11000000000000007, "test_set_default_mobile_cpu_allocator": 0.279, "test_shape_ops": 0.09300000000000007, "test_show_pickle": 0.248, "test_sort_and_select": 112.78700000000029, "test_sparse": 3.152999999999913, "test_sparse_csr": 4.852999999999693, "test_spectral_ops": 0.2890000000000002, "test_stateless": 0.06300000000000004, "test_subclass": 0.32600000000000007, "test_sympy_utils": 0.1570000000000001, "test_tensor_creation_ops": 3.9309999999999703, "test_tensorboard": 0.30100000000000005, "test_tensorexpr": 0.33000000000000007, "test_tensorexpr_pybind": 0.273, "test_testing": 2.1409999999999756, "test_torch": 42.27399999999846, "test_transformers": 2.0109999999999975, "test_type_hints": 0.255, "test_type_info": 0.28, "test_type_promotion": 0.4250000000000003, "test_unary_ufuncs": 25.15000000000686, "test_utils": 5.873000000000224, "test_view_ops": 0.4920000000000003, "test_vulkan": 0.0, "test_weak": 0.322, "test_xnnpack_integration": 1503.662, "torch_np/numpy_tests/core/test_dlpack": 0.32300000000000006, "torch_np/numpy_tests/core/test_dtype": 0.21200000000000005, "torch_np/numpy_tests/core/test_einsum": 0.276, "torch_np/numpy_tests/core/test_getlimits": 0.26, "torch_np/numpy_tests/core/test_indexing": 0.29100000000000004, "torch_np/numpy_tests/core/test_multiarray": 1023.3820000000001, "torch_np/numpy_tests/core/test_numeric": 7.245000000000001, "torch_np/numpy_tests/core/test_numerictypes": 0.28800000000000003, "torch_np/numpy_tests/core/test_scalar_ctors": 0.32300000000000006, "torch_np/numpy_tests/core/test_scalar_methods": 0.255, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 96.20900000000002, "torch_np/numpy_tests/core/test_shape_base": 0.3410000000000001, "torch_np/numpy_tests/fft/test_helper": 0.263, "torch_np/numpy_tests/fft/test_pocketfft": 6.3729999999999976, "torch_np/numpy_tests/lib/test_arraypad": 0.26, "torch_np/numpy_tests/lib/test_arraysetops": 0.30100000000000005, "torch_np/numpy_tests/lib/test_function_base": 0.7700000000000004, "torch_np/numpy_tests/lib/test_histograms": 1.5879999999999976, "torch_np/numpy_tests/lib/test_index_tricks": 0.28600000000000003, "torch_np/numpy_tests/lib/test_shape_base_": 0.30200000000000005, "torch_np/numpy_tests/lib/test_twodim_base": 0.267, "torch_np/numpy_tests/lib/test_type_check": 0.278, "torch_np/numpy_tests/linalg/test_linalg": 0.40900000000000014, "torch_np/test_basic": 0.7840000000000004, "torch_np/test_binary_ufuncs": 0.29800000000000004, "torch_np/test_dtype": 0.29100000000000004, "torch_np/test_function_base": 0.262, "torch_np/test_ndarray_methods": 0.5850000000000002, "torch_np/test_nep50_examples": 0.097, "torch_np/test_random": 0.271, "torch_np/test_reductions": 1.5459999999999718, "torch_np/test_scalars_0D_arrays": 0.29100000000000004, "torch_np/test_ufuncs_basic": 0.6080000000000003, "torch_np/test_unary_ufuncs": 0.30500000000000005}}, "macos-12-py3-arm64": {"default": {"backends/xeon/test_launch": 0.0, "benchmark_utils/test_benchmark_utils": 0.4326666666666667, "distributions/test_constraints": 0.005, "distributions/test_distributions": 35.181999999999995, "dynamo/test_activation_checkpointing": 0.20966666666666667, "dynamo/test_after_aot": 3.800333333333333, "dynamo/test_allow_inline_skip": 0.3706666666666667, "dynamo/test_aot_autograd": 6.895333333333333, "dynamo/test_aot_autograd_cache": 0.38566666666666666, "dynamo/test_autograd_function": 1.0999999999999996, "dynamo/test_backends": 5.566666666666666, "dynamo/test_backward_higher_order_ops": 5.572333333333334, "dynamo/test_base_output": 0.0, "dynamo/test_bytecode_hook": 3.789, "dynamo/test_compile": 4.131, "dynamo/test_comptime": 0.39333333333333337, "dynamo/test_config": 0.47266666666666673, "dynamo/test_cpp_guard_manager": 51.02566666666666, "dynamo/test_ctx_manager": 0.8083333333333337, "dynamo/test_debug_utils": 0.10866666666666668, "dynamo/test_decorators": 0.4763333333333335, "dynamo/test_deviceguard": 0.009666666666666665, "dynamo/test_dynamic_shapes": 2123.5679999999998, "dynamo/test_exc": 1.1463333333333334, "dynamo/test_export": 9.432333333333332, "dynamo/test_export_mutations": 0.4116666666666667, "dynamo/test_frame_init": 0.09333333333333334, "dynamo/test_functions": 10.178333333333361, "dynamo/test_fx_passes_pre_grad": 0.7520000000000001, "dynamo/test_global": 0.4436666666666667, "dynamo/test_guard_manager": 0.11800000000000004, "dynamo/test_higher_order_ops": 11.34533333333333, "dynamo/test_hooks": 10.132333333333335, "dynamo/test_input_attr_tracking": 4.212, "dynamo/test_interop": 0.4206666666666667, "dynamo/test_logging": 6.6226666666666665, "dynamo/test_minifier": 0.8346666666666667, "dynamo/test_misc": 20.81000000000002, "dynamo/test_model_output": 0.0, "dynamo/test_modules": 5.722333333333331, "dynamo/test_nops": 0.34500000000000003, "dynamo/test_optimizers": 0.4606666666666667, "dynamo/test_pre_dispatch": 0.3873333333333333, "dynamo/test_profiler": 0.7023333333333334, "dynamo/test_python_autograd": 0.4953333333333334, "dynamo/test_recompile_ux": 0.555, "dynamo/test_recompiles": 0.5620000000000002, "dynamo/test_reorder_logs": 0.4116666666666667, "dynamo/test_replay_record": 0.0023333333333333335, "dynamo/test_repros": 16.35633333333333, "dynamo/test_sdpa": 0.403, "dynamo/test_skip_non_tensor": 0.4066666666666667, "dynamo/test_sources": 0.37666666666666665, "dynamo/test_structured_trace": 5.077000000000001, "dynamo/test_subclasses": 6.4673333333333325, "dynamo/test_subgraphs": 1.3153333333333326, "dynamo/test_trace_rules": 0.8116666666666669, "dynamo/test_triton_kernels": 0.042333333333333334, "dynamo/test_unspec": 5.605, "dynamo/test_verify_correctness": 0.4683333333333333, "export/test_db": 1.5363333333333327, "export/test_experimental": 0.44933333333333336, "export/test_export": 14.662999999999997, "export/test_export_nonstrict": 12.133666666666665, "export/test_export_predispatch": 14.608999999999995, "export/test_functionalized_assertions": 0.35300000000000004, "export/test_funtionalized_assertions": 0.4716666666666667, "export/test_hop": 1.3513333333333335, "export/test_lift_unlift": 0.0, "export/test_pass_infra": 0.5830000000000001, "export/test_passes": 5.058000000000001, "export/test_retraceability": 19.048999999999996, "export/test_safeguard": 0.5750000000000001, "export/test_schema": 0.11866666666666666, "export/test_serdes": 25.936000000000003, "export/test_serialize": 0.7613333333333335, "export/test_torchbind": 0.0, "export/test_tree_utils": 0.09366666666666668, "export/test_unflatten": 1.480666666666667, "export/test_upgrade": 0.41133333333333333, "export/test_verifier": 0.5553333333333335, "functorch/test_aotdispatch": 1796.7376666666669, "functorch/test_control_flow": 48.04966666666667, "functorch/test_dims": 12.489666666666665, "functorch/test_eager_transforms": 7.939333333333333, "functorch/test_logging": 0.11633333333333333, "functorch/test_memory_efficient_fusion": 0.48233333333333334, "functorch/test_minifier": 0.238, "functorch/test_ops": 1100.673333333332, "functorch/test_parsing": 0.34366666666666673, "functorch/test_rearrange": 0.35533333333333333, "functorch/test_vmap": 340.2753333333319, "functorch/test_vmap_registrations": 2.060666666666551, "higher_order_ops/test_with_effects": 0.0013333333333333333, "inductor/test_aot_inductor": 429.67366666666703, "inductor/test_codecache": 13.134666666666668, "inductor/test_codegen_triton": 0.19400000000000003, "inductor/test_compiled_autograd": 88.00733333333328, "inductor/test_compiled_optimizers": 274.789, "inductor/test_config": 3.0033333333333325, "inductor/test_control_flow": 0.001, "inductor/test_custom_lowering": 0.001, "inductor/test_debug_trace": 2.182333333333333, "inductor/test_decompose_mem_bound_mm": 0.0003333333333333333, "inductor/test_dependencies": 0.0003333333333333333, "inductor/test_flex_attention": 0.0, "inductor/test_foreach": 6.388000000000002, "inductor/test_fused_attention": 11.803333333333333, "inductor/test_fx_fusion": 0.17933333333333334, "inductor/test_group_batch_fusion": 0.10633333333333334, "inductor/test_indexing": 0.35966666666666663, "inductor/test_inductor_freezing": 0.002, "inductor/test_memory_planning": 0.0, "inductor/test_metrics": 0.107, "inductor/test_mmdecomp": 14.716999999999992, "inductor/test_profiler": 0.0, "inductor/test_standalone_compile": 6.892666666666667, "inductor/test_templated_attention": 0.001, "inductor/test_torchinductor": 268.4299999999998, "inductor/test_torchinductor_codegen_dynamic_shapes": 554.1703333333335, "inductor/test_torchinductor_dynamic_shapes": 597.968, "inductor/test_torchinductor_opinfo": 1165.692666666666, "inductor/test_triton_kernels": 0.0023333333333333335, "inductor/test_utils": 0.09733333333333334, "lazy/test_debug_util": 0.336, "lazy/test_functionalization": 0.3506666666666667, "lazy/test_generator": 0.337, "lazy/test_reuse_ir": 0.618, "lazy/test_step_closures": 2.3343333333333334, "lazy/test_ts_opinfo": 2.677666666666663, "nn/test_convolution": 96.01866666666665, "nn/test_dropout": 0.367, "nn/test_embedding": 2.5429999999999975, "nn/test_init": 2.9199999999999995, "nn/test_lazy_modules": 0.5813333333333336, "nn/test_load_state_dict": 0.5693333333333334, "nn/test_module_hooks": 0.324, "nn/test_multihead_attention": 9.647666666666666, "nn/test_packed_sequence": 0.39100000000000007, "nn/test_parametrization": 0.48533333333333345, "nn/test_pooling": 22.351666666666674, "nn/test_pruning": 0.277, "profiler/test_execution_trace": 0.063, "profiler/test_memory_profiler": 2.1853333333333333, "profiler/test_profiler": 16.295999999999996, "profiler/test_profiler_tree": 0.0, "profiler/test_record_function": 0.335, "profiler/test_torch_tidy": 1.9453333333333334, "test_ao_sparsity": 1.876666666666667, "test_autocast": 1.0443333333333333, "test_autograd": 9.85700000000001, "test_autograd_fallback": 0.37200000000000005, "test_binary_ufuncs": 56.388666666676045, "test_bundled_inputs": 1.2043333333333326, "test_comparison_utils": 0.3356666666666667, "test_compile_benchmark_util": 0.0, "test_complex": 0.25266666666666665, "test_content_store": 3.321333333333333, "test_cpp_extensions_aot_ninja": 0.3383333333333333, "test_cpp_extensions_aot_no_ninja": 0.3363333333333334, "test_cpp_extensions_jit": 81.20733333333334, "test_cpp_extensions_mtia_backend": 0.23366666666666666, "test_cpp_extensions_open_device_registration": 0.23, "test_cpp_extensions_stream_and_event": 0.23466666666666666, "test_custom_backend": 0.14533333333333334, "test_custom_ops": 6.573666666666682, "test_dataloader": 1133.840666666667, "test_datapipe": 24.738666666666663, "test_decomp": 2199.8073333333236, "test_deploy": 0.3376666666666667, "test_dispatch": 18.49833333333333, "test_dlpack": 0.34433333333333344, "test_dynamic_shapes": 2.3720000000000003, "test_expanded_weights": 3.1163333333333334, "test_fake_tensor": 1.0363333333333333, "test_flop_counter": 0.29100000000000004, "test_foreach": 49.91800000000021, "test_function_schema": 0.459, "test_functional_autograd_benchmark": 22.183333333333334, "test_functional_optim": 0.0, "test_functionalization": 2.820666666666664, "test_functionalization_of_rng_ops": 0.009333333333333332, "test_futures": 0.973, "test_fx": 8.983999999999982, "test_fx_experimental": 17.377999999999982, "test_fx_passes": 0.6026666666666668, "test_fx_reinplace_pass": 0.448, "test_import_stats": 1.7313333333333334, "test_indexing": 0.9290000000000002, "test_itt": 0.0, "test_jit": 42.65400000000003, "test_jit_autocast": 17.438666666666666, "test_jit_cuda_fuser": 0.005, "test_jit_disabled": 0.4203333333333333, "test_jit_fuser_te": 110.80033333333336, "test_jit_llga_fuser": 0.0023333333333333335, "test_legacy_vmap": 1.0556666666666668, "test_license": 0.3826666666666667, "test_linalg": 83.34500000000013, "test_logging": 1.2616666666666665, "test_masked": 4.166666666666661, "test_maskedtensor": 2.760999999999971, "test_meta": 936.2706666666396, "test_mkl_verbose": 1.7816666666666665, "test_mkldnn": 0.002, "test_mkldnn_fusion": 0.0, "test_mkldnn_verbose": 2.0686666666666667, "test_mobile_optimizer": 0.8073333333333333, "test_model_dump": 0.3863333333333334, "test_model_exports_to_core_aten": 0.0, "test_module_init": 1.204999999999991, "test_module_tracker": 0.3416666666666666, "test_modules": 369.44200000001155, "test_monitor": 0.5116666666666667, "test_multiprocessing": 153.85733333333334, "test_multiprocessing_spawn": 10.804000000000002, "test_namedtensor": 0.7533333333333335, "test_namedtuple_return_api": 1.2573333333333334, "test_native_functions": 0.3996666666666668, "test_native_mha": 0.3196666666666667, "test_nestedtensor": 6.9266666666666685, "test_nn": 106.83766666666708, "test_numba_integration": 0.2343333333333333, "test_numpy_interop": 0.32700000000000007, "test_nvfuser_frontend": 0.0, "test_openmp": 3.237666666666667, "test_ops": 1306.2373333333062, "test_ops_fwd_gradients": 160.4293333333375, "test_ops_gradients": 530.7793333333005, "test_ops_jit": 803.6069999999991, "test_optim": 162.16500000000096, "test_out_dtype_op": 0.3076666666666667, "test_overrides": 1.8669999999999165, "test_package": 0.7550000000000002, "test_per_overload_api": 0.35033333333333333, "test_prims": 0.43366666666666664, "test_proxy_tensor": 293.59633333333574, "test_pruning_op": 0.3916666666666666, "test_public_bindings": 0.342, "test_python_dispatch": 2.8479999999999994, "test_pytree": 0.4280000000000001, "test_quantization": 366.04466666666667, "test_reductions": 94.8863333333323, "test_scatter_gather_ops": 1.6886666666666652, "test_schema_check": 320.3296666666555, "test_segment_reductions": 0.5123333333333336, "test_serialization": 31.048999999999996, "test_set_default_mobile_cpu_allocator": 0.32, "test_shape_ops": 0.9593333333333338, "test_show_pickle": 0.31866666666666665, "test_sort_and_select": 1.454333333333328, "test_sparse": 174.5229999999983, "test_sparse_csr": 113.76500000000061, "test_sparse_semi_structured": 0.0, "test_spectral_ops": 4.847999999999993, "test_stateless": 2.8313333333333333, "test_subclass": 0.4240000000000001, "test_sympy_utils": 8.620333333333333, "test_tensor_creation_ops": 14.171333333333296, "test_tensorboard": 0.8943333333333333, "test_tensorexpr": 10.915999999999999, "test_tensorexpr_pybind": 0.34400000000000003, "test_testing": 15.241333333333301, "test_torch": 11.2073333333333, "test_transformers": 163.18166666666627, "test_type_hints": 0.22899999999999998, "test_type_info": 0.35633333333333334, "test_type_promotion": 4.894999999999961, "test_typing": 0.0, "test_unary_ufuncs": 225.68266666664212, "test_utils": 58.2906666666676, "test_view_ops": 7.381999999999995, "test_vulkan": 0.0, "test_weak": 2.3899999999999992, "test_xnnpack_integration": 20.431, "torch_np/numpy_tests/core/test_dlpack": 0.0, "torch_np/numpy_tests/core/test_dtype": 0.19100000000000003, "torch_np/numpy_tests/core/test_einsum": 4.849333333333334, "torch_np/numpy_tests/core/test_getlimits": 0.3293333333333333, "torch_np/numpy_tests/core/test_indexing": 0.27533333333333343, "torch_np/numpy_tests/core/test_multiarray": 11.220666666666665, "torch_np/numpy_tests/core/test_numeric": 2.1569999999999996, "torch_np/numpy_tests/core/test_numerictypes": 0.34766666666666673, "torch_np/numpy_tests/core/test_scalar_ctors": 0.38400000000000006, "torch_np/numpy_tests/core/test_scalar_methods": 0.22533333333333336, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 9.469000000000001, "torch_np/numpy_tests/core/test_shape_base": 0.4583333333333334, "torch_np/numpy_tests/fft/test_helper": 2.3183333333333334, "torch_np/numpy_tests/fft/test_pocketfft": 1.5710000000000004, "torch_np/numpy_tests/lib/test_arraypad": 0.325, "torch_np/numpy_tests/lib/test_arraysetops": 0.14700000000000002, "torch_np/numpy_tests/lib/test_function_base": 1.0650000000000004, "torch_np/numpy_tests/lib/test_histograms": 0.5030000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.36733333333333335, "torch_np/numpy_tests/lib/test_shape_base_": 0.49233333333333346, "torch_np/numpy_tests/lib/test_twodim_base": 0.4206666666666667, "torch_np/numpy_tests/lib/test_type_check": 0.38166666666666665, "torch_np/numpy_tests/linalg/test_linalg": 3.564999999999999, "torch_np/test_basic": 0.6773333333333337, "torch_np/test_binary_ufuncs": 0.379, "torch_np/test_dtype": 0.3586666666666667, "torch_np/test_function_base": 0.3413333333333333, "torch_np/test_ndarray_methods": 1.6006666666666673, "torch_np/test_nep50_examples": 0.05733333333333335, "torch_np/test_random": 0.1363333333333334, "torch_np/test_reductions": 1.4633333333333336, "torch_np/test_scalars_0D_arrays": 0.132, "torch_np/test_ufuncs_basic": 0.8173333333333338, "torch_np/test_unary_ufuncs": 0.4040000000000001}}, "macos-12-py3-arm64-mps": {"default": {"test_metal": 0.7056666666666667, "test_modules": 93.42633333333042, "test_mps": 1166.7653333333255}, "mps": {"test_metal": 1.109, "test_modules": 895.8990000000263, "test_mps": 2421.2059999999824}}, "macos-12-py3-x86-64": {"default": {"backends/xeon/test_launch": 0.002, "benchmark_utils/test_benchmark_utils": 1.2419999999999998, "distributions/test_constraints": 0.20700000000000007, "distributions/test_distributions": 77.25499999999998, "dynamo/test_activation_checkpointing": 0.736, "dynamo/test_after_aot": 7.626, "dynamo/test_allow_inline_skip": 0.827, "dynamo/test_aot_autograd": 16.142000000000003, "dynamo/test_autograd_function": 2.4559999999999995, "dynamo/test_backends": 14.44, "dynamo/test_backward_higher_order_ops": 12.844000000000001, "dynamo/test_base_output": 0.006, "dynamo/test_bytecode_hook": 7.616, "dynamo/test_compile": 7.309, "dynamo/test_comptime": 1.018, "dynamo/test_config": 1.0, "dynamo/test_ctx_manager": 1.854999999999999, "dynamo/test_debug_utils": 0.489, "dynamo/test_decorators": 1.2109999999999999, "dynamo/test_dynamic_shapes": 1563.0159999999998, "dynamo/test_exc": 1.871, "dynamo/test_export": 23.538, "dynamo/test_export_mutations": 0.524, "dynamo/test_frame_init": 0.472, "dynamo/test_functions": 18.76799999999999, "dynamo/test_global": 1.0499999999999998, "dynamo/test_higher_order_ops": 9.321999999999996, "dynamo/test_hooks": 24.942, "dynamo/test_input_attr_tracking": 9.058, "dynamo/test_interop": 1.109, "dynamo/test_logging": 10.969999999999992, "dynamo/test_minifier": 2.185999999999999, "dynamo/test_misc": 58.898000000000074, "dynamo/test_model_output": 0.009000000000000001, "dynamo/test_modules": 13.256999999999998, "dynamo/test_nops": 0.598, "dynamo/test_optimizers": 2.8720000000000003, "dynamo/test_pre_dispatch": 1.1059999999999999, "dynamo/test_profiler": 1.9019999999999997, "dynamo/test_python_autograd": 1.2799999999999998, "dynamo/test_recompile_ux": 1.762, "dynamo/test_recompiles": 1.5729999999999997, "dynamo/test_replay_record": 0.011, "dynamo/test_repros": 38.666, "dynamo/test_skip_non_tensor": 1.0099999999999996, "dynamo/test_sources": 0.474, "dynamo/test_subclasses": 4.593999999999999, "dynamo/test_subgraphs": 2.7679999999999993, "dynamo/test_trace_rules": 1.21, "dynamo/test_triton_kernels": 0.1210000000000001, "dynamo/test_unspec": 10.144999999999996, "dynamo/test_verify_correctness": 1.312, "export/test_db": 4.087, "export/test_export": 21.753, "export/test_export_nonstrict": 16.053000000000004, "export/test_functionalized_assertions": 1.12, "export/test_funtionalized_assertions": 1.078, "export/test_pass_infra": 0.8800000000000001, "export/test_passes": 1.994, "export/test_retraceability": 26.372999999999994, "export/test_serdes": 20.581000000000003, "export/test_serialize": 5.7090000000000005, "export/test_unflatten": 1.945, "export/test_upgrade": 0.649, "export/test_verifier": 0.9830000000000002, "functorch/test_aotdispatch": 3156.548000000002, "functorch/test_control_flow": 85.62799999999997, "functorch/test_dims": 24.118000000000002, "functorch/test_eager_transforms": 22.926000000000002, "functorch/test_logging": 0.501, "functorch/test_memory_efficient_fusion": 0.7310000000000001, "functorch/test_minifier": 0.7130000000000002, "functorch/test_ops": 4733.245999999999, "functorch/test_parsing": 1.129, "functorch/test_rearrange": 0.8170000000000001, "functorch/test_vmap": 795.0249999999993, "functorch/test_vmap_registrations": 4.550999999999731, "inductor/test_benchmark_fusion": 3.5389999999999997, "inductor/test_binary_folding": 24.897000000000002, "inductor/test_codecache": 20.395000000000007, "inductor/test_codegen_triton": 0.442, "inductor/test_compiled_autograd": 128.81200000000027, "inductor/test_compiled_optimizers": 212.36500000000018, "inductor/test_config": 4.482999999999998, "inductor/test_custom_lowering": 0.003, "inductor/test_debug_trace": 2.567, "inductor/test_dependencies": 0.001, "inductor/test_efficient_conv_bn_eval": 0.002, "inductor/test_foreach": 11.557999999999915, "inductor/test_fx_fusion": 0.49000000000000005, "inductor/test_group_batch_fusion": 0.003, "inductor/test_indexing": 0.9640000000000001, "inductor/test_inductor_freezing": 20.400000000000002, "inductor/test_memory_planning": 0.002, "inductor/test_mmdecomp": 35.21, "inductor/test_profiler": 0.005, "inductor/test_standalone_compile": 5.771999999999999, "inductor/test_torchinductor": 870.7049999999996, "inductor/test_torchinductor_codegen_dynamic_shapes": 176.6250000000001, "inductor/test_torchinductor_dynamic_shapes": 795.2789999999985, "inductor/test_torchinductor_opinfo": 3541.342999999999, "lazy/test_debug_util": 1.336, "lazy/test_functionalization": 1.286, "lazy/test_generator": 1.163, "lazy/test_reuse_ir": 1.557, "lazy/test_step_closures": 3.195, "lazy/test_ts_opinfo": 10.95399999999997, "nn/test_convolution": 22.903999999999968, "nn/test_dropout": 0.943, "nn/test_embedding": 12.452000000000002, "nn/test_init": 5.921, "nn/test_lazy_modules": 1.3469999999999986, "nn/test_module_hooks": 1.0850000000000002, "nn/test_multihead_attention": 8.351, "nn/test_packed_sequence": 1.4149999999999994, "nn/test_parametrization": 1.378, "nn/test_pooling": 46.77200000000001, "nn/test_pruning": 0.8670000000000001, "profiler/test_memory_profiler": 4.7250000000000005, "profiler/test_profiler": 15.402000000000001, "profiler/test_profiler_tree": 1.2719999999999994, "test_ao_sparsity": 7.529, "test_autocast": 1.132, "test_autograd": 42.135999999999946, "test_autograd_fallback": 1.1879999999999984, "test_binary_ufuncs": 182.5970000000003, "test_bundled_inputs": 2.4619999999999993, "test_comparison_utils": 1.0729999999999997, "test_compile_benchmark_util": 0.001, "test_complex": 0.7670000000000001, "test_content_store": 6.977, "test_cpp_api_parity": 5.110999999999999, "test_cpp_extensions_aot_ninja": 0.739, "test_cpp_extensions_aot_no_ninja": 0.743, "test_cpp_extensions_jit": 217.659, "test_cpp_extensions_open_device_registration": 25.403, "test_custom_backend": 0.247, "test_custom_ops": 4.167000000000001, "test_dataloader": 1227.74, "test_datapipe": 29.489000000000004, "test_decomp": 6151.216999999982, "test_deploy": 1.028, "test_dispatch": 42.60300000000001, "test_dlpack": 0.7880000000000001, "test_dynamic_shapes": 6.470999999999998, "test_expanded_weights": 24.31899999999999, "test_fake_tensor": 1.0350000000000001, "test_flop_counter": 0.8190000000000001, "test_foreach": 294.1369999999999, "test_function_schema": 1.6299999999999997, "test_functional_autograd_benchmark": 60.281000000000006, "test_functional_optim": 0.003, "test_functionalization": 8.603, "test_functionalization_of_rng_ops": 0.017, "test_futures": 1.501, "test_fx": 16.94999999999999, "test_fx_experimental": 51.845, "test_fx_passes": 1.8899999999999981, "test_fx_reinplace_pass": 1.5659999999999996, "test_import_stats": 5.752, "test_indexing": 12.398000000000012, "test_itt": 1.086, "test_jit": 88.04999999999997, "test_jit_autocast": 47.120999999999995, "test_jit_cuda_fuser": 0.1760000000000001, "test_jit_disabled": 1.263, "test_jit_fuser_te": 360.2600000000011, "test_jit_llga_fuser": 0.021000000000000005, "test_legacy_vmap": 4.567999999999997, "test_license": 1.091, "test_linalg": 111.19899999999988, "test_logging": 4.122, "test_masked": 44.18200000000004, "test_maskedtensor": 9.399999999999995, "test_meta": 2858.442000000317, "test_mkl_verbose": 6.098, "test_mkldnn": 56.84, "test_mkldnn_fusion": 243.679, "test_mkldnn_verbose": 5.823, "test_mobile_optimizer": 2.4779999999999998, "test_model_dump": 1.4189999999999998, "test_model_exports_to_core_aten": 0.001, "test_module_init": 2.9249999999999896, "test_modules": 546.6559999999972, "test_monitor": 1.429, "test_multiprocessing": 217.25, "test_multiprocessing_spawn": 18.494, "test_namedtensor": 2.5339999999999976, "test_namedtuple_return_api": 3.252, "test_native_functions": 1.2549999999999997, "test_native_mha": 0.7490000000000002, "test_nestedtensor": 5.010999999999998, "test_nn": 144.51000000000067, "test_numba_integration": 0.48, "test_numpy_interop": 0.6290000000000001, "test_nvfuser_frontend": 0.003, "test_openmp": 7.791, "test_ops": 4639.486000000035, "test_ops_fwd_gradients": 457.7979999999839, "test_ops_gradients": 1457.2960000000096, "test_ops_jit": 1989.9519999999982, "test_optim": 139.004, "test_out_dtype_op": 0.6950000000000002, "test_overrides": 4.404999999999792, "test_package": 2.214, "test_per_overload_api": 0.89, "test_prims": 0.9820000000000001, "test_proxy_tensor": 1085.0790000000004, "test_pruning_op": 1.4629999999999999, "test_public_bindings": 7.451, "test_python_dispatch": 0.9530000000000003, "test_pytree": 1.3699999999999977, "test_quantization": 901.755, "test_reductions": 254.11799999999633, "test_scatter_gather_ops": 4.979999999999996, "test_schema_check": 842.7509999999957, "test_segment_reductions": 1.3559999999999992, "test_serialization": 46.704, "test_set_default_mobile_cpu_allocator": 0.775, "test_shape_ops": 2.879999999999998, "test_show_pickle": 1.092, "test_sort_and_select": 4.358999999999993, "test_sparse": 736.2209999999988, "test_sparse_csr": 411.758999999998, "test_sparse_semi_structured": 0.002, "test_spectral_ops": 10.751999999999994, "test_stateless": 9.187999999999997, "test_subclass": 1.3949999999999965, "test_sympy_utils": 28.502999999999997, "test_tensor_creation_ops": 39.26199999999998, "test_tensorboard": 2.481, "test_tensorexpr": 32.827999999999996, "test_tensorexpr_pybind": 1.2589999999999988, "test_testing": 42.84199999999987, "test_torch": 19.108000000000033, "test_transformers": 74.42099999999999, "test_type_hints": 0.62, "test_type_info": 1.037, "test_type_promotion": 16.591999999999967, "test_typing": 0.004, "test_unary_ufuncs": 371.9569999999135, "test_utils": 159.4580000000013, "test_view_ops": 23.86500000000003, "test_vulkan": 0.001, "test_weak": 6.108, "test_xnnpack_integration": 6.2669999999999995, "torch_np/numpy_tests/core/test_dlpack": 0.002, "torch_np/numpy_tests/core/test_dtype": 0.5810000000000001, "torch_np/numpy_tests/core/test_einsum": 20.062, "torch_np/numpy_tests/core/test_getlimits": 1.1519999999999997, "torch_np/numpy_tests/core/test_indexing": 0.9640000000000002, "torch_np/numpy_tests/core/test_multiarray": 32.149, "torch_np/numpy_tests/core/test_numeric": 5.827, "torch_np/numpy_tests/core/test_numerictypes": 0.809, "torch_np/numpy_tests/core/test_scalar_ctors": 1.349, "torch_np/numpy_tests/core/test_scalar_methods": 1.0989999999999998, "torch_np/numpy_tests/core/test_scalarinherit": 0.001, "torch_np/numpy_tests/core/test_scalarmath": 17.054, "torch_np/numpy_tests/core/test_shape_base": 1.556, "torch_np/numpy_tests/fft/test_helper": 6.180999999999999, "torch_np/numpy_tests/fft/test_pocketfft": 6.802999999999999, "torch_np/numpy_tests/lib/test_arraypad": 1.1359999999999997, "torch_np/numpy_tests/lib/test_arraysetops": 0.669, "torch_np/numpy_tests/lib/test_function_base": 3.4240000000000004, "torch_np/numpy_tests/lib/test_histograms": 1.650999999999999, "torch_np/numpy_tests/lib/test_index_tricks": 1.3449999999999995, "torch_np/numpy_tests/lib/test_shape_base_": 1.6859999999999995, "torch_np/numpy_tests/lib/test_twodim_base": 1.4529999999999996, "torch_np/numpy_tests/lib/test_type_check": 1.267, "torch_np/numpy_tests/linalg/test_linalg": 8.515, "torch_np/test_basic": 1.857999999999999, "torch_np/test_binary_ufuncs": 1.4389999999999994, "torch_np/test_dtype": 1.141, "torch_np/test_function_base": 1.153, "torch_np/test_ndarray_methods": 4.085999999999999, "torch_np/test_nep50_examples": 0.21400000000000013, "torch_np/test_random": 0.7070000000000001, "torch_np/test_reductions": 4.958999999999925, "torch_np/test_scalars_0D_arrays": 0.554, "torch_np/test_ufuncs_basic": 2.475999999999998, "torch_np/test_unary_ufuncs": 1.255}}, "macos-13-py3-arm64": {"default": {"backends/xeon/test_launch": 0.0, "benchmark_utils/test_benchmark_utils": 0.5526666666666668, "distributions/test_constraints": 0.013666666666666672, "distributions/test_distributions": 29.714333333333332, "dynamo/test_activation_checkpointing": 0.326, "dynamo/test_after_aot": 4.7026666666666666, "dynamo/test_aot_autograd": 9.415666666666665, "dynamo/test_aot_autograd_cache": 0.47633333333333344, "dynamo/test_autograd_function": 2.0099999999999993, "dynamo/test_backends": 7.325333333333333, "dynamo/test_backward_higher_order_ops": 6.411999999999999, "dynamo/test_base_output": 0.0, "dynamo/test_bytecode_hook": 4.254333333333332, "dynamo/test_bytecode_utils": 4.461666666666666, "dynamo/test_compile": 4.411333333333332, "dynamo/test_comptime": 0.512, "dynamo/test_config": 0.5499999999999999, "dynamo/test_cpp_guard_manager": 55.89233333333335, "dynamo/test_ctx_manager": 1.0063333333333337, "dynamo/test_debug_utils": 0.18000000000000002, "dynamo/test_decorators": 0.5673333333333335, "dynamo/test_deviceguard": 0.009000000000000001, "dynamo/test_dynamic_shapes": 1228.1956666666663, "dynamo/test_exc": 1.1649999999999998, "dynamo/test_export": 10.060999999999998, "dynamo/test_export_mutations": 0.5013333333333333, "dynamo/test_frame_init": 0.119, "dynamo/test_functions": 12.433666666666705, "dynamo/test_fx_passes_pre_grad": 1.0073333333333332, "dynamo/test_global": 0.7349999999999998, "dynamo/test_guard_manager": 0.15033333333333335, "dynamo/test_higher_order_ops": 14.303999999999997, "dynamo/test_hooks": 13.665000000000001, "dynamo/test_input_attr_tracking": 5.383, "dynamo/test_interop": 0.4953333333333334, "dynamo/test_logging": 9.386000000000001, "dynamo/test_minifier": 1.002, "dynamo/test_misc": 27.830333333333357, "dynamo/test_model_output": 0.0006666666666666666, "dynamo/test_modules": 7.123666666666665, "dynamo/test_nops": 0.36566666666666664, "dynamo/test_optimizers": 0.453, "dynamo/test_pre_dispatch": 0.49866666666666665, "dynamo/test_profiler": 0.7403333333333334, "dynamo/test_python_autograd": 0.5673333333333334, "dynamo/test_recompile_ux": 0.6023333333333333, "dynamo/test_recompiles": 0.6233333333333334, "dynamo/test_reorder_logs": 0.39300000000000007, "dynamo/test_repros": 25.210000000000008, "dynamo/test_resume": 0.327, "dynamo/test_sdpa": 0.4713333333333334, "dynamo/test_skip_non_tensor": 0.49, "dynamo/test_sources": 0.36566666666666664, "dynamo/test_structured_trace": 6.224, "dynamo/test_subclasses": 9.100666666666665, "dynamo/test_subgraphs": 1.6803333333333328, "dynamo/test_trace_rules": 0.9116666666666666, "dynamo/test_unspec": 7.28, "dynamo/test_verify_correctness": 0.462, "export/test_converter": 0.504, "export/test_db": 2.079, "export/test_experimental": 0.5793333333333334, "export/test_export": 20.627000000000002, "export/test_export_nonstrict": 14.21733333333333, "export/test_export_predispatch": 18.026333333333326, "export/test_functionalized_assertions": 0.37999999999999995, "export/test_hop": 1.842666666666667, "export/test_lift_unlift": 0.001, "export/test_pass_infra": 0.6790000000000002, "export/test_passes": 7.163, "export/test_retraceability": 25.837666666666664, "export/test_schema": 0.207, "export/test_serdes": 19.941, "export/test_serialize": 1.1743333333333335, "export/test_sparse": 30.878333333333376, "export/test_tools": 0.532, "export/test_torchbind": 0.001, "export/test_tree_utils": 0.122, "export/test_unflatten": 1.7023333333333335, "export/test_verifier": 0.6503333333333334, "functorch/test_aotdispatch": 1612.913333333331, "functorch/test_control_flow": 69.31099999999996, "functorch/test_dims": 13.36766666666667, "functorch/test_eager_transforms": 10.656666666666665, "functorch/test_logging": 0.16366666666666665, "functorch/test_memory_efficient_fusion": 0.4506666666666667, "functorch/test_minifier": 0.24866666666666667, "functorch/test_ops": 1250.7816666666388, "functorch/test_parsing": 0.3633333333333333, "functorch/test_rearrange": 0.38866666666666666, "functorch/test_vmap": 433.5049999999986, "functorch/test_vmap_registrations": 2.1799999999998736, "higher_order_ops/test_with_effects": 0.0, "inductor/test_aot_inductor": 559.1620000000003, "inductor/test_codecache": 18.714333333333332, "inductor/test_codegen_triton": 0.147, "inductor/test_compile_worker": 2.8539999999999996, "inductor/test_compiled_autograd": 168.85666666666677, "inductor/test_compiled_optimizers": 266.442, "inductor/test_config": 3.6706666666666656, "inductor/test_control_flow": 0.0003333333333333333, "inductor/test_custom_lowering": 0.001, "inductor/test_debug_trace": 2.308666666666667, "inductor/test_decompose_mem_bound_mm": 0.0, "inductor/test_flex_attention": 0.002, "inductor/test_foreach": 7.593333333333334, "inductor/test_fx_fusion": 0.19499999999999998, "inductor/test_group_batch_fusion": 0.11733333333333333, "inductor/test_indexing": 0.4166666666666667, "inductor/test_mmdecomp": 18.636000000000006, "inductor/test_standalone_compile": 8.493333333333334, "inductor/test_torchbind": 0.15266666666666664, "inductor/test_torchinductor": 592.018333333333, "inductor/test_torchinductor_codegen_dynamic_shapes": 589.1179999999998, "inductor/test_torchinductor_dynamic_shapes": 725.2429999999996, "inductor/test_torchinductor_opinfo": 2216.41433333333, "inductor/test_triton_kernels": 0.008000000000000002, "inductor/test_utils": 0.1433333333333333, "lazy/test_debug_util": 0.4036666666666666, "lazy/test_functionalization": 0.37266666666666665, "lazy/test_generator": 0.45166666666666666, "lazy/test_reuse_ir": 0.605, "lazy/test_step_closures": 2.4269999999999996, "lazy/test_ts_opinfo": 3.5469999999999957, "nn/test_convolution": 86.02533333333331, "nn/test_dropout": 0.4883333333333333, "nn/test_embedding": 2.5156666666666596, "nn/test_init": 3.6573333333333333, "nn/test_lazy_modules": 0.8040000000000003, "nn/test_load_state_dict": 0.6963333333333335, "nn/test_module_hooks": 0.5006666666666667, "nn/test_multihead_attention": 12.624666666666664, "nn/test_packed_sequence": 0.5066666666666667, "nn/test_parametrization": 0.7270000000000002, "nn/test_pooling": 24.752666666666673, "nn/test_pruning": 0.36466666666666675, "profiler/test_execution_trace": 0.135, "profiler/test_memory_profiler": 2.7223333333333333, "profiler/test_profiler": 17.711666666666662, "profiler/test_profiler_tree": 0.0, "profiler/test_record_function": 0.48533333333333334, "profiler/test_torch_tidy": 2.42, "test_ao_sparsity": 1.940666666666667, "test_autocast": 1.2629999999999997, "test_autograd": 21.237666666666694, "test_autograd_fallback": 0.3783333333333334, "test_binary_ufuncs": 54.7483333333363, "test_bundled_inputs": 1.4759999999999998, "test_comparison_utils": 0.5526666666666666, "test_compile_benchmark_util": 0.0, "test_complex": 0.27466666666666667, "test_content_store": 4.781333333333333, "test_cpp_extensions_aot_ninja": 0.3196666666666667, "test_cpp_extensions_aot_no_ninja": 0.3086666666666667, "test_cpp_extensions_jit": 85.16033333333334, "test_cpp_extensions_mtia_backend": 0.25666666666666665, "test_cpp_extensions_open_device_registration": 0.2373333333333333, "test_cpp_extensions_stream_and_event": 0.248, "test_custom_backend": 0.1466666666666667, "test_custom_ops": 8.673000000000014, "test_dataloader": 1072.5126666666663, "test_datapipe": 26.46733333333333, "test_decomp": 2182.708999999983, "test_deploy": 0.37000000000000005, "test_dispatch": 20.753, "test_dlpack": 0.4503333333333335, "test_dynamic_shapes": 2.9160000000000004, "test_expanded_weights": 3.271000000000001, "test_fake_tensor": 1.1553333333333333, "test_flop_counter": 0.37666666666666676, "test_foreach": 24.791333333333057, "test_function_schema": 0.6063333333333333, "test_functional_autograd_benchmark": 25.706333333333333, "test_functional_optim": 0.0, "test_functionalization": 3.518666666666663, "test_functionalization_of_rng_ops": 0.010333333333333333, "test_futures": 1.0403333333333333, "test_fx": 7.264999999999978, "test_fx_experimental": 24.617000000000008, "test_fx_passes": 0.7356666666666668, "test_fx_reinplace_pass": 0.5746666666666668, "test_import_stats": 2.421, "test_indexing": 0.9356666666666665, "test_itt": 0.0, "test_jit": 53.536, "test_jit_autocast": 23.733, "test_jit_disabled": 0.4749999999999999, "test_jit_fuser_te": 140.76400000000095, "test_jit_llga_fuser": 0.0, "test_legacy_vmap": 1.2220000000000002, "test_license": 0.37599999999999995, "test_linalg": 98.39700000000009, "test_logging": 1.7530000000000001, "test_masked": 6.953666666666662, "test_maskedtensor": 3.573666666666648, "test_meta": 652.5143333333027, "test_mkl_verbose": 2.3670000000000004, "test_mkldnn": 0.0030000000000000005, "test_mkldnn_fusion": 0.0, "test_mkldnn_verbose": 2.356333333333333, "test_mobile_optimizer": 0.678, "test_model_dump": 0.4870000000000001, "test_model_exports_to_core_aten": 0.0006666666666666666, "test_module_tracker": 0.4076666666666667, "test_modules": 458.0366666666703, "test_monitor": 0.7156666666666668, "test_multiprocessing": 158.96466666666672, "test_multiprocessing_spawn": 11.814333333333336, "test_namedtensor": 0.5280000000000001, "test_namedtuple_return_api": 1.3863333333333332, "test_native_functions": 0.5023333333333334, "test_native_mha": 0.36133333333333345, "test_nestedtensor": 7.984666666666669, "test_nn": 94.46700000000065, "test_numba_integration": 0.2823333333333333, "test_numpy_interop": 0.47366666666666674, "test_openmp": 4.230999999999999, "test_ops": 1071.7536666666447, "test_ops_fwd_gradients": 198.7676666666715, "test_ops_gradients": 321.97833333333307, "test_ops_jit": 545.0590000000005, "test_optim": 160.01233333333383, "test_out_dtype_op": 0.2803333333333333, "test_overrides": 1.867333333333251, "test_package": 0.8336666666666669, "test_per_overload_api": 0.4253333333333333, "test_prims": 0.5233333333333333, "test_proxy_tensor": 379.3476666666647, "test_pruning_op": 0.5213333333333333, "test_public_bindings": 0.429, "test_python_dispatch": 3.079, "test_pytree": 0.45100000000000007, "test_quantization": 387.27233333333334, "test_reductions": 102.9559999999987, "test_scatter_gather_ops": 2.1873333333333327, "test_schema_check": 71.67766666666797, "test_segment_reductions": 0.7086666666666671, "test_serialization": 41.36366666666667, "test_set_default_mobile_cpu_allocator": 0.39999999999999997, "test_shape_ops": 0.7116666666666668, "test_show_pickle": 0.3433333333333333, "test_sort_and_select": 1.514333333333327, "test_sparse": 193.82499999999922, "test_sparse_csr": 56.13233333333343, "test_sparse_semi_structured": 0.0003333333333333333, "test_spectral_ops": 5.684999999999991, "test_stateless": 3.209, "test_subclass": 0.4870000000000001, "test_sympy_utils": 12.737000000000004, "test_tensor_creation_ops": 10.82366666666662, "test_tensorboard": 0.9106666666666667, "test_tensorexpr": 13.155333333333331, "test_tensorexpr_pybind": 0.36933333333333335, "test_testing": 17.682999999999964, "test_torch": 6.579666666666621, "test_transformers": 234.44866666666636, "test_type_hints": 0.3016666666666667, "test_type_info": 0.3766666666666667, "test_type_promotion": 2.0229999999999904, "test_typing": 0.0, "test_unary_ufuncs": 230.20866666661755, "test_utils": 62.887666666667315, "test_view_ops": 7.140666666666674, "test_vulkan": 0.0, "test_weak": 3.0413333333333323, "test_xnnpack_integration": 18.002, "torch_np/numpy_tests/core/test_dlpack": 0.0003333333333333333, "torch_np/numpy_tests/core/test_dtype": 0.18966666666666668, "torch_np/numpy_tests/core/test_einsum": 6.159666666666667, "torch_np/numpy_tests/core/test_getlimits": 0.4143333333333333, "torch_np/numpy_tests/core/test_indexing": 0.22366666666666676, "torch_np/numpy_tests/core/test_multiarray": 15.203000000000001, "torch_np/numpy_tests/core/test_numeric": 2.7866666666666657, "torch_np/numpy_tests/core/test_numerictypes": 0.4266666666666667, "torch_np/numpy_tests/core/test_scalar_ctors": 0.4723333333333333, "torch_np/numpy_tests/core/test_scalar_methods": 0.27399999999999997, "torch_np/numpy_tests/core/test_scalarinherit": 0.0, "torch_np/numpy_tests/core/test_scalarmath": 12.415333333333331, "torch_np/numpy_tests/core/test_shape_base": 0.5496666666666669, "torch_np/numpy_tests/fft/test_helper": 3.0416666666666665, "torch_np/numpy_tests/fft/test_pocketfft": 1.782333333333333, "torch_np/numpy_tests/lib/test_arraypad": 0.41300000000000003, "torch_np/numpy_tests/lib/test_arraysetops": 0.2126666666666667, "torch_np/numpy_tests/lib/test_function_base": 1.145666666666667, "torch_np/numpy_tests/lib/test_histograms": 0.4713333333333334, "torch_np/numpy_tests/lib/test_index_tricks": 0.41733333333333333, "torch_np/numpy_tests/lib/test_shape_base_": 0.5890000000000001, "torch_np/numpy_tests/lib/test_twodim_base": 0.4856666666666667, "torch_np/numpy_tests/lib/test_type_check": 0.48833333333333345, "torch_np/numpy_tests/linalg/test_linalg": 4.134333333333331, "torch_np/test_basic": 0.8110000000000003, "torch_np/test_binary_ufuncs": 0.5373333333333333, "torch_np/test_dtype": 0.4956666666666667, "torch_np/test_function_base": 0.4686666666666666, "torch_np/test_ndarray_methods": 1.918000000000001, "torch_np/test_nep50_examples": 0.053666666666666675, "torch_np/test_random": 0.1993333333333334, "torch_np/test_reductions": 1.8933333333333193, "torch_np/test_scalars_0D_arrays": 0.1536666666666667, "torch_np/test_ufuncs_basic": 1.075666666666667, "torch_np/test_unary_ufuncs": 0.5183333333333334}}, "macos-py3-arm64": {"default": {"backends/xeon/test_launch": 0.0, "benchmark_utils/test_benchmark_utils": 0.20566666666666666, "distributions/test_constraints": 0.008, "distributions/test_distributions": 25.617333333333335, "dynamo/test_activation_checkpointing": 0.44166666666666665, "dynamo/test_after_aot": 4.332, "dynamo/test_aot_autograd": 7.355999999999999, "dynamo/test_aot_autograd_cache": 8.340333333333334, "dynamo/test_autograd_function": 2.022, "dynamo/test_backends": 8.39, "dynamo/test_backward_higher_order_ops": 7.438333333333333, "dynamo/test_base_output": 0.0, "dynamo/test_bytecode_utils": 4.278666666666667, "dynamo/test_compile": 5.4959999999999996, "dynamo/test_comptime": 0.4913333333333334, "dynamo/test_config": 0.413, "dynamo/test_ctx_manager": 0.8590000000000004, "dynamo/test_debug_utils": 0.14666666666666664, "dynamo/test_decorators": 4.2926666666666655, "dynamo/test_deviceguard": 0.052333333333333336, "dynamo/test_dynamic_shapes": 520.0013333333333, "dynamo/test_exc": 1.4333333333333333, "dynamo/test_exceptions": 0.3763333333333334, "dynamo/test_export": 10.229666666666661, "dynamo/test_export_mutations": 0.5156666666666667, "dynamo/test_frame_init": 0.143, "dynamo/test_functions": 19.948666666666686, "dynamo/test_fx_passes_pre_grad": 1.1356666666666666, "dynamo/test_global": 0.387, "dynamo/test_guard_manager": 0.20100000000000004, "dynamo/test_higher_order_ops": 11.988999999999995, "dynamo/test_hooks": 14.077333333333337, "dynamo/test_inline_inbuilt_nn_modules": 71.37866666666675, "dynamo/test_input_attr_tracking": 5.397333333333333, "dynamo/test_interop": 0.4043333333333334, "dynamo/test_logging": 9.178666666666667, "dynamo/test_minifier": 0.8716666666666667, "dynamo/test_misc": 35.7676666666667, "dynamo/test_model_output": 0.0006666666666666666, "dynamo/test_modules": 9.985999999999997, "dynamo/test_nops": 0.31233333333333335, "dynamo/test_optimizers": 0.47833333333333333, "dynamo/test_pre_dispatch": 0.41533333333333333, "dynamo/test_profiler": 0.8756666666666667, "dynamo/test_python_autograd": 0.6546666666666668, "dynamo/test_recompile_ux": 0.5830000000000001, "dynamo/test_recompiles": 0.5656666666666669, "dynamo/test_reorder_logs": 0.37100000000000005, "dynamo/test_repros": 23.072999999999997, "dynamo/test_resume": 0.38400000000000006, "dynamo/test_sdpa": 0.34500000000000003, "dynamo/test_skip_non_tensor": 0.38599999999999995, "dynamo/test_sources": 0.3473333333333333, "dynamo/test_structured_trace": 7.531999999999999, "dynamo/test_subclasses": 8.588, "dynamo/test_subgraphs": 1.2729999999999995, "dynamo/test_trace_rules": 0.9113333333333333, "dynamo/test_unspec": 7.976666666666667, "dynamo/test_verify_correctness": 0.39566666666666667, "dynamo/test_view": 0.4443333333333333, "export/test_converter": 4.196000000000001, "export/test_db": 1.6216666666666661, "export/test_experimental": 0.5466666666666667, "export/test_export": 18.137999999999995, "export/test_export_nonstrict": 17.127, "export/test_functionalized_assertions": 0.139, "export/test_hop": 1.6233333333333333, "export/test_lift_unlift": 0.0013333333333333333, "export/test_pass_infra": 0.6476666666666667, "export/test_passes": 5.514666666666667, "export/test_retraceability": 23.458333333333332, "export/test_schema": 0.19366666666666665, "export/test_serdes": 19.480333333333334, "export/test_serialize": 1.0340000000000005, "export/test_sparse": 27.66700000000007, "export/test_tools": 0.38799999999999996, "export/test_torchbind": 0.001, "export/test_tree_utils": 0.15966666666666665, "export/test_unflatten": 2.2553333333333336, "export/test_verifier": 0.6790000000000002, "functorch/test_aotdispatch": 1523.2469999999983, "functorch/test_control_flow": 60.99933333333332, "functorch/test_dims": 15.339, "functorch/test_eager_transforms": 9.120666666666667, "functorch/test_logging": 0.164, "functorch/test_memory_efficient_fusion": 0.444, "functorch/test_minifier": 0.29433333333333334, "functorch/test_ops": 1099.3726666666569, "functorch/test_parsing": 0.15300000000000002, "functorch/test_rearrange": 0.16933333333333334, "functorch/test_vmap": 337.9393333333323, "functorch/test_vmap_registrations": 1.8609999999999072, "higher_order_ops/test_with_effects": 0.0, "inductor/test_aot_inductor": 538.797, "inductor/test_codecache": 17.953666666666667, "inductor/test_codegen_triton": 0.14866666666666664, "inductor/test_compile_worker": 4.076333333333333, "inductor/test_compiled_autograd": 222.0460000000004, "inductor/test_compiled_optimizers": 350.7703333333334, "inductor/test_config": 3.705999999999998, "inductor/test_control_flow": 0.058666666666666666, "inductor/test_custom_lowering": 0.001, "inductor/test_debug_trace": 2.430333333333333, "inductor/test_decompose_mem_bound_mm": 0.0003333333333333333, "inductor/test_flex_attention": 0.001, "inductor/test_foreach": 8.470666666666665, "inductor/test_fx_fusion": 0.1386666666666667, "inductor/test_group_batch_fusion": 0.11733333333333335, "inductor/test_indexing": 0.38933333333333336, "inductor/test_mmdecomp": 0.0, "inductor/test_standalone_compile": 9.953, "inductor/test_torchbind": 0.15866666666666665, "inductor/test_torchinductor": 749.2503333333328, "inductor/test_torchinductor_codegen_dynamic_shapes": 671.5829999999997, "inductor/test_torchinductor_dynamic_shapes": 780.4936666666666, "inductor/test_torchinductor_opinfo": 11340.254666666677, "inductor/test_triton_kernels": 0.010333333333333335, "inductor/test_utils": 0.151, "lazy/test_debug_util": 0.16633333333333333, "lazy/test_functionalization": 0.18400000000000002, "lazy/test_generator": 0.17066666666666666, "lazy/test_reuse_ir": 0.39066666666666666, "lazy/test_step_closures": 2.1769999999999996, "lazy/test_ts_opinfo": 3.2403333333333286, "nn/test_convolution": 64.85966666666663, "nn/test_dropout": 0.168, "nn/test_embedding": 1.9826666666666597, "nn/test_init": 3.0786666666666656, "nn/test_lazy_modules": 0.34066666666666673, "nn/test_load_state_dict": 0.30800000000000005, "nn/test_module_hooks": 0.1026666666666667, "nn/test_multihead_attention": 10.783333333333333, "nn/test_packed_sequence": 0.22433333333333336, "nn/test_parametrization": 0.3223333333333334, "nn/test_pooling": 15.170999999999998, "nn/test_pruning": 0.06600000000000003, "profiler/test_execution_trace": 0.10433333333333335, "profiler/test_memory_profiler": 2.2070000000000003, "profiler/test_profiler": 15.813999999999998, "profiler/test_profiler_tree": 0.0, "profiler/test_record_function": 0.15533333333333335, "profiler/test_torch_tidy": 1.9123333333333334, "test_ao_sparsity": 1.6669999999999998, "test_autocast": 0.49266666666666664, "test_autograd": 19.473999999999986, "test_autograd_fallback": 0.17333333333333337, "test_binary_ufuncs": 49.88433333333678, "test_bundled_inputs": 1.2013333333333331, "test_comparison_utils": 0.14200000000000002, "test_compile_benchmark_util": 0.0, "test_complex": 0.025000000000000005, "test_content_store": 3.81, "test_cpp_extensions_aot_ninja": 0.09200000000000001, "test_cpp_extensions_aot_no_ninja": 0.07266666666666667, "test_cpp_extensions_jit": 89.66133333333333, "test_cpp_extensions_mtia_backend": 0.0, "test_cpp_extensions_open_device_registration": 0.0013333333333333333, "test_cpp_extensions_stream_and_event": 0.0, "test_custom_backend": 0.15433333333333335, "test_custom_ops": 11.946333333333351, "test_dataloader": 937.0263333333332, "test_datapipe": 25.40833333333333, "test_decomp": 1984.5389999999845, "test_deploy": 0.14933333333333335, "test_dispatch": 22.031333333333336, "test_dlpack": 0.1300000000000001, "test_dynamic_shapes": 3.238333333333332, "test_expanded_weights": 2.776333333333334, "test_fake_tensor": 1.0640000000000003, "test_flop_counter": 0.09133333333333336, "test_foreach": 23.966333333333107, "test_function_schema": 0.28400000000000003, "test_functional_autograd_benchmark": 22.523333333333337, "test_functional_optim": 0.0, "test_functionalization": 2.642999999999999, "test_functionalization_of_rng_ops": 0.01, "test_futures": 0.786, "test_fx": 6.523666666666649, "test_fx_experimental": 18.89699999999999, "test_fx_passes": 0.4246666666666668, "test_fx_reinplace_pass": 0.23066666666666671, "test_import_stats": 1.9323333333333332, "test_indexing": 0.6826666666666666, "test_itt": 0.0, "test_jit": 47.30600000000002, "test_jit_autocast": 17.013, "test_jit_disabled": 0.25033333333333335, "test_jit_fuser_te": 120.20366666666696, "test_jit_llga_fuser": 0.001, "test_legacy_vmap": 0.8423333333333335, "test_license": 0.14733333333333334, "test_linalg": 75.19366666666653, "test_logging": 1.2263333333333333, "test_masked": 5.028333333333327, "test_maskedtensor": 2.9106666666666636, "test_meta": 517.5819999998895, "test_mkl_verbose": 1.8463333333333332, "test_mkldnn": 0.002, "test_mkldnn_fusion": 0.0, "test_mkldnn_verbose": 1.7953333333333334, "test_mobile_optimizer": 0.4723333333333333, "test_model_dump": 0.2106666666666667, "test_model_exports_to_core_aten": 0.0003333333333333333, "test_module_tracker": 0.1446666666666667, "test_modules": 355.4190000000079, "test_monitor": 0.496, "test_multiprocessing": 160.2146666666667, "test_multiprocessing_spawn": 13.973333333333334, "test_namedtensor": 0.18566666666666676, "test_namedtuple_return_api": 1.048, "test_native_functions": 0.22400000000000006, "test_native_mha": 0.10333333333333335, "test_nestedtensor": 10.359000000000004, "test_nn": 76.83999999999958, "test_numba_integration": 0.041666666666666664, "test_numpy_interop": 0.1056666666666667, "test_openmp": 3.8023333333333333, "test_ops": 1019.8073333333132, "test_ops_fwd_gradients": 200.49833333333706, "test_ops_gradients": 391.1559999999909, "test_ops_jit": 536.1909999999998, "test_optim": 137.75966666666702, "test_out_dtype_op": 0.274, "test_overrides": 1.6716666666666065, "test_package": 0.6133333333333335, "test_per_overload_api": 0.15366666666666665, "test_prims": 0.14100000000000001, "test_proxy_tensor": 320.79566666666227, "test_pruning_op": 0.20366666666666666, "test_public_bindings": 0.17366666666666666, "test_python_dispatch": 3.0083333333333333, "test_pytree": 0.28233333333333344, "test_quantization": 430.90299999999985, "test_reductions": 83.18900000000514, "test_scatter_gather_ops": 1.5430000000000004, "test_schema_check": 61.14533333333484, "test_segment_reductions": 0.33633333333333354, "test_serialization": 58.12033333333334, "test_set_default_mobile_cpu_allocator": 0.154, "test_shape_ops": 0.35100000000000015, "test_show_pickle": 0.19033333333333333, "test_sort_and_select": 1.1136666666666653, "test_sparse": 154.07300000000012, "test_sparse_csr": 55.81766666666667, "test_sparse_semi_structured": 0.0003333333333333333, "test_spectral_ops": 2.9033333333333275, "test_stateless": 3.0380000000000003, "test_subclass": 0.28100000000000014, "test_sympy_utils": 8.775333333333329, "test_tensor_creation_ops": 9.372000000000003, "test_tensorboard": 0.7416666666666667, "test_tensorexpr": 10.241333333333332, "test_tensorexpr_pybind": 0.17233333333333334, "test_testing": 20.221666666666653, "test_torch": 5.362999999999938, "test_transformers": 159.92999999999984, "test_type_hints": 0.0003333333333333333, "test_type_info": 0.16033333333333336, "test_type_promotion": 1.3489999999999978, "test_typing": 0.0, "test_unary_ufuncs": 163.22400000001608, "test_utils": 59.60266666666748, "test_view_ops": 5.86600000000001, "test_vulkan": 0.0, "test_weak": 2.4253333333333322, "test_xnnpack_integration": 10.411, "torch_np/numpy_tests/core/test_dlpack": 0.0003333333333333333, "torch_np/numpy_tests/core/test_dtype": 0.20400000000000004, "torch_np/numpy_tests/core/test_einsum": 5.869666666666666, "torch_np/numpy_tests/core/test_getlimits": 0.11766666666666668, "torch_np/numpy_tests/core/test_indexing": 0.2193333333333334, "torch_np/numpy_tests/core/test_multiarray": 11.506666666666666, "torch_np/numpy_tests/core/test_numeric": 2.1929999999999996, "torch_np/numpy_tests/core/test_numerictypes": 0.12733333333333335, "torch_np/numpy_tests/core/test_scalar_ctors": 0.18400000000000005, "torch_np/numpy_tests/core/test_scalar_methods": 0.0016666666666666668, "torch_np/numpy_tests/core/test_scalarinherit": 0.0003333333333333333, "torch_np/numpy_tests/core/test_scalarmath": 10.293333333333331, "torch_np/numpy_tests/core/test_shape_base": 0.28333333333333344, "torch_np/numpy_tests/fft/test_helper": 2.235333333333333, "torch_np/numpy_tests/fft/test_pocketfft": 1.483666666666667, "torch_np/numpy_tests/lib/test_arraypad": 0.14833333333333334, "torch_np/numpy_tests/lib/test_arraysetops": 0.1616666666666667, "torch_np/numpy_tests/lib/test_function_base": 0.9153333333333338, "torch_np/numpy_tests/lib/test_histograms": 0.2653333333333334, "torch_np/numpy_tests/lib/test_index_tricks": 0.23700000000000002, "torch_np/numpy_tests/lib/test_shape_base_": 0.29866666666666675, "torch_np/numpy_tests/lib/test_twodim_base": 0.21333333333333337, "torch_np/numpy_tests/lib/test_type_check": 0.16333333333333336, "torch_np/numpy_tests/linalg/test_linalg": 3.438666666666666, "torch_np/test_basic": 0.44766666666666693, "torch_np/test_binary_ufuncs": 0.19233333333333338, "torch_np/test_dtype": 0.1413333333333334, "torch_np/test_function_base": 0.122, "torch_np/test_ndarray_methods": 1.8190000000000008, "torch_np/test_nep50_examples": 0.02233333333333334, "torch_np/test_random": 0.21933333333333338, "torch_np/test_reductions": 1.5486666666666522, "torch_np/test_scalars_0D_arrays": 0.17366666666666672, "torch_np/test_ufuncs_basic": 0.5973333333333336, "torch_np/test_unary_ufuncs": 0.18800000000000006}}, "macos-py3-arm64-mps": {"mps": {"test_metal": 1.1053333333333333, "test_modules": 1139.4930000000015, "test_mps": 2175.6303333333276}}, "parallelnative-linux-jammy-py3.8-gcc11": {"default": {"backends/xeon/test_launch": 2.3979999999999997, "benchmark_utils/test_benchmark_utils": 0.56, "distributions/test_constraints": 0.14700000000000008, "distributions/test_distributions": 89.154, "dynamo/test_activation_checkpointing": 0.901, "dynamo/test_after_aot": 7.525499999999999, "dynamo/test_allow_inline_skip": 0.6599999999999999, "dynamo/test_aot_autograd": 20.646500000000003, "dynamo/test_aot_autograd_cache": 8.545, "dynamo/test_autograd_function": 4.3614999999999995, "dynamo/test_backends": 20.311999999999998, "dynamo/test_backward_higher_order_ops": 17.7255, "dynamo/test_base_output": 0.0055, "dynamo/test_bytecode_hook": 6.179, "dynamo/test_bytecode_utils": 8.685, "dynamo/test_compile": 10.018, "dynamo/test_comptime": 1.1590000000000003, "dynamo/test_config": 0.968, "dynamo/test_cpp_guard_manager": 114.89600000000006, "dynamo/test_ctx_manager": 1.9175, "dynamo/test_debug_utils": 0.406, "dynamo/test_decorators": 9.445999999999998, "dynamo/test_deviceguard": 0.022, "dynamo/test_dynamic_shapes": 642.122, "dynamo/test_exc": 3.066, "dynamo/test_exceptions": 0.8665, "dynamo/test_export": 23.446000000000005, "dynamo/test_export_mutations": 0.8680000000000001, "dynamo/test_frame_init": 0.385, "dynamo/test_functions": 42.47050000000005, "dynamo/test_fx_passes_pre_grad": 2.059, "dynamo/test_global": 0.8585, "dynamo/test_guard_manager": 0.40700000000000003, "dynamo/test_higher_order_ops": 28.463499999999996, "dynamo/test_hooks": 35.749, "dynamo/test_inline_inbuilt_nn_modules": 145.31300000000007, "dynamo/test_input_attr_tracking": 11.179, "dynamo/test_interop": 0.942, "dynamo/test_logging": 24.188, "dynamo/test_minifier": 2.1559999999999997, "dynamo/test_misc": 84.76600000000015, "dynamo/test_model_output": 0.006, "dynamo/test_modules": 26.823499999999996, "dynamo/test_nops": 0.5165, "dynamo/test_optimizers": 1.0390000000000001, "dynamo/test_pre_dispatch": 0.7875000000000001, "dynamo/test_profiler": 2.0694999999999997, "dynamo/test_python_autograd": 1.0010000000000003, "dynamo/test_recompile_ux": 1.2685000000000004, "dynamo/test_recompiles": 1.3365000000000002, "dynamo/test_reorder_logs": 0.8275000000000001, "dynamo/test_replay_record": 0.8423333333333334, "dynamo/test_repros": 60.699999999999996, "dynamo/test_resume": 0.6975, "dynamo/test_sdpa": 0.7595000000000001, "dynamo/test_skip_non_tensor": 0.8600000000000001, "dynamo/test_sources": 0.789, "dynamo/test_structured_trace": 21.451, "dynamo/test_subclasses": 20.064999999999998, "dynamo/test_subgraphs": 3.4844999999999993, "dynamo/test_trace_rules": 1.9280000000000002, "dynamo/test_triton_kernels": 0.060500000000000026, "dynamo/test_unspec": 18.755, "dynamo/test_verify_correctness": 0.9065, "dynamo/test_view": 0.9809999999999999, "export/test_converter": 7.186, "export/test_db": 4.522, "export/test_experimental": 1.572, "export/test_export": 45.384, "export/test_export_nonstrict": 36.70999999999998, "export/test_export_predispatch": 27.57999999999999, "export/test_functionalized_assertions": 0.3775, "export/test_funtionalized_assertions": 0.713, "export/test_hop": 3.9370000000000003, "export/test_lift_unlift": 0.135, "export/test_pass_infra": 1.3135000000000003, "export/test_passes": 19.036, "export/test_retraceability": 66.8605, "export/test_safeguard": 0.7909999999999999, "export/test_schema": 0.42099999999999993, "export/test_serdes": 43.05099999999998, "export/test_serialize": 13.836500000000004, "export/test_sparse": 85.11349999999989, "export/test_tools": 0.8420000000000001, "export/test_torchbind": 4.0184999999999995, "export/test_tree_utils": 0.357, "export/test_unflatten": 4.812000000000001, "export/test_upgrade": 0.45400000000000007, "export/test_verifier": 1.4235000000000002, "functorch/test_aotdispatch": 3612.003999999997, "functorch/test_control_flow": 161.32049999999992, "functorch/test_dims": 40.906499999999994, "functorch/test_eager_transforms": 25.388, "functorch/test_logging": 0.4445, "functorch/test_memory_efficient_fusion": 0.9929999999999999, "functorch/test_minifier": 0.6699999999999999, "functorch/test_ops": 4457.550999999965, "functorch/test_parsing": 0.403, "functorch/test_rearrange": 0.44600000000000006, "functorch/test_vmap": 721.5519999999967, "functorch/test_vmap_registrations": 3.279999999999838, "higher_order_ops/test_with_effects": 8.6575, "inductor/test_benchmark_fusion": 11.8925, "inductor/test_binary_folding": 50.4905, "inductor/test_codecache": 62.455499999999994, "inductor/test_codegen_triton": 0.3785, "inductor/test_compile_worker": 10.011, "inductor/test_compiled_autograd": 677.0760000000005, "inductor/test_compiled_optimizers": 1078.395, "inductor/test_config": 8.2145, "inductor/test_control_flow": 0.014000000000000002, "inductor/test_cpp_wrapper": 1129.428, "inductor/test_cpu_cpp_wrapper": 3376.647, "inductor/test_cpu_repro": 910.7455, "inductor/test_cpu_select_algorithm": 2828.4135, "inductor/test_custom_lowering": 0.0045000000000000005, "inductor/test_custom_post_grad_passes": 15.178999999999998, "inductor/test_debug_trace": 4.4265, "inductor/test_decompose_mem_bound_mm": 0.0035, "inductor/test_dependencies": 0.001, "inductor/test_distributed_patterns": 48.47950000000001, "inductor/test_efficient_conv_bn_eval": 0.0015, "inductor/test_extension_backend": 25.955, "inductor/test_flex_attention": 0.020500000000000008, "inductor/test_foreach": 23.28999999999999, "inductor/test_fused_attention": 215.18699999999998, "inductor/test_fx_fusion": 0.3985, "inductor/test_graph_transform_observer": 0.0215, "inductor/test_group_batch_fusion": 0.271, "inductor/test_indexing": 0.998, "inductor/test_inductor_freezing": 74.8305, "inductor/test_memory_planning": 0.0003333333333333333, "inductor/test_minifier": 34.592, "inductor/test_minifier_isolate": 67.4925, "inductor/test_mkldnn_pattern_matcher": 1030.4395, "inductor/test_mmdecomp": 57.042000000000044, "inductor/test_profiler": 0.004666666666666667, "inductor/test_standalone_compile": 24.5865, "inductor/test_templated_attention": 0.005, "inductor/test_torchbind": 13.5075, "inductor/test_torchinductor": 2076.2095000000004, "inductor/test_torchinductor_codegen_dynamic_shapes": 2055.1429999999987, "inductor/test_torchinductor_dynamic_shapes": 2139.421499999999, "inductor/test_torchinductor_opinfo": 7616.550499999987, "inductor/test_triton_extension_backend": 0.8714999999999999, "inductor/test_triton_kernels": 0.09650000000000006, "inductor/test_utils": 0.381, "lazy/test_debug_util": 0.4235, "lazy/test_functionalization": 0.45299999999999996, "lazy/test_generator": 0.4465, "lazy/test_reuse_ir": 0.793, "lazy/test_step_closures": 3.38, "lazy/test_ts_opinfo": 9.673999999999946, "nn/test_convolution": 41.80550000000001, "nn/test_dropout": 0.537, "nn/test_embedding": 7.450499999999991, "nn/test_init": 5.771499999999999, "nn/test_lazy_modules": 0.7505000000000004, "nn/test_load_state_dict": 0.8685, "nn/test_module_hooks": 0.31550000000000006, "nn/test_multihead_attention": 6.865, "nn/test_packed_sequence": 0.6130000000000001, "nn/test_parametrization": 1.1455000000000002, "nn/test_pooling": 50.51049999999999, "nn/test_pruning": 0.14200000000000007, "profiler/test_execution_trace": 0.147, "profiler/test_memory_profiler": 5.914, "profiler/test_profiler": 35.437, "profiler/test_profiler_tree": 0.5035000000000001, "profiler/test_record_function": 0.41950000000000004, "profiler/test_torch_tidy": 5.0074999999999985, "test_ao_sparsity": 9.273999999999997, "test_autocast": 1.6534999999999997, "test_autograd": 50.71499999999995, "test_autograd_fallback": 0.4965000000000001, "test_binary_ufuncs": 129.43950000000606, "test_bundled_inputs": 1.5110000000000001, "test_comparison_utils": 0.3935, "test_compile_benchmark_util": 0.0015, "test_complex": 0.08850000000000001, "test_content_store": 8.065, "test_cpp_api_parity": 4.6624999999999845, "test_cpp_extensions_aot_ninja": 0.05350000000000002, "test_cpp_extensions_aot_no_ninja": 0.05450000000000001, "test_cpp_extensions_jit": 60.434, "test_cpp_extensions_mtia_backend": 1.124, "test_cpp_extensions_open_device_registration": 11.646999999999998, "test_cpp_extensions_stream_and_event": 1.0955, "test_custom_backend": 0.10999999999999999, "test_custom_ops": 11.614499999999992, "test_dataloader": 261.64250000000004, "test_datapipe": 14.950999999999999, "test_decomp": 5961.310499999996, "test_deploy": 0.382, "test_dispatch": 40.275499999999994, "test_dlpack": 0.23600000000000015, "test_dynamic_shapes": 6.492999999999992, "test_expanded_weights": 12.049999999999995, "test_fake_tensor": 2.74, "test_flop_counter": 0.7805, "test_foreach": 72.3555000000004, "test_function_schema": 0.779, "test_functional_autograd_benchmark": 62.4165, "test_functional_optim": 0.5475000000000001, "test_functionalization": 6.979999999999997, "test_functionalization_of_rng_ops": 0.025500000000000002, "test_futures": 1.3555000000000001, "test_fx": 436.6054999999998, "test_fx_experimental": 82.3235, "test_fx_passes": 1.0315000000000003, "test_fx_reinplace_pass": 0.6230000000000002, "test_import_stats": 4.297, "test_indexing": 2.805999999999998, "test_itt": 0.375, "test_jit": 111.71650000000001, "test_jit_autocast": 34.267500000000005, "test_jit_cuda_fuser": 0.021000000000000005, "test_jit_disabled": 0.591, "test_jit_fuser_te": 231.79000000000133, "test_jit_llga_fuser": 41.24750000000001, "test_legacy_vmap": 2.7035000000000005, "test_license": 0.3625, "test_linalg": 198.7309999999993, "test_logging": 2.9, "test_masked": 19.9845, "test_maskedtensor": 7.123999999999981, "test_meta": 1996.94949999984, "test_mkl_verbose": 5.086, "test_mkldnn": 205.51099999999997, "test_mkldnn_fusion": 108.6935, "test_mkldnn_verbose": 4.3309999999999995, "test_mobile_optimizer": 3.5350000000000006, "test_model_dump": 1.2545, "test_model_exports_to_core_aten": 0.379, "test_module_init": 2.122999999999992, "test_module_tracker": 0.406, "test_modules": 757.9724999999926, "test_monitor": 0.665, "test_multiprocessing": 66.598, "test_multiprocessing_spawn": 35.1085, "test_namedtensor": 0.4545000000000001, "test_namedtuple_return_api": 2.501, "test_native_functions": 0.5495000000000001, "test_native_mha": 0.30450000000000016, "test_nestedtensor": 25.921500000000005, "test_nn": 222.42200000000076, "test_numba_integration": 0.007, "test_numpy_interop": 0.2165000000000001, "test_nvfuser_frontend": 0.0, "test_openmp": 6.78, "test_ops": 2635.238499999982, "test_ops_fwd_gradients": 896.7930000000104, "test_ops_gradients": 1117.5425000000205, "test_ops_jit": 1082.8974999999996, "test_optim": 58.129000000000026, "test_out_dtype_op": 0.501, "test_overrides": 2.901999999999882, "test_package": 3.3599999999999985, "test_per_overload_api": 0.43650000000000005, "test_prims": 0.30450000000000005, "test_proxy_tensor": 857.7640000000013, "test_pruning_op": 0.6120000000000001, "test_public_bindings": 8.9485, "test_python_dispatch": 0.9325000000000002, "test_pytree": 0.6415000000000002, "test_quantization": 2207.6545, "test_reductions": 310.15400000000534, "test_scatter_gather_ops": 5.8145000000000024, "test_schema_check": 216.78549999999933, "test_segment_reductions": 1.3875000000000004, "test_serialization": 47.917, "test_set_default_mobile_cpu_allocator": 0.381, "test_shape_ops": 1.3335000000000001, "test_show_pickle": 0.393, "test_sort_and_select": 3.005499999999995, "test_sparse": 692.7925000000005, "test_sparse_csr": 194.32499999999993, "test_sparse_semi_structured": 0.0045000000000000005, "test_spectral_ops": 9.774999999999975, "test_stateless": 6.4544999999999995, "test_subclass": 0.5965000000000003, "test_sympy_utils": 20.347499999999993, "test_tensor_creation_ops": 33.79400000000008, "test_tensorboard": 54.013000000000005, "test_tensorexpr": 68.04399999999997, "test_tensorexpr_pybind": 1.2140000000000004, "test_testing": 44.43100000000004, "test_torch": 18.890000000000086, "test_transformers": 492.0079999999988, "test_type_hints": 0.3825, "test_type_info": 0.3695, "test_type_promotion": 4.5419999999999785, "test_typing": 99.74499999999999, "test_unary_ufuncs": 482.38949999986335, "test_utils": 53.07200000000111, "test_view_ops": 19.03950000000002, "test_vulkan": 0.0015, "test_weak": 5.915499999999998, "test_xnnpack_integration": 12.032999999999998, "torch_np/numpy_tests/core/test_dlpack": 0.003, "torch_np/numpy_tests/core/test_dtype": 0.6685000000000001, "torch_np/numpy_tests/core/test_einsum": 18.762500000000003, "torch_np/numpy_tests/core/test_getlimits": 0.42750000000000005, "torch_np/numpy_tests/core/test_indexing": 0.6570000000000001, "torch_np/numpy_tests/core/test_multiarray": 34.728000000000016, "torch_np/numpy_tests/core/test_numeric": 5.648999999999999, "torch_np/numpy_tests/core/test_numerictypes": 0.43550000000000005, "torch_np/numpy_tests/core/test_scalar_ctors": 0.4845000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.4295, "torch_np/numpy_tests/core/test_scalarinherit": 0.0015, "torch_np/numpy_tests/core/test_scalarmath": 29.880000000000003, "torch_np/numpy_tests/core/test_shape_base": 0.7305000000000003, "torch_np/numpy_tests/fft/test_helper": 7.354, "torch_np/numpy_tests/fft/test_pocketfft": 5.11, "torch_np/numpy_tests/lib/test_arraypad": 0.3935, "torch_np/numpy_tests/lib/test_arraysetops": 0.587, "torch_np/numpy_tests/lib/test_function_base": 2.618500000000001, "torch_np/numpy_tests/lib/test_histograms": 0.7890000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.5395000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.9530000000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.7215, "torch_np/numpy_tests/lib/test_type_check": 0.5095000000000001, "torch_np/numpy_tests/linalg/test_linalg": 5.8245000000000005, "torch_np/test_basic": 0.7950000000000006, "torch_np/test_binary_ufuncs": 0.5040000000000001, "torch_np/test_dtype": 0.5130000000000001, "torch_np/test_function_base": 0.3975, "torch_np/test_ndarray_methods": 3.1710000000000016, "torch_np/test_nep50_examples": 0.05000000000000002, "torch_np/test_random": 0.4615, "torch_np/test_reductions": 3.388999999999932, "torch_np/test_scalars_0D_arrays": 0.45050000000000007, "torch_np/test_ufuncs_basic": 1.5300000000000007, "torch_np/test_unary_ufuncs": 0.5580000000000002}}, "rocm5.7-py3.8-inductor": {"inductor": {"distributed/test_dynamo_distributed": 58.022000000000006, "distributed/test_inductor_collectives": 81.827, "inductor/test_torchinductor": 543.3529999999996, "inductor/test_torchinductor_opinfo": 1212.5229999999901, "test_modules": 587.7499999999693, "test_ops": 1812.7359999995488, "test_ops_gradients": 851.9289999999404, "test_torch": 619.2749999999968}}, "rocm6.0-py3.8-inductor": {"inductor": {"distributed/test_dynamo_distributed": 92.57099999999998, "distributed/test_inductor_collectives": 98.93900000000001, "inductor/test_aot_inductor": 4566.091999999997, "inductor/test_torchinductor": 1184.0969999999995, "inductor/test_torchinductor_opinfo": 3775.0340000000156, "test_modules": 1048.3729999999416, "test_ops": 2476.0879999994713, "test_ops_gradients": 891.1819999999655, "test_torch": 1815.0509999999986}}, "rocm6.1-py3.8-inductor": {"inductor": {"distributed/_composable/fsdp/test_fully_shard_clip_grad_norm_": 25.955, "distributed/_composable/fsdp/test_fully_shard_comm": 184.949, "distributed/_composable/fsdp/test_fully_shard_frozen": 70.587, "distributed/_composable/fsdp/test_fully_shard_mixed_precision": 47.1465, "distributed/_composable/fsdp/test_fully_shard_training": 426.381, "distributed/_tensor/test_dtensor_compile": 113.328, "distributed/fsdp/test_fsdp_tp_integration": 56.487500000000004, "distributed/tensor/parallel/test_fsdp_2d_parallel": 165.65750000000003, "distributed/test_c10d_functional_native": 174.988, "distributed/test_dynamo_distributed": 175.4865, "distributed/test_inductor_collectives": 190.41199999999998, "inductor/test_aot_inductor": 7213.283999999998, "inductor/test_torchinductor": 4412.835499999997, "inductor/test_torchinductor_opinfo": 34215.78650000017, "test_modules": 2491.499000000026, "test_ops": 3331.127499999435, "test_ops_gradients": 1971.667999999885, "test_torch": 2376.3255000000004}}, "win-vs2019-cpu-py3": {"default": {"backends/xeon/test_launch": 0.002, "benchmark_utils/test_benchmark_utils": 0.644, "distributions/test_constraints": 0.08950000000000007, "distributions/test_distributions": 65.57133333333333, "export/test_converter": 7.006333333333334, "export/test_db": 0.007666666666666666, "export/test_export": 2.318, "export/test_functionalized_assertions": 0.36366666666666664, "export/test_funtionalized_assertions": 1.7043333333333333, "export/test_hop": 0.01766666666666667, "export/test_lift_unlift": 0.119, "export/test_pass_infra": 0.7643333333333332, "export/test_passes": 15.373333333333333, "export/test_safeguard": 1.4323333333333332, "export/test_schema": 0.37399999999999994, "export/test_serialize": 2.199333333333333, "export/test_sparse": 84.42266666666667, "export/test_tools": 0.6670000000000001, "export/test_torchbind": 3.624333333333333, "export/test_tree_utils": 0.3383333333333334, "export/test_unflatten": 4.229333333333333, "export/test_upgrade": 1.106333333333333, "export/test_verifier": 0.9596666666666666, "functorch/test_aotdispatch": 3842.8543333333328, "functorch/test_control_flow": 0.15133333333333335, "functorch/test_dims": 32.967666666666666, "functorch/test_eager_transforms": 25.066666666666666, "functorch/test_logging": 0.43733333333333335, "functorch/test_memory_efficient_fusion": 0.7793333333333333, "functorch/test_minifier": 0.6010000000000001, "functorch/test_ops": 4050.8613333333556, "functorch/test_parsing": 0.3873333333333333, "functorch/test_rearrange": 0.45533333333333337, "functorch/test_vmap": 581.2996666666651, "functorch/test_vmap_registrations": 4.421999999999834, "higher_order_ops/test_with_effects": 0.8163333333333335, "inductor/test_fx_fusion": 0.38566666666666666, "lazy/test_debug_util": 0.001, "lazy/test_functionalization": 0.4703333333333333, "lazy/test_generator": 0.46166666666666667, "lazy/test_reuse_ir": 0.0026666666666666666, "lazy/test_step_closures": 2.408666666666667, "lazy/test_ts_opinfo": 10.176333333333313, "nn/test_convolution": 28.668999999999972, "nn/test_dropout": 0.39166666666666666, "nn/test_embedding": 7.8219999999999965, "nn/test_init": 179.18633333333332, "nn/test_lazy_modules": 0.4613333333333336, "nn/test_load_state_dict": 0.911, "nn/test_module_hooks": 0.3146666666666667, "nn/test_multihead_attention": 7.127666666666666, "nn/test_packed_sequence": 0.6446666666666667, "nn/test_parametrization": 1.0739999999999996, "nn/test_pooling": 43.80766666666667, "nn/test_pruning": 0.1443333333333334, "profiler/test_execution_trace": 0.8443333333333332, "profiler/test_memory_profiler": 6.871333333333332, "profiler/test_profiler": 22.209999999999997, "profiler/test_profiler_tree": 0.49633333333333346, "profiler/test_record_function": 0.3980000000000001, "profiler/test_torch_tidy": 4.206333333333332, "test_ao_sparsity": 11.100333333333333, "test_autocast": 1.4866666666666664, "test_autograd": 52.666, "test_autograd_fallback": 0.4666666666666668, "test_binary_ufuncs": 156.8500000000043, "test_bundled_inputs": 1.4639999999999997, "test_comparison_utils": 0.38566666666666666, "test_compile_benchmark_util": 0.001, "test_complex": 0.08, "test_content_store": 0.001, "test_cpp_api_parity": 5.859666666666683, "test_cpp_extensions_aot_ninja": 0.054666666666666676, "test_cpp_extensions_aot_no_ninja": 0.055000000000000014, "test_cpp_extensions_jit": 230.43633333333335, "test_cpp_extensions_mtia_backend": 0.005, "test_cpp_extensions_open_device_registration": 16.373, "test_cpp_extensions_stream_and_event": 0.001, "test_custom_backend": 0.10133333333333333, "test_custom_ops": 25.29600000000003, "test_dataloader": 509.70799999999986, "test_datapipe": 13.031999999999998, "test_decomp": 7348.932333333334, "test_deploy": 0.36766666666666664, "test_dispatch": 53.27066666666666, "test_dlpack": 0.34366666666666695, "test_dynamic_shapes": 6.478333333333329, "test_expanded_weights": 10.742999999999997, "test_fake_tensor": 2.818333333333334, "test_flop_counter": 0.16500000000000004, "test_foreach": 115.9670000000009, "test_function_schema": 0.862, "test_functional_autograd_benchmark": 0.002, "test_functional_optim": 0.458, "test_functionalization": 5.500333333333333, "test_futures": 1.0306666666666666, "test_fx": 16.226666666666613, "test_fx_experimental": 53.71933333333332, "test_fx_passes": 0.8686666666666669, "test_fx_reinplace_pass": 0.5676666666666668, "test_import_stats": 4.796333333333333, "test_indexing": 1.8013333333333303, "test_itt": 0.323, "test_jit": 113.73900000000009, "test_jit_autocast": 11.603, "test_jit_cuda_fuser": 0.7980000000000002, "test_jit_disabled": 0.5946666666666666, "test_jit_fuser_te": 371.50066666666606, "test_jit_llga_fuser": 0.04933333333333336, "test_legacy_vmap": 3.015666666666666, "test_license": 0.002, "test_linalg": 252.38499999999712, "test_logging": 2.9443333333333332, "test_masked": 18.286333333333307, "test_maskedtensor": 10.891333333333288, "test_meta": 1896.6109999999064, "test_mkl_verbose": 5.367, "test_mkldnn": 49.422333333333334, "test_mkldnn_fusion": 202.9023333333333, "test_mkldnn_verbose": 4.858666666666667, "test_mobile_optimizer": 0.9803333333333333, "test_model_dump": 0.46966666666666673, "test_model_exports_to_core_aten": 0.001, "test_module_init": 2.7769999999999913, "test_module_tracker": 0.38033333333333336, "test_modules": 664.7283333333345, "test_monitor": 1.0466666666666666, "test_multiprocessing": 676.9986666666665, "test_multiprocessing_spawn": 33.98133333333333, "test_namedtensor": 0.5013333333333336, "test_namedtuple_return_api": 2.2103333333333333, "test_native_functions": 0.5120000000000001, "test_native_mha": 0.3663333333333334, "test_nestedtensor": 4.171333333333332, "test_nn": 203.65066666666655, "test_numba_integration": 0.008, "test_numpy_interop": 0.2686666666666668, "test_nvfuser_frontend": 0.003, "test_openmp": 4.908666666666667, "test_ops": 2898.650333333256, "test_ops_fwd_gradients": 802.0413333333187, "test_ops_gradients": 1471.626333333348, "test_ops_jit": 1281.017999999998, "test_optim": 52.064000000000085, "test_out_dtype_op": 0.32866666666666666, "test_overrides": 3.525999999999875, "test_package": 1.2510000000000001, "test_per_overload_api": 0.37566666666666676, "test_prims": 0.33433333333333337, "test_proxy_tensor": 853.1943333333237, "test_pruning_op": 0.584, "test_public_bindings": 0.4076666666666666, "test_python_dispatch": 5.646333333333334, "test_pytree": 0.5936666666666668, "test_quantization": 927.7173333333334, "test_reductions": 279.7903333333151, "test_scatter_gather_ops": 6.9529999999999985, "test_schema_check": 227.1523333333304, "test_segment_reductions": 1.1850000000000003, "test_serialization": 134.19600000000005, "test_set_default_mobile_cpu_allocator": 0.3706666666666667, "test_shape_ops": 1.2313333333333325, "test_show_pickle": 0.001, "test_sort_and_select": 2.8219999999999956, "test_sparse": 738.4699999999997, "test_sparse_csr": 200.23566666666784, "test_sparse_semi_structured": 0.0030000000000000005, "test_spectral_ops": 22.378333333333334, "test_stateless": 9.649666666666667, "test_subclass": 0.6216666666666669, "test_sympy_utils": 18.913, "test_tensor_creation_ops": 32.063999999999986, "test_tensorboard": 1.42, "test_tensorexpr": 29.93466666666667, "test_tensorexpr_pybind": 0.4043333333333334, "test_testing": 29.89366666666665, "test_torch": 19.988000000000042, "test_transformers": 401.25533333333243, "test_type_hints": 0.001, "test_type_info": 0.34600000000000003, "test_type_promotion": 4.309333333333316, "test_typing": 0.0030000000000000005, "test_unary_ufuncs": 553.5973333331558, "test_utils": 114.53800000000062, "test_view_ops": 16.663, "test_vulkan": 0.001, "test_weak": 4.274333333333333, "test_xnnpack_integration": 44.16566666666666, "torch_np/numpy_tests/core/test_dlpack": 0.03200000000000002, "torch_np/numpy_tests/core/test_dtype": 0.5846666666666668, "torch_np/numpy_tests/core/test_einsum": 16.155666666666665, "torch_np/numpy_tests/core/test_getlimits": 0.414, "torch_np/numpy_tests/core/test_indexing": 0.717666666666667, "torch_np/numpy_tests/core/test_multiarray": 35.15266666666667, "torch_np/numpy_tests/core/test_numeric": 5.901666666666666, "torch_np/numpy_tests/core/test_numerictypes": 0.49366666666666675, "torch_np/numpy_tests/core/test_scalar_ctors": 0.5823333333333335, "torch_np/numpy_tests/core/test_scalar_methods": 0.021, "torch_np/numpy_tests/core/test_scalarinherit": 0.0026666666666666666, "torch_np/numpy_tests/core/test_scalarmath": 28.14333333333333, "torch_np/numpy_tests/core/test_shape_base": 0.725666666666667, "torch_np/numpy_tests/fft/test_helper": 6.583666666666666, "torch_np/numpy_tests/fft/test_pocketfft": 4.555666666666666, "torch_np/numpy_tests/lib/test_arraypad": 0.38133333333333336, "torch_np/numpy_tests/lib/test_arraysetops": 0.6033333333333334, "torch_np/numpy_tests/lib/test_function_base": 2.493666666666667, "torch_np/numpy_tests/lib/test_histograms": 0.689666666666667, "torch_np/numpy_tests/lib/test_index_tricks": 0.5300000000000001, "torch_np/numpy_tests/lib/test_shape_base_": 0.8666666666666668, "torch_np/numpy_tests/lib/test_twodim_base": 0.6393333333333334, "torch_np/numpy_tests/lib/test_type_check": 0.5440000000000002, "torch_np/numpy_tests/linalg/test_linalg": 10.645666666666665, "torch_np/test_basic": 1.1830000000000007, "torch_np/test_binary_ufuncs": 0.5373333333333334, "torch_np/test_dtype": 0.4646666666666668, "torch_np/test_function_base": 0.3953333333333333, "torch_np/test_ndarray_methods": 4.885999999999996, "torch_np/test_nep50_examples": 0.46533333333333365, "torch_np/test_random": 0.45500000000000007, "torch_np/test_reductions": 3.810666666666638, "torch_np/test_scalars_0D_arrays": 0.4603333333333334, "torch_np/test_ufuncs_basic": 1.575000000000001, "torch_np/test_unary_ufuncs": 0.5420000000000001}}, "win-vs2019-cuda11.8-py3": {"default": {"backends/xeon/test_launch": 0.0025, "benchmark_utils/test_benchmark_utils": 5.072499999999999, "distributions/test_distributions": 113.77250000000001, "export/test_converter": 10.495, "export/test_db": 0.0095, "export/test_export": 5.224500000000001, "export/test_functionalized_assertions": 2.4185, "export/test_funtionalized_assertions": 3.3289999999999997, "export/test_hop": 2.066, "export/test_lift_unlift": 2.225, "export/test_pass_infra": 3.6715, "export/test_passes": 23.055, "export/test_safeguard": 0.969, "export/test_schema": 2.5974999999999997, "export/test_serialize": 5.1530000000000005, "export/test_sparse": 113.36900000000006, "export/test_tools": 3.2655, "export/test_torchbind": 7.116999999999999, "export/test_tree_utils": 2.4505, "export/test_unflatten": 7.006499999999999, "export/test_upgrade": 1.1219999999999999, "export/test_verifier": 3.494499999999999, "functorch/test_aotdispatch": 54.55250000000001, "functorch/test_control_flow": 0.08150000000000004, "functorch/test_dims": 41.6045, "functorch/test_eager_transforms": 17.820499999999996, "functorch/test_logging": 2.566, "functorch/test_memory_efficient_fusion": 12.9965, "functorch/test_minifier": 2.745, "functorch/test_ops": 7228.1579999999885, "functorch/test_parsing": 2.6145, "functorch/test_rearrange": 2.5194999999999994, "functorch/test_vmap": 663.5429999999994, "functorch/test_vmap_registrations": 7.956999999999571, "higher_order_ops/test_with_effects": 3.308, "inductor/test_fx_fusion": 1.6769999999999996, "lazy/test_debug_util": 0.0015, "lazy/test_functionalization": 2.5815, "lazy/test_generator": 2.885, "lazy/test_reuse_ir": 0.0025, "lazy/test_step_closures": 5.808, "lazy/test_ts_opinfo": 0.623, "nn/test_convolution": 143.3460000000009, "nn/test_dropout": 2.9885, "nn/test_embedding": 39.27999999999999, "nn/test_init": 267.6310000000001, "nn/test_lazy_modules": 2.5629999999999953, "nn/test_load_state_dict": 3.208999999999997, "nn/test_module_hooks": 2.359499999999999, "nn/test_multihead_attention": 13.181, "nn/test_packed_sequence": 2.7404999999999995, "nn/test_parametrization": 5.061999999999998, "nn/test_pooling": 11.043999999999993, "nn/test_pruning": 2.2274999999999974, "profiler/test_execution_trace": 2.2304999999999997, "profiler/test_memory_profiler": 11.0195, "profiler/test_profiler": 40.602000000000004, "profiler/test_profiler_tree": 2.5509999999999993, "profiler/test_record_function": 2.9815, "profiler/test_torch_tidy": 8.4835, "test_ao_sparsity": 21.149499999999996, "test_autocast": 10.8385, "test_autograd": 77.37150000000015, "test_autograd_fallback": 0.6995000000000002, "test_binary_ufuncs": 372.447500000005, "test_bundled_inputs": 3.964999999999999, "test_comparison_utils": 2.4735, "test_compile_benchmark_util": 0.0015, "test_complex": 2.7885, "test_content_store": 0.0025, "test_cpp_api_parity": 27.272499999999997, "test_cpp_extensions_aot_ninja": 2.2809999999999993, "test_cpp_extensions_aot_no_ninja": 2.2349999999999994, "test_cpp_extensions_jit": 412.876, "test_cpp_extensions_mtia_backend": 0.0075, "test_cpp_extensions_open_device_registration": 25.605000000000004, "test_cpp_extensions_stream_and_event": 0.0015, "test_cuda": 201.57650000000007, "test_cuda_expandable_segments": 309.7834999999997, "test_cuda_multigpu": 2.942499999999995, "test_cuda_nvml_based_avail": 0.11900000000000002, "test_cuda_primary_ctx": 0.0045000000000000005, "test_cuda_sanitizer": 2.6169999999999995, "test_cuda_trace": 13.261499999999998, "test_custom_backend": 0.1705, "test_custom_ops": 63.586000000000055, "test_dataloader": 1190.638, "test_datapipe": 24.0655, "test_decomp": 14994.85200000001, "test_deploy": 3.4154999999999998, "test_dispatch": 94.53199999999998, "test_dlpack": 3.115499999999993, "test_dynamic_shapes": 10.128, "test_expanded_weights": 28.991, "test_fake_tensor": 51.34500000000001, "test_flop_counter": 2.1819999999999986, "test_foreach": 567.0159999999992, "test_function_schema": 3.072999999999998, "test_functional_autograd_benchmark": 0.003, "test_functional_optim": 2.792, "test_functionalization": 9.659999999999998, "test_futures": 3.4639999999999995, "test_fx": 22.50449999999996, "test_fx_experimental": 12.014999999999961, "test_fx_passes": 3.609499999999997, "test_fx_reinplace_pass": 2.8589999999999995, "test_import_stats": 9.109, "test_indexing": 5.968499999999993, "test_itt": 2.442, "test_jit": 182.40650000000014, "test_jit_autocast": 63.790499999999994, "test_jit_cuda_fuser": 1455.1580000000006, "test_jit_disabled": 0.8674999999999999, "test_jit_fuser_legacy": 0.008, "test_jit_fuser_te": 1103.1365000000023, "test_jit_legacy": 191.06000000000014, "test_jit_llga_fuser": 0.025500000000000002, "test_jiterator": 41.4999999999999, "test_legacy_vmap": 7.594, "test_license": 0.003, "test_linalg": 509.2569999999996, "test_logging": 5.751, "test_masked": 49.61250000000007, "test_maskedtensor": 28.185499999999948, "test_matmul_cuda": 151.357, "test_meta": 4431.801999999678, "test_mkl_verbose": 9.1485, "test_mkldnn": 39.41200000000002, "test_mkldnn_fusion": 276.42600000000004, "test_mkldnn_verbose": 9.189499999999999, "test_mobile_optimizer": 1.4889999999999999, "test_model_dump": 2.6504999999999996, "test_model_exports_to_core_aten": 0.0015, "test_module_init": 4.007999999999968, "test_module_tracker": 2.4535, "test_modules": 1914.9424999999924, "test_monitor": 3.1205, "test_multiprocessing": 1052.0105, "test_multiprocessing_spawn": 53.019499999999994, "test_namedtensor": 5.250999999999994, "test_namedtuple_return_api": 3.4890000000000003, "test_native_functions": 2.8054999999999994, "test_native_mha": 4.2395000000000005, "test_nestedtensor": 9.892499999999988, "test_nn": 421.9020000000125, "test_numba_integration": 2.854999999999999, "test_numpy_interop": 2.395999999999998, "test_nvfuser_frontend": 6.976999999999999, "test_openmp": 9.0475, "test_ops": 10401.081999999915, "test_ops_fwd_gradients": 1808.378999999981, "test_ops_gradients": 2546.084499999935, "test_ops_jit": 2112.7829999999976, "test_optim": 536.9174999999992, "test_out_dtype_op": 2.9579999999999997, "test_overrides": 5.275499999999821, "test_package": 3.623, "test_per_overload_api": 2.4479999999999995, "test_prims": 3.3120000000000003, "test_proxy_tensor": 11.895999999999997, "test_pruning_op": 2.6855, "test_public_bindings": 2.4619999999999997, "test_python_dispatch": 15.092499999999998, "test_pytree": 2.937499999999997, "test_quantization": 1661.5899999999997, "test_reductions": 183.1445000000012, "test_scatter_gather_ops": 44.214999999999996, "test_schema_check": 752.1984999999945, "test_segment_reductions": 7.594999999999997, "test_serialization": 81.8545, "test_set_default_mobile_cpu_allocator": 2.4255, "test_shape_ops": 4.296999999999993, "test_show_pickle": 0.0015, "test_sort_and_select": 8.69899999999999, "test_sparse": 908.0565000000001, "test_sparse_csr": 511.1740000000008, "test_sparse_semi_structured": 0.24700000000000016, "test_spectral_ops": 44.67850000000004, "test_stateless": 14.532499999999995, "test_subclass": 2.7979999999999956, "test_sympy_utils": 28.531999999999996, "test_tensor_creation_ops": 141.37599999999946, "test_tensorboard": 4.0729999999999995, "test_tensorexpr": 117.26850000000002, "test_tensorexpr_pybind": 2.5184999999999977, "test_testing": 41.98849999999998, "test_torch": 399.2730000000008, "test_transformers": 556.3450000000355, "test_type_hints": 0.0015, "test_type_info": 2.44, "test_type_promotion": 21.550500000000117, "test_typing": 0.0045000000000000005, "test_unary_ufuncs": 1524.8699999998287, "test_utils": 149.8609999999992, "test_view_ops": 29.07549999999997, "test_vulkan": 0.0015, "test_weak": 8.424, "test_xnnpack_integration": 17.4355, "torch_np/numpy_tests/core/test_dlpack": 0.017, "torch_np/numpy_tests/core/test_dtype": 2.771999999999996, "torch_np/numpy_tests/core/test_einsum": 24.152500000000003, "torch_np/numpy_tests/core/test_getlimits": 2.4725, "torch_np/numpy_tests/core/test_indexing": 2.7284999999999955, "torch_np/numpy_tests/core/test_multiarray": 56.752, "torch_np/numpy_tests/core/test_numeric": 9.361999999999998, "torch_np/numpy_tests/core/test_numerictypes": 2.55, "torch_np/numpy_tests/core/test_scalar_ctors": 2.6295, "torch_np/numpy_tests/core/test_scalar_methods": 0.0315, "torch_np/numpy_tests/core/test_scalarinherit": 0.0025, "torch_np/numpy_tests/core/test_scalarmath": 42.4285, "torch_np/numpy_tests/core/test_shape_base": 3.0994999999999995, "torch_np/numpy_tests/fft/test_helper": 11.504, "torch_np/numpy_tests/fft/test_pocketfft": 7.494499999999999, "torch_np/numpy_tests/lib/test_arraypad": 2.6224999999999996, "torch_np/numpy_tests/lib/test_arraysetops": 2.6704999999999997, "torch_np/numpy_tests/lib/test_function_base": 5.496, "torch_np/numpy_tests/lib/test_histograms": 2.925999999999998, "torch_np/numpy_tests/lib/test_index_tricks": 2.6329999999999996, "torch_np/numpy_tests/lib/test_shape_base_": 3.0895, "torch_np/numpy_tests/lib/test_twodim_base": 2.9614999999999996, "torch_np/numpy_tests/lib/test_type_check": 2.6764999999999994, "torch_np/numpy_tests/linalg/test_linalg": 14.9475, "torch_np/test_basic": 5.0325, "torch_np/test_binary_ufuncs": 2.4529999999999945, "torch_np/test_dtype": 2.5435, "torch_np/test_function_base": 2.449, "torch_np/test_ndarray_methods": 8.578999999999997, "torch_np/test_nep50_examples": 0.5525000000000003, "torch_np/test_random": 2.592, "torch_np/test_reductions": 6.841499999999951, "torch_np/test_scalars_0D_arrays": 2.5744999999999996, "torch_np/test_ufuncs_basic": 4.030499999999998, "torch_np/test_unary_ufuncs": 2.538999999999995}, "force_on_cpu": {"backends/xeon/test_launch": 0.003, "benchmark_utils/test_benchmark_utils": 0.9240000000000002, "distributions/test_distributions": 97.99699999999999, "export/test_converter": 6.628499999999999, "export/test_db": 0.019500000000000007, "export/test_export": 3.031, "export/test_functionalized_assertions": 0.47050000000000003, "export/test_funtionalized_assertions": 1.5499999999999998, "export/test_hop": 0.0085, "export/test_lift_unlift": 0.163, "export/test_pass_infra": 1.4255, "export/test_passes": 20.280499999999996, "export/test_safeguard": 0.9299999999999999, "export/test_schema": 0.552, "export/test_serialize": 2.9475, "export/test_sparse": 115.015, "export/test_tools": 1.3215, "export/test_torchbind": 4.99, "export/test_tree_utils": 0.47750000000000004, "export/test_unflatten": 4.955500000000001, "export/test_upgrade": 1.0289999999999997, "export/test_verifier": 1.576, "functorch/test_aotdispatch": 47.982, "functorch/test_control_flow": 0.054000000000000034, "functorch/test_dims": 39.937, "functorch/test_eager_transforms": 0.24200000000000005, "functorch/test_logging": 0.542, "functorch/test_memory_efficient_fusion": 1.5364999999999998, "functorch/test_minifier": 0.8300000000000001, "functorch/test_parsing": 0.5465, "functorch/test_rearrange": 0.5815000000000001, "functorch/test_vmap": 5.345499999999992, "functorch/test_vmap_registrations": 6.850999999999748, "higher_order_ops/test_with_effects": 1.2695000000000003, "inductor/test_fx_fusion": 0.35100000000000003, "lazy/test_debug_util": 0.0015, "lazy/test_functionalization": 0.573, "lazy/test_generator": 0.6074999999999999, "lazy/test_reuse_ir": 0.003, "lazy/test_step_closures": 3.4825, "lazy/test_ts_opinfo": 0.652, "nn/test_convolution": 30.475500000000004, "nn/test_dropout": 0.139, "nn/test_embedding": 0.13150000000000006, "nn/test_init": 240.67749999999992, "nn/test_lazy_modules": 0.5900000000000003, "nn/test_load_state_dict": 1.2175000000000002, "nn/test_module_hooks": 0.40750000000000003, "nn/test_multihead_attention": 9.7045, "nn/test_packed_sequence": 0.8315000000000001, "nn/test_parametrization": 1.4895, "nn/test_pooling": 1.1975, "nn/test_pruning": 0.21850000000000008, "profiler/test_execution_trace": 0.41350000000000003, "profiler/test_memory_profiler": 8.167000000000002, "profiler/test_profiler": 31.4925, "profiler/test_profiler_tree": 0.6505000000000001, "profiler/test_record_function": 0.539, "profiler/test_torch_tidy": 5.1754999999999995, "test_ao_sparsity": 13.9255, "test_autocast": 3.2959999999999994, "test_autograd": 65.9525, "test_autograd_fallback": 0.6680000000000001, "test_bundled_inputs": 2.079999999999999, "test_comparison_utils": 0.48350000000000004, "test_compile_benchmark_util": 0.0015, "test_cpp_api_parity": 8.184000000000012, "test_cpp_extensions_aot_ninja": 0.07750000000000001, "test_cpp_extensions_aot_no_ninja": 0.07700000000000001, "test_cpp_extensions_jit": 338.1355, "test_cpp_extensions_mtia_backend": 0.0075, "test_cpp_extensions_open_device_registration": 23.981, "test_cpp_extensions_stream_and_event": 0.0015, "test_custom_backend": 0.15000000000000002, "test_custom_ops": 29.453999999999997, "test_dataloader": 732.5319999999999, "test_datapipe": 17.918499999999998, "test_decomp": 0.314, "test_deploy": 0.4625, "test_dispatch": 79.6875, "test_dynamic_shapes": 11.084999999999992, "test_fake_tensor": 3.7030000000000003, "test_flop_counter": 0.3480000000000001, "test_function_schema": 1.0525, "test_functional_autograd_benchmark": 0.003, "test_functional_optim": 0.6765, "test_functionalization": 7.725999999999999, "test_futures": 1.4480000000000002, "test_fx": 15.730499999999978, "test_fx_experimental": 3.1439999999999992, "test_fx_passes": 1.2350000000000003, "test_fx_reinplace_pass": 0.8065, "test_import_stats": 6.349, "test_itt": 0.477, "test_jit": 156.9160000000001, "test_jit_autocast": 16.252499999999998, "test_jit_cuda_fuser": 0.7960000000000002, "test_jit_disabled": 0.8654999999999999, "test_jit_fuser_te": 486.2980000000001, "test_jit_llga_fuser": 0.053000000000000026, "test_legacy_vmap": 3.6824999999999974, "test_license": 0.003, "test_logging": 3.5700000000000003, "test_maskedtensor": 1.484500000000001, "test_meta": 0.11200000000000004, "test_mkl_verbose": 6.750500000000001, "test_mkldnn": 36.767999999999994, "test_mkldnn_fusion": 294.697, "test_mkldnn_verbose": 6.927, "test_mobile_optimizer": 1.4445, "test_model_dump": 0.7100000000000001, "test_model_exports_to_core_aten": 0.0015, "test_module_tracker": 0.492, "test_monitor": 1.1840000000000002, "test_multiprocessing": 946.8289999999998, "test_multiprocessing_spawn": 47.67550000000001, "test_namedtensor": 0.7150000000000003, "test_namedtuple_return_api": 3.205, "test_native_functions": 0.6880000000000002, "test_nestedtensor": 0.2825000000000002, "test_nn": 79.00550000000004, "test_numba_integration": 0.012, "test_nvfuser_frontend": 0.010000000000000002, "test_openmp": 6.733499999999999, "test_ops": 0.0075, "test_optim": 2.237999999999998, "test_out_dtype_op": 0.8190000000000001, "test_overrides": 5.136499999999811, "test_package": 1.7100000000000004, "test_per_overload_api": 0.478, "test_prims": 0.024, "test_proxy_tensor": 7.652999999999999, "test_pruning_op": 0.718, "test_public_bindings": 0.489, "test_python_dispatch": 7.803000000000001, "test_pytree": 0.8530000000000002, "test_quantization": 1145.4465000000005, "test_schema_check": 0.27400000000000013, "test_serialization": 75.19749999999999, "test_set_default_mobile_cpu_allocator": 0.46599999999999997, "test_show_pickle": 0.0015, "test_sparse": 6.291500000000001, "test_sparse_csr": 0.8375, "test_sparse_semi_structured": 0.0045000000000000005, "test_stateless": 11.9465, "test_subclass": 0.8105000000000002, "test_sympy_utils": 24.174999999999997, "test_tensorboard": 1.904, "test_tensorexpr": 46.445499999999996, "test_tensorexpr_pybind": 0.524, "test_testing": 9.445999999999998, "test_torch": 6.855999999999981, "test_type_hints": 0.0015, "test_type_info": 0.48450000000000004, "test_typing": 0.008, "test_utils": 74.665, "test_vulkan": 0.0015, "test_weak": 5.885999999999999, "test_xnnpack_integration": 13.2025, "torch_np/numpy_tests/core/test_dlpack": 0.017, "torch_np/numpy_tests/core/test_dtype": 0.7455000000000002, "torch_np/numpy_tests/core/test_einsum": 22.434500000000003, "torch_np/numpy_tests/core/test_getlimits": 0.514, "torch_np/numpy_tests/core/test_indexing": 0.8230000000000002, "torch_np/numpy_tests/core/test_multiarray": 44.8815, "torch_np/numpy_tests/core/test_numeric": 7.895499999999998, "torch_np/numpy_tests/core/test_numerictypes": 0.573, "torch_np/numpy_tests/core/test_scalar_ctors": 0.6665000000000001, "torch_np/numpy_tests/core/test_scalar_methods": 0.04750000000000001, "torch_np/numpy_tests/core/test_scalarinherit": 0.003, "torch_np/numpy_tests/core/test_scalarmath": 38.07599999999999, "torch_np/numpy_tests/core/test_shape_base": 1.0850000000000004, "torch_np/numpy_tests/fft/test_helper": 8.819999999999999, "torch_np/numpy_tests/fft/test_pocketfft": 6.045999999999999, "torch_np/numpy_tests/lib/test_arraypad": 0.517, "torch_np/numpy_tests/lib/test_arraysetops": 0.7090000000000001, "torch_np/numpy_tests/lib/test_function_base": 3.6784999999999997, "torch_np/numpy_tests/lib/test_histograms": 1.0430000000000001, "torch_np/numpy_tests/lib/test_index_tricks": 0.649, "torch_np/numpy_tests/lib/test_shape_base_": 1.1685000000000003, "torch_np/numpy_tests/lib/test_twodim_base": 0.8570000000000001, "torch_np/numpy_tests/lib/test_type_check": 0.687, "torch_np/numpy_tests/linalg/test_linalg": 13.436500000000002, "torch_np/test_basic": 1.428000000000001, "torch_np/test_binary_ufuncs": 0.6075000000000002, "torch_np/test_dtype": 0.4735000000000001, "torch_np/test_function_base": 0.47250000000000003, "torch_np/test_ndarray_methods": 6.657499999999995, "torch_np/test_nep50_examples": 0.6330000000000005, "torch_np/test_random": 0.6225, "torch_np/test_reductions": 5.0474999999999515, "torch_np/test_scalars_0D_arrays": 0.5805000000000001, "torch_np/test_ufuncs_basic": 2.1770000000000014, "torch_np/test_unary_ufuncs": 0.6730000000000003}}} \ No newline at end of file diff --git a/.gitignore b/.gitignore index bfb3013c6d191..8f3efefd5220d 100644 --- a/.gitignore +++ b/.gitignore @@ -14,7 +14,6 @@ coverage.xml .gradle .hypothesis .mypy_cache -.additional_ci_files /.extracted_scripts/ **/.pytorch_specified_test_cases.csv **/.pytorch-disabled-tests.json From 0c5d257cddc14326c47da5a63c054404485807c9 Mon Sep 17 00:00:00 2001 From: wenchenvincent <32376000+wenchenvincent@users.noreply.github.com> Date: Tue, 14 Feb 2023 02:34:42 -0600 Subject: [PATCH 52/57] Sync updates from hipify_torch. (#1168) Co-authored-by: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> --- torch/utils/hipify/constants.py | 3 ++- torch/utils/hipify/cuda_to_hip_mappings.py | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/torch/utils/hipify/constants.py b/torch/utils/hipify/constants.py index a9053b261ad44..302cf487a85da 100644 --- a/torch/utils/hipify/constants.py +++ b/torch/utils/hipify/constants.py @@ -59,4 +59,5 @@ API_PYTORCH = 1337 API_CAFFE2 = 1338 API_C10 = 1339 -API_ROCMSMI = 1340 +API_PYT_EXT = 1340 +API_ROCMSMI = 1341 diff --git a/torch/utils/hipify/cuda_to_hip_mappings.py b/torch/utils/hipify/cuda_to_hip_mappings.py index 32ba13a4d7efe..7adfc4fc5d899 100644 --- a/torch/utils/hipify/cuda_to_hip_mappings.py +++ b/torch/utils/hipify/cuda_to_hip_mappings.py @@ -621,6 +621,7 @@ ("cub/device/device_select.cuh", ("hipcub/hipcub.hpp", CONV_INCLUDE, API_BLAS)), ("nvToolsExt.h", ("roctracer/roctx.h", CONV_INCLUDE, API_ROCTX)), ("nvml.h", ("rocm_smi/rocm_smi.h", CONV_INCLUDE, API_ROCMSMI)), + ("tensorpipe/tensorpipe_cuda.h", ("tensorpipe/tensorpipe_hip.h", CONV_INCLUDE, API_PYT_EXT)), ] ) From ecf4e8dd907e8b7d629ff1490233def8c0c99c4a Mon Sep 17 00:00:00 2001 From: Dmitry Nikolaev Date: Thu, 20 Jun 2024 22:22:07 +0000 Subject: [PATCH 53/57] fix install_centos() function --- .ci/docker/common/install_rocm.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.ci/docker/common/install_rocm.sh b/.ci/docker/common/install_rocm.sh index a52e4a830547d..0f8d6e0df749d 100644 --- a/.ci/docker/common/install_rocm.sh +++ b/.ci/docker/common/install_rocm.sh @@ -125,7 +125,7 @@ install_centos() { rocprofiler-dev \ roctracer-dev \ amd-smi-lib - + fi # precompiled miopen kernels; search for all unversioned packages # if search fails it will abort this script; use true to avoid case where search fails MIOPENHIPGFX=$(yum -q search miopen-hip-gfx | grep miopen-hip-gfx | awk '{print $1}'| grep -F kdb. || true) From 5de711cfe30d33c740ac6194aaca228453bcc4cd Mon Sep 17 00:00:00 2001 From: Jithun Nair <37884920+jithunnair-amd@users.noreply.github.com> Date: Thu, 27 Jun 2024 16:08:53 -0500 Subject: [PATCH 54/57] Update apex commit to pick up wheel-related changes (#1443) --- related_commits | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/related_commits b/related_commits index 1ae893a29ee9a..d04c114cabbed 100644 --- a/related_commits +++ b/related_commits @@ -1,5 +1,5 @@ -ubuntu|pytorch|apex|master|a4d9af3e08152db491057f9a59a017c37b985694|https://github.com/ROCm/apex -centos|pytorch|apex|master|a4d9af3e08152db491057f9a59a017c37b985694|https://github.com/ROCm/apex +ubuntu|pytorch|apex|master|35c34749428f77ab7c5dea8cf9ae78399deb0ddc|https://github.com/ROCm/apex +centos|pytorch|apex|master|35c34749428f77ab7c5dea8cf9ae78399deb0ddc|https://github.com/ROCm/apex ubuntu|pytorch|torchvision|main|bf01bab6125c5f1152e4f336b470399e52a8559d|https://github.com/pytorch/vision centos|pytorch|torchvision|main|bf01bab6125c5f1152e4f336b470399e52a8559d|https://github.com/pytorch/vision ubuntu|pytorch|torchtext|main|09e2690791add5ddfa10f186919f731f61516b3a|https://github.com/pytorch/text From 4459b67916e700336e470e612ec7b8b82440de41 Mon Sep 17 00:00:00 2001 From: Dmitry Nikolaev <139769634+dnikolaev-amd@users.noreply.github.com> Date: Mon, 8 Jul 2024 20:15:24 +0200 Subject: [PATCH 55/57] increase tensor size to force out of memory exception on MI300X (#1449) --- test/profiler/test_profiler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/profiler/test_profiler.py b/test/profiler/test_profiler.py index 81d158635c0e5..6b1df4b6d734c 100644 --- a/test/profiler/test_profiler.py +++ b/test/profiler/test_profiler.py @@ -717,7 +717,7 @@ def run_profiler(tensor_creation_fn): def create_cuda_tensor_oom(): device = torch.device("cuda:0") - return torch.empty(1024, 1024, 1024, 20, dtype=torch.float32, device=device) + return torch.empty(1024, 1024, 1024, 1024, dtype=torch.float32, device=device) def check_trace(fname): prof.export_chrome_trace(fname) From dd43b9bd71ac4aa3fec8bc23cdc865bca6217851 Mon Sep 17 00:00:00 2001 From: Jack Taylor <108682042+jataylo@users.noreply.github.com> Date: Wed, 10 Jul 2024 21:37:14 +0000 Subject: [PATCH 56/57] Update clock info metric AMDSMI (#1459) --- torch/cuda/__init__.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/torch/cuda/__init__.py b/torch/cuda/__init__.py index e08572f5a0997..b7b9dc0465464 100644 --- a/torch/cuda/__init__.py +++ b/torch/cuda/__init__.py @@ -1106,7 +1106,11 @@ def _get_amdsmi_power_draw(device: Optional[Union[Device, int]] = None) -> int: def _get_amdsmi_clock_rate(device: Optional[Union[Device, int]] = None) -> int: handle = _get_amdsmi_handler(device) - return amdsmi.amdsmi_get_clock_info(handle, amdsmi.AmdSmiClkType.GFX)["cur_clk"] + clock_info = amdsmi.amdsmi_get_clock_info(handle, amdsmi.AmdSmiClkType.GFX) + if "cur_clk" in clock_info: + return clock_info["cur_clk"] + else: + return clock_info["clk"] def memory_usage(device: Optional[Union[Device, int]] = None) -> int: From 1b6b84ecf382b55ed398c6d89714363da20a59f5 Mon Sep 17 00:00:00 2001 From: Jeff Daily Date: Wed, 26 Jun 2024 23:45:14 +0000 Subject: [PATCH 57/57] CK GEMM Backend --- .gitmodules | 3 + aten/src/ATen/BlasBackend.h | 4 +- aten/src/ATen/Context.cpp | 2 + aten/src/ATen/Context.h | 3 + aten/src/ATen/cuda/CUDABlas.cpp | 22 ++ aten/src/ATen/native/hip/ck_gemm.h | 24 ++ aten/src/ATen/native/hip/ck_gemm.hip | 315 +++++++++++++++++++++++++++ test/test_linalg.py | 16 ++ third_party/composable_kernel | 1 + torch/_C/__init__.pyi.in | 1 + torch/backends/cuda/__init__.py | 6 +- torch/csrc/Module.cpp | 3 +- 12 files changed, 396 insertions(+), 4 deletions(-) create mode 100644 aten/src/ATen/native/hip/ck_gemm.h create mode 100644 aten/src/ATen/native/hip/ck_gemm.hip create mode 160000 third_party/composable_kernel diff --git a/.gitmodules b/.gitmodules index b2c2c01716b8d..df22abfb39831 100644 --- a/.gitmodules +++ b/.gitmodules @@ -129,3 +129,6 @@ path = third_party/tensorpipe url = https://github.com/ROCmSoftwarePlatform/tensorpipe.git branch = tp_rocm_60 +[submodule "third_party/composable_kernel"] + path = third_party/composable_kernel + url = https://github.com/ROCm/composable_kernel diff --git a/aten/src/ATen/BlasBackend.h b/aten/src/ATen/BlasBackend.h index 7f8c321ad9fa2..521addefc5ee1 100644 --- a/aten/src/ATen/BlasBackend.h +++ b/aten/src/ATen/BlasBackend.h @@ -7,7 +7,7 @@ namespace at { -enum class BlasBackend : int8_t { Cublas, Cublaslt }; +enum class BlasBackend : int8_t { Cublas, Cublaslt, Ck }; inline std::string BlasBackendToString(at::BlasBackend backend) { switch (backend) { @@ -15,6 +15,8 @@ inline std::string BlasBackendToString(at::BlasBackend backend) { return "at::BlasBackend::Cublas"; case BlasBackend::Cublaslt: return "at::BlasBackend::Cublaslt"; + case BlasBackend::Ck: + return "at::BlasBackend::Ck"; default: TORCH_CHECK(false, "Unknown blas backend"); } diff --git a/aten/src/ATen/Context.cpp b/aten/src/ATen/Context.cpp index 7fd191ef3f38c..c708f6a99a283 100644 --- a/aten/src/ATen/Context.cpp +++ b/aten/src/ATen/Context.cpp @@ -276,6 +276,8 @@ void Context::setBlasPreferredBackend(at::BlasBackend b) { #else TORCH_CHECK((b != at::BlasBackend::Cublaslt) || hasCuBLASLt(), "Cannot set preferred backend to cuBLASLt if PyTorch has not been compiled with cuBLASLt."); + TORCH_CHECK((b != at::BlasBackend::Ck) || hasROCM(), + "Cannot set preferred backend to Ck if PyTorch has not been compiled for ROCm."); if (b != at::BlasBackend::Cublas) { TORCH_WARN_ONCE( "torch.backends.cuda.preferred_blas_library is an experimental feature. " diff --git a/aten/src/ATen/Context.h b/aten/src/ATen/Context.h index 0aebafa2034bc..37838da7201a9 100644 --- a/aten/src/ATen/Context.h +++ b/aten/src/ATen/Context.h @@ -126,6 +126,9 @@ class TORCH_API Context { static bool hasCuBLASLt() { return detail::getCUDAHooks().hasCuBLASLt(); } + static bool hasROCM() { + return detail::getCUDAHooks().hasROCM(); + } static bool hasHIP() { return detail::getHIPHooks().hasHIP(); } diff --git a/aten/src/ATen/cuda/CUDABlas.cpp b/aten/src/ATen/cuda/CUDABlas.cpp index ce991a9bcad4e..b18d782dc1b57 100644 --- a/aten/src/ATen/cuda/CUDABlas.cpp +++ b/aten/src/ATen/cuda/CUDABlas.cpp @@ -18,6 +18,7 @@ // until hipblas has an API to accept flags, we must use rocblas here #include #include +#include #define PYTORCH_ROCBLAS_VERSION_DECIMAL (ROCBLAS_VERSION_MAJOR * 100 + ROCBLAS_VERSION_MINOR) #define USE_GEMM_FLAGS_FP16_ALT_IMPL (PYTORCH_ROCBLAS_VERSION_DECIMAL >= 242) // needed to work around calling rocblas API instead of hipblas API @@ -792,6 +793,7 @@ inline void gemm_internal_cublas(CUDABLAS_GEMM_ARGTYPES(Dtype)) { AT_ERROR("at::cuda::blas::gemm_internal_cublas: not implemented for ", typeid(Dtype).name()); } + template <> void gemm_internal_cublas(CUDABLAS_GEMM_ARGTYPES(double)) { // See Note [Writing Nondeterministic Operations] @@ -1000,6 +1002,11 @@ void gemm_internal(CUDABLAS_GEMM_ARGTYPES(double)) gemm_internal_cublaslt(CUDABLAS_GEMM_ARGS(double)); #endif } +#ifdef USE_ROCM + else if (at::globalContext().blasPreferredBackend() == BlasBackend::Ck) { + at::native::gemm_internal_ck(CUDABLAS_GEMM_ARGS(double)); + } +#endif else { gemm_internal_cublas(CUDABLAS_GEMM_ARGS(double)); } @@ -1011,6 +1018,11 @@ void gemm_internal(CUDABLAS_GEMM_ARGTYPES(float)) if (at::globalContext().blasPreferredBackend() == BlasBackend::Cublaslt) { gemm_internal_cublaslt(CUDABLAS_GEMM_ARGS(float)); } +#ifdef USE_ROCM + else if (at::globalContext().blasPreferredBackend() == BlasBackend::Ck) { + at::native::gemm_internal_ck(CUDABLAS_GEMM_ARGS(float)); + } +#endif else { gemm_internal_cublas(CUDABLAS_GEMM_ARGS(float)); } @@ -1054,6 +1066,11 @@ void gemm_internal(CUDABLAS_GEMM_ARGTYPES(at::Half)) if (at::globalContext().blasPreferredBackend() == BlasBackend::Cublaslt) { gemm_internal_cublaslt(CUDABLAS_GEMM_ARGS(at::Half)); } +#ifdef USE_ROCM + else if (at::globalContext().blasPreferredBackend() == BlasBackend::Ck) { + at::native::gemm_internal_ck(CUDABLAS_GEMM_ARGS(at::Half)); + } +#endif else { gemm_internal_cublas(CUDABLAS_GEMM_ARGS(at::Half)); } @@ -1065,6 +1082,11 @@ void gemm_internal(CUDABLAS_GEMM_ARGTYPES(at::BFloat16)) if (at::globalContext().blasPreferredBackend() == BlasBackend::Cublaslt) { gemm_internal_cublaslt(CUDABLAS_GEMM_ARGS(at::BFloat16)); } +#ifdef USE_ROCM + else if (at::globalContext().blasPreferredBackend() == BlasBackend::Ck) { + at::native::gemm_internal_ck(CUDABLAS_GEMM_ARGS(at::BFloat16)); + } +#endif else { gemm_internal_cublas(CUDABLAS_GEMM_ARGS(at::BFloat16)); } diff --git a/aten/src/ATen/native/hip/ck_gemm.h b/aten/src/ATen/native/hip/ck_gemm.h new file mode 100644 index 0000000000000..176cbabd5e01c --- /dev/null +++ b/aten/src/ATen/native/hip/ck_gemm.h @@ -0,0 +1,24 @@ +#pragma once + +#include +#include +namespace at::native { + + +template +inline void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(Dtype)) { + static_assert(false&&sizeof(Dtype),"at::cuda::blas_gemm_internal_ck: not implemented"); +} + +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(double)); +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(float)); +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(at::Half)); +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(at::BFloat16)); + + + +} // namespace at::native diff --git a/aten/src/ATen/native/hip/ck_gemm.hip b/aten/src/ATen/native/hip/ck_gemm.hip new file mode 100644 index 0000000000000..1202d86fffa4f --- /dev/null +++ b/aten/src/ATen/native/hip/ck_gemm.hip @@ -0,0 +1,315 @@ +/* + * Copyright (c) Meta Platforms, Inc. and affiliates. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include +#include +#include +#include + +#undef __HIP_NO_HALF_CONVERSIONS__ + +#include +#include +#include +#include + + +#include "ck/ck.hpp" +#include "ck/tensor_operation/gpu/device/gemm_specialization.hpp" +#include "ck/tensor_operation/gpu/device/tensor_layout.hpp" +#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp" +#include "ck/utility/data_type.hpp" + +#include "ck/library/reference_tensor_operation/cpu/reference_gemm.hpp" +#include "ck/library/utility/check_err.hpp" +#include "ck/library/utility/device_memory.hpp" +#include "ck/library/utility/fill.hpp" +#include "ck/library/utility/host_tensor.hpp" +#include "ck/library/utility/host_tensor_generator.hpp" +#include "ck/library/utility/literals.hpp" + +#include "ck/tensor_operation/gpu/device/impl/device_gemm_multiple_d_xdl_cshuffle_v3.hpp" + +// Define commonly used types. +template +using S = ck::Sequence; + +using Row = ck::tensor_layout::gemm::RowMajor; +using Col = ck::tensor_layout::gemm::ColumnMajor; +using PassThrough = ck::tensor_operation::element_wise::PassThrough; + +namespace at::native { + +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(double)) { + return; +} + +template +struct CkMathType { + using dtype = T; +}; + +template <> +struct CkMathType { + using dtype = ck::bhalf_t; +}; + +template <> +struct CkMathType { + using dtype = ck::half_t; +}; + +// Elementwise Operators +struct AlphaBetaAdd +{ + AlphaBetaAdd(float alpha, float beta) : alpha_(alpha), beta_(beta){}; + + template + __host__ __device__ constexpr void operator()(C& c, const AB& ab) const; + + template<> + __host__ __device__ constexpr void operator() + (float& c, const float& ab) const + { + c = alpha_ * ab; + }; + + template<> + __host__ __device__ constexpr void operator() + (ck::bhalf_t& c, const ck::bhalf_t& ab) const + { + c = alpha_ * ab; + }; + + template<> + __host__ __device__ constexpr void operator() + (ck::half_t& c, const ck::half_t& ab) const + { + c = alpha_ * ab; + }; + + float alpha_; + // TODO: Leaving for now, will use later + float beta_; +}; + +template < + typename Dtype, + int BLOCK_SIZE, + int MBLOCK, + int NBLOCK, + int KBLOCK, + int AK1, + int BK1, + int MPER_XDL, + int NPER_XDL, + int MPER_WAVE, + int NPER_WAVE, + int CNPER_WAVE = 1, + bool PADDING = false> +void gemm_impl(CUDABLAS_GEMM_ARGTYPES(Dtype)) { + // Get input information. + int M = m; + int N = n; + int K = k; + + int StrideA = lda; + int StrideB = ldb; + int StrideC = ldc; + + float falpha = alpha; + float fbeta = beta; + + + using ADataType = typename CkMathType::dtype; + using BDataType = typename CkMathType::dtype; + using CDataType = typename CkMathType::dtype; + using DDataType = typename CkMathType::dtype; + + using AccDataType = float; + using CShuffleDataType = typename CkMathType::dtype; + + + // NOTE: in our example, transa = t and transb = n; + // since default for cublas is Column-major, since the value is T, ALayout is Row + // same for B. transb = N = NO Transpose so B is column Major + using ALayout = Row; + using BLayout = Col; + using DLayout = Row; + using CLayout = Row; + + using AElementOp = PassThrough; + using BElementOp = PassThrough; + using CElementOp = AlphaBetaAdd; + + static constexpr auto GemmDefault = + ck::tensor_operation::device::GemmSpecialization::Default; + static constexpr auto GemmMNKPadding = + ck::tensor_operation::device::GemmSpecialization::MNKPadding; + static constexpr auto GemmSpec = PADDING ? GemmMNKPadding : GemmDefault; + + + // TODO: Flesh out template parameters + using DeviceGemmInstance = + ck::tensor_operation::device::DeviceGemmMultiD_Xdl_CShuffle_V3, + CLayout, + ADataType, + BDataType, + ck::Tuple<>, + CDataType, + AccDataType, + CShuffleDataType, + AElementOp, + BElementOp, + CElementOp, + GemmSpec, + BLOCK_SIZE, //256, + MBLOCK, //256, + NBLOCK, //128, + KBLOCK, //32, + AK1, //4, + BK1, //4, + MPER_XDL, //32, + NPER_XDL, //32, + MPER_WAVE, //4, + NPER_WAVE, //2, + S<8, 32, 1>, + S<1, 0, 2>, + S<1, 0, 2>, + 2, + 4, + 4, + 0, + S<8, 32, 1>, + S<1, 0, 2>, + S<1, 0, 2>, + 2, + 4, + 4, + 0, + 1, + 1, + S<1, 32, 1, 8>, + S<4>>; + + + auto gemm = DeviceGemmInstance{}; + auto invoker = gemm.MakeInvoker(); + + auto a_element_op = AElementOp{}; + auto b_element_op = BElementOp{}; + auto c_element_op = CElementOp{alpha, beta}; + + using DDataArrayType = std::array; + DDataArrayType DDataArray; + + // Note: CK only supports row-major output. + // We swap A and B inputs here as a temporary workaround + auto argument = gemm.MakeArgument( + reinterpret_cast(b), + reinterpret_cast(a), + DDataArray, + reinterpret_cast(c), + N, + M, + K, + StrideB, + StrideA, + std::array{}, + StrideC, + a_element_op, + b_element_op, + c_element_op); + + + if(!gemm.IsSupportedArgument(argument)) + { + throw std::runtime_error( + "wrong! device_gemm with the specified compilation parameters does " + "not support this GEMM problem"); + } + + + auto stream = at::cuda::getCurrentHIPStream().stream(); + invoker.Run(argument, StreamConfig{stream, false}); +} + +void dispatch_float_gemm(CUDABLAS_GEMM_ARGTYPES(float)) { + // If any of the shapes cant be tiled, we must use padding. + bool use_padding = ((m % 256 != 0) || (n % 128 != 0) || (k % 64 != 0)); + // Dispatch to best implementation. + // TODO add more configurations. Optimize. + if (use_padding) { + if (m <= 128) { + gemm_impl(CUDABLAS_GEMM_ARGS(float)); + } else { + gemm_impl(CUDABLAS_GEMM_ARGS(float)); + } + } else { + { + gemm_impl(CUDABLAS_GEMM_ARGS(float)); + } + } +} + +void dispatch_bfloat16_gemm(CUDABLAS_GEMM_ARGTYPES(at::BFloat16)) { + // If any of the shapes cant be tiled, we must use padding. + bool use_padding = ((m % 256 != 0) || (n % 128 != 0) || (k % 64 != 0)); + // Dispatch to best implementation. + // TODO add more configurations. Optimize. + if (use_padding) { + if (m <= 128) { + gemm_impl(CUDABLAS_GEMM_ARGS(at::BFloat16)); + } else { + gemm_impl(CUDABLAS_GEMM_ARGS(at::BFloat16)); + } + } else { + { + gemm_impl(CUDABLAS_GEMM_ARGS(at::BFloat16)); + } + } +} + +void dispatch_half_gemm(CUDABLAS_GEMM_ARGTYPES(at::Half)) { + // If any of the shapes cant be tiled, we must use padding. + bool use_padding = ((m % 256 != 0) || (n % 128 != 0) || (k % 64 != 0)); + // Dispatch to best implementation. + // TODO add more configurations. Optimize. + if (use_padding) { + if (m <= 128) { + gemm_impl(CUDABLAS_GEMM_ARGS(at::Half)); + } else { + gemm_impl(CUDABLAS_GEMM_ARGS(at::Half)); + } + } else { + { + gemm_impl(CUDABLAS_GEMM_ARGS(at::Half)); + } + } +} + +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(float)) { + dispatch_float_gemm(CUDABLAS_GEMM_ARGS(float)); +} + +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(at::BFloat16)) { + dispatch_bfloat16_gemm(CUDABLAS_GEMM_ARGS(at::BFloat16)); +} + +template <> +void gemm_internal_ck(CUDABLAS_GEMM_ARGTYPES(at::Half)) { + dispatch_half_gemm(CUDABLAS_GEMM_ARGS(at::Half)); +} + +} // namespace at::native + diff --git a/test/test_linalg.py b/test/test_linalg.py index 207290f5a6a8b..9a783b988f3cb 100644 --- a/test/test_linalg.py +++ b/test/test_linalg.py @@ -8036,6 +8036,22 @@ def test_preferred_blas_library(self): self.assertEqual(out1, out2) self.assertEqual(out_ref, out2.cpu()) + @onlyCUDA + @unittest.skipIf(not blaslt_supported_device(), "blasLt not supported on current device") + @setBlasBackendsToDefaultFinally + def test_ck_blas_library(self): + m1 = torch.randint(2, 5, (7168, 8192), device='cuda', dtype=torch.float) + m2 = torch.randint(2, 5, (1280, 8192), device='cuda', dtype=torch.float) + + torch.backends.cuda.preferred_blas_library('ck') + ck_out = torch.nn.functional.linear(m1, m2) + + cpu_out = torch.nn.functional.linear(m1.cpu(), m2.cpu()) + + self.assertEqual(ck_out, cpu_out) + + + def test_permute_matmul(self): a = torch.ones([2, 5, 24, 24]) b = torch.ones([3, 2, 5, 24, 24]) diff --git a/third_party/composable_kernel b/third_party/composable_kernel new file mode 160000 index 0000000000000..a32b1bc64794b --- /dev/null +++ b/third_party/composable_kernel @@ -0,0 +1 @@ +Subproject commit a32b1bc64794b8bd51f6924cb7d72dd1059803dd diff --git a/torch/_C/__init__.pyi.in b/torch/_C/__init__.pyi.in index 485f37b47b744..395952acb1d15 100644 --- a/torch/_C/__init__.pyi.in +++ b/torch/_C/__init__.pyi.in @@ -1260,6 +1260,7 @@ def _set_blas_preferred_backend(arg: torch._C._BlasBackend): ... class _BlasBackend: Cublas: _BlasBackend Cublaslt: _BlasBackend + Ck: _BlasBackend class ConvBackend(Enum): ... diff --git a/torch/backends/cuda/__init__.py b/torch/backends/cuda/__init__.py index cb5f511bc5dbc..23e68f4980df8 100644 --- a/torch/backends/cuda/__init__.py +++ b/torch/backends/cuda/__init__.py @@ -212,6 +212,7 @@ def preferred_linalg_library( "cublas": torch._C._BlasBackend.Cublas, "cublaslt": torch._C._BlasBackend.Cublaslt, "hipblaslt": torch._C._BlasBackend.Cublaslt, # alias + "ck": torch._C._BlasBackend.Ck, } _BlasBackends_str = ", ".join(_BlasBackends.keys()) @@ -220,16 +221,17 @@ def preferred_blas_library( backend: Union[None, str, torch._C._BlasBackend] = None ) -> torch._C._BlasBackend: r""" - Override the library PyTorch uses for BLAS operations. Choose between cuBLAS and cuBLASLt. + Override the library PyTorch uses for BLAS operations. Choose between cuBLAS, cuBLASLt, and CK [ROCm-only]. .. warning:: This flag is experimental and subject to change. When PyTorch runs a CUDA BLAS operation it defaults to cuBLAS even if both cuBLAS and cuBLASLt are available. - For PyTorch built for ROCm, hipBLAS and hipBLASLt may offer different performance. + For PyTorch built for ROCm, hipBLAS, hipBLASLt, and CK may offer different performance. This flag (a :class:`str`) allows overriding which BLAS library to use. * If `"cublas"` is set then cuBLAS will be used wherever possible. * If `"cublaslt"` is set then cuBLASLt will be used wherever possible. + * If `"ck"` is set then CK will be used wherever possible. * When no input is given, this function returns the currently preferred library. * User may use the environment variable TORCH_BLAS_PREFER_CUBLASLT=1 to set the preferred library to cuBLASLt globally. diff --git a/torch/csrc/Module.cpp b/torch/csrc/Module.cpp index 00a2c0bbe3026..6dc2291288377 100644 --- a/torch/csrc/Module.cpp +++ b/torch/csrc/Module.cpp @@ -1938,7 +1938,8 @@ Call this whenever a new thread is created in order to propagate values from py::enum_(py_module, "_BlasBackend") .value("Cublas", at::BlasBackend::Cublas) - .value("Cublaslt", at::BlasBackend::Cublaslt); + .value("Cublaslt", at::BlasBackend::Cublaslt) + .value("Ck", at::BlasBackend::Ck); py_module.def("_set_blas_preferred_backend", [](at::BlasBackend b) { at::globalContext().setBlasPreferredBackend(b);