derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
709 lines
36 KiB
C++
709 lines
36 KiB
C++
/*******************************************************************************
|
|
*
|
|
* MIT License
|
|
*
|
|
* Copyright (c) 2024 Advanced Micro Devices, Inc.
|
|
*
|
|
* 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.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include <miopen/logger.hpp>
|
|
|
|
#include "unit_TensorDescriptor.hpp"
|
|
|
|
namespace {
|
|
|
|
struct TestCasePossibleLayout
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
std::vector<std::string> actual_layouts;
|
|
miopen::TensorDescriptor::LayoutValidationMode validation_mode =
|
|
miopen::TensorDescriptor::LayoutValidationMode::StrictDecreasingStrides;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCasePossibleLayout& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
miopen::LogRange(os << "{", tc.actual_layouts, ",") << "}, ";
|
|
os << " {LayoutValidationMode: " << static_cast<int>(tc.validation_mode) << "} ";
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseGetLayoutT
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
miopenTensorLayout_t actual_layout;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseGetLayoutT& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
os << static_cast<int>(tc.actual_layout);
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseGetLayoutEnum
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
std::optional<miopenTensorLayout_t> actual_layout;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseGetLayoutEnum& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
if(tc.actual_layout)
|
|
os << static_cast<int>(tc.actual_layout.value());
|
|
else
|
|
os << "unknown";
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseGetLayoutStr
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
std::string actual_layout;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseGetLayoutStr& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
os << tc.actual_layout;
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseLayoutEnumToStr
|
|
{
|
|
miopenTensorLayout_t layout_enum;
|
|
std::string layout_str;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseLayoutEnumToStr& tc)
|
|
{
|
|
os << "(";
|
|
os << static_cast<int>(tc.layout_enum) << ", ";
|
|
os << tc.layout_str;
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseGetLayout
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
std::string storage_layout;
|
|
std::string actual_layout;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseGetLayout& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
os << tc.storage_layout << ", ";
|
|
os << tc.actual_layout;
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseGetVectorLength
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
std::size_t actual_vector_length;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseGetVectorLength& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
os << tc.actual_vector_length;
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
struct TestCaseCheckDimsFitIntoInt
|
|
{
|
|
miopen::unit_tests::TensorDescriptorParams tp;
|
|
bool lens_fit_into_int;
|
|
bool strides_fit_into_int;
|
|
|
|
friend std::ostream& operator<<(std::ostream& os, const TestCaseCheckDimsFitIntoInt& tc)
|
|
{
|
|
os << "(";
|
|
os << "(" << tc.tp << "), ";
|
|
os << tc.lens_fit_into_int << ", ";
|
|
os << tc.strides_fit_into_int;
|
|
os << ")";
|
|
return os;
|
|
}
|
|
};
|
|
|
|
class TestPossibleLayout4D5D : public ::testing::TestWithParam<TestCasePossibleLayout>
|
|
{
|
|
static auto& GetAllLayouts()
|
|
{
|
|
static const auto layouts =
|
|
std::vector<std::string>{"NCHW", "NHWC", "CHWN", "NCDHW", "NDHWC", "NCHWc", "CHWNc"};
|
|
return layouts;
|
|
}
|
|
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCasePossibleLayout;
|
|
|
|
static const auto ignore_degenerate_strides =
|
|
miopen::TensorDescriptor::LayoutValidationMode::IgnoreDegenerateStrides;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}}, {"NCHW", "NHWC", "CHWN"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}}, {"NCHW"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1, 1}}, {"NCDHW", "NDHWC"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}}, {"NCDHW"}},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {1, 1, 1, 1}}, {"NCHW", "NHWC", "CHWN"}},
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}}, {"NCHW"}},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {1, 1, 1, 1}}, {"NCHW", "NHWC", "CHWN"}},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}}, {"NHWC"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {1, 1, 1, 1}}, {"NCHW", "NHWC", "CHWN"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}}, {"CHWN"}},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {1, 4, 1, 1}}, {"NCHWc", "CHWNc"}},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {2, 4, 2, 2}}, {"NCHWc"}},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {1, 8, 1, 1}}, {"NCHWc", "CHWNc"}},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {2, 8, 2, 2}}, {"NCHWc"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {1, 4, 1, 1}}, {"NCHWc", "CHWNc"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {2, 4, 2, 2}}, {"CHWNc"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {1, 8, 1, 1}}, {"NCHWc", "CHWNc"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {2, 8, 2, 2}}, {"CHWNc"}},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {1, 1, 1, 1, 1}}, {"NCDHW", "NDHWC"}},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}}, {"NCDHW"}},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {1, 1, 1, 1, 1}}, {"NCDHW", "NDHWC"}},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}}, {"NDHWC"}},
|
|
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1000, 100, 10, 1}}, {"NCHW"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1000, 1, 100, 10}}, {"NHWC"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1, 1000, 100, 10}}, {"CHWN"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1, 1, 1, 1}}, {"NCHW", "NHWC", "CHWN"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 100, 10, 1}}, {"NCHW"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 1, 100, 10}}, {"NHWC"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 1000, 100, 10}}, {"CHWN"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 1, 1, 1}}, {"NCHW", "NHWC", "CHWN"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1, 1}, {10000, 1000, 100, 10, 1}}, {"NCDHW"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1, 1}, {10000, 1, 1000, 100, 10}}, {"NDHWC"}},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}}, {"NCDHW", "NDHWC"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, {"NCDHW"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, {"NDHWC"}},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 1, 1, 1, 1}}, {"NCDHW", "NDHWC"}},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {1, 1, 1, 1}, {1000, 100, 10, 1}}, {"NCHW"}},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {1, 1, 1, 1}, {1000, 1, 100, 10}}, {"NHWC"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {1, 1, 1, 1}, {1, 1000, 100, 10}}, {"CHWN"}},
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}, {1000, 100, 10, 1}}, {"NCHW"}},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}, {1000, 1, 100, 10}}, {"NHWC"}},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}, {1, 1000, 100, 10}}, {"CHWN"}},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {1, 1, 1, 1, 1}, {10000, 1000, 100, 10, 1}}, {"NCDHW"}},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {1, 1, 1, 1, 1}, {10000, 1, 1000, 100, 10}}, {"NDHWC"}},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, {"NCDHW"}},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, {"NDHWC"}},
|
|
|
|
// Stride is ignored when the corresponding dimension length is 1 with LayoutValidationMode::IgnoreDegenerateStrides.
|
|
// As a result, multiple layouts have identical memory footprints.
|
|
// E.G, NCHW == CHWN for n = 1.
|
|
TestCase{{miopenHalf, {1, 2, 2, 2}, {1, 100, 10, 1}}, {"NCHW", "CHWN"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 1, 2, 2}, {1000, 10000, 10, 1}}, {"NCHW", "NHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 1, 2}, {1000, 100, 10000, 1}}, {"NCHW"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 1}, {1000, 100, 10, 10000}}, {"NCHW"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 2, 2, 2}, {1, 1, 100, 10}}, {"NHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 1, 2}, {1000, 1, 10000, 10}}, {"NHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 1}, {1000, 1, 100, 10000}}, {"NHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 1, 2, 2}, {1, 1, 100, 10}}, {"CHWN"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 1, 2}, {1, 1000, 10000, 10}}, {"CHWN"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 1}, {1, 1000, 100, 10000}}, {"CHWN"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1000, 100, 10, 1}}, {"NCHW", "NHWC", "CHWN"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1000, 1, 100, 10}}, {"NCHW", "NHWC", "CHWN"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1, 1000, 100, 10}}, {"NCHW", "NHWC", "CHWN"}, ignore_degenerate_strides},
|
|
|
|
TestCase{{miopenHalf, {1, 1, 1, 1, 1}, {10000, 1000, 100, 10, 1}}, {"NCDHW", "NDHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1, 1}, {10000, 1, 1000, 100, 10}}, {"NCDHW", "NDHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 2, 2, 2, 2}, {1, 1000, 100, 10, 1}}, {"NCDHW"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 1, 2, 2, 2}, {10000, 100000, 100, 10, 1}}, {"NCDHW", "NDHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 1, 2, 2}, {10000, 1000, 100000, 10, 1}}, {"NCDHW"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 1, 2}, {10000, 1000, 100, 100000, 1}}, {"NCDHW"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 1}, {10000, 1000, 100, 10, 100000}}, {"NCDHW"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {1, 2, 2, 2, 2}, {1, 1, 1000, 100, 10}}, {"NDHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 1, 2, 2}, {10000, 1, 100000, 100, 10}}, {"NDHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 1, 2}, {10000, 1, 1000, 100000, 10}}, {"NDHWC"}, ignore_degenerate_strides},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 1}, {10000, 1, 1000, 100, 100000}}, {"NDHWC"}, ignore_degenerate_strides},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
const auto validation_mode = p.validation_mode;
|
|
for(const auto& layout : this->GetAllLayouts())
|
|
{
|
|
const auto is_possible_layout = td.IsPossibleLayout4D5D(layout, validation_mode);
|
|
const auto expected =
|
|
std::count(p.actual_layouts.cbegin(), p.actual_layouts.cend(), layout);
|
|
ASSERT_EQ(is_possible_layout, expected) << "current layout: " << layout;
|
|
}
|
|
}
|
|
};
|
|
|
|
class TestGetLayoutT : public ::testing::TestWithParam<TestCaseGetLayoutT>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseGetLayoutT;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}}, miopenTensorNCDHW},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}}, miopenTensorNHWC},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}}, miopenTensorCHWN},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {2, 4, 2, 2}}, miopenTensorNCHWc4},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {2, 8, 2, 2}}, miopenTensorNCHWc8},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {2, 4, 2, 2}}, miopenTensorCHWNc4},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {2, 8, 2, 2}}, miopenTensorCHWNc8},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}}, miopenTensorNDHWC},
|
|
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 100, 10, 1}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 1, 100, 10}}, miopenTensorNHWC},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 1000, 100, 10}}, miopenTensorCHWN},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, miopenTensorNDHWC},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}, {1000, 100, 10, 1}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}, {1000, 1, 100, 10}}, miopenTensorNHWC},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}, {1, 1000, 100, 10}}, miopenTensorCHWN},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, miopenTensorNDHWC},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
ASSERT_EQ(td.GetLayoutEnum(), p.actual_layout);
|
|
}
|
|
};
|
|
|
|
class TestGetLayoutEnum : public ::testing::TestWithParam<TestCaseGetLayoutEnum>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseGetLayoutEnum;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {2}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}}, std::nullopt}, // Unknown
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}}, miopenTensorNHWC},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}}, miopenTensorCHWN},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {2, 4, 2, 2}}, miopenTensorNCHWc4},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {2, 8, 2, 2}}, miopenTensorNCHWc8},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {2, 4, 2, 2}}, miopenTensorCHWNc4},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {2, 8, 2, 2}}, miopenTensorCHWNc8},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}}, miopenTensorNDHWC},
|
|
|
|
TestCase{{miopenHalf, {2}, {1}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2}, {10, 1}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2}, {1, 10}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}, {100, 10, 1}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}, {100, 1, 10}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}, {10, 100, 1}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}, {1, 100, 10}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}, {10, 1, 100}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2}, {1, 10, 100}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 100, 10, 1}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 1, 100, 10}}, miopenTensorNHWC},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 1000, 100, 10}}, miopenTensorCHWN},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {100, 1000, 10, 1}}, std::nullopt}, // CNHW
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 10, 1000, 100}}, std::nullopt}, // HWCN
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {10, 1, 1000, 100}}, std::nullopt}, // HWNC
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, miopenTensorNDHWC},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1000, 10000, 100, 10, 1}}, std::nullopt}, // CNDHW
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 10000, 1000, 100, 10}}, std::nullopt}, // CDHWN
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10, 1, 10000, 1000, 100}}, std::nullopt}, // DHWNC
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 10, 10000, 1000, 100}}, std::nullopt}, // DHWCN
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}, {100000, 10000, 1000, 100, 10, 1}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}, {1000000, 100000, 10000, 1000, 100, 10, 1}}, std::nullopt}, // Unknown
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}, {10000000, 1000000, 100000, 10000, 1000, 100, 10, 1}}, std::nullopt}, // Unknown
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}, {1000, 100, 10, 1}}, miopenTensorNCHW},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}, {1000, 1, 100, 10}}, miopenTensorNHWC},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}, {1, 1000, 100, 10}}, miopenTensorCHWN},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, miopenTensorNCDHW},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, miopenTensorNDHWC},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
ASSERT_EQ(td.GetLayoutEnum(), p.actual_layout);
|
|
}
|
|
};
|
|
|
|
class TestGetLayoutStr : public ::testing::TestWithParam<TestCaseGetLayoutStr>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseGetLayoutStr;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {2}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}}, "NCHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}}, "NCDHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}}, "UNKNOWN"},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}}, "NCHW"},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}}, "NHWC"},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}}, "CHWN"},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {2, 4, 2, 2}}, "NCHWc"},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {2, 8, 2, 2}}, "NCHWc"},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {2, 4, 2, 2}}, "CHWNc"},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {2, 8, 2, 2}}, "CHWNc"},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}}, "NCDHW"},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}}, "NDHWC"},
|
|
|
|
TestCase{{miopenHalf, {2}, {1}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2}, {10, 1}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2}, {1, 10}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {100, 10, 1}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {100, 1, 10}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {10, 100, 1}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {1, 100, 10}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {10, 1, 100}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {1, 10, 100}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 100, 10, 1}}, "NCHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 1, 100, 10}}, "NHWC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 1000, 100, 10}}, "CHWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {100, 1000, 10, 1}}, "CNHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 10, 1000, 100}}, "HWCN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {10, 1, 1000, 100}}, "HWNC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, "NCDHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, "NDHWC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1000, 10000, 100, 10, 1}}, "CNDHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 10000, 1000, 100, 10}}, "CDHWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10, 1, 10000, 1000, 100}}, "DHWNC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 10, 10000, 1000, 100}}, "DHWCN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}, {100000, 10000, 1000, 100, 10, 1}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}, {1000000, 100000, 10000, 1000, 100, 10, 1}}, "UNKNOWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}, {10000000, 1000000, 100000, 10000, 1000, 100, 10, 1}}, "UNKNOWN"},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}, {1000, 100, 10, 1}}, "NCHW"},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}, {1000, 1, 100, 10}}, "NHWC"},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}, {1, 1000, 100, 10}}, "CHWN"},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, "NCDHW"},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, "NDHWC"},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
ASSERT_EQ(td.GetLayout_str(), p.actual_layout);
|
|
}
|
|
};
|
|
|
|
class TestLayoutEnumToStr : public ::testing::TestWithParam<TestCaseLayoutEnumToStr>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseLayoutEnumToStr;
|
|
|
|
return std::vector{
|
|
TestCase{miopenTensorNCHW, "NCHW"},
|
|
TestCase{miopenTensorNHWC, "NHWC"},
|
|
TestCase{miopenTensorCHWN, "CHWN"},
|
|
TestCase{miopenTensorNCHWc4, "NCHWc"},
|
|
TestCase{miopenTensorNCHWc8, "NCHWc"},
|
|
TestCase{miopenTensorCHWNc4, "CHWNc"},
|
|
TestCase{miopenTensorCHWNc8, "CHWNc"},
|
|
TestCase{miopenTensorNCDHW, "NCDHW"},
|
|
TestCase{miopenTensorNDHWC, "NDHWC"},
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
ASSERT_EQ(miopen::TensorDescriptor::LayoutEnumToStr(p.layout_enum), p.layout_str);
|
|
}
|
|
};
|
|
|
|
class TestGetLayout : public ::testing::TestWithParam<TestCaseGetLayout>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseGetLayout;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {2}}, "A", "A"},
|
|
TestCase{{miopenHalf, {2, 2}}, "AB", "AB"},
|
|
TestCase{{miopenHalf, {2, 2, 2}}, "ABC", "ABC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}}, "ABCD", "ABCD"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}}, "ABCDE", "ABCDE"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}}, "ABCDEF", "ABCDEF"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}}, "ABCDEFG", "ABCDEFG"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}}, "ABCDEFGH", "ABCDEFGH"},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}}, "NCHW", "NCHW"},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}}, "NCHW", "NHWC"},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}}, "NCHW", "CHWN"},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {2, 8, 2, 2}}, "NCHWc", "NCHWc"},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {2, 16, 2, 2}}, "NCHWc", "NCHWc"},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {2, 8, 2, 2}}, "CHWNc", "CHWNc"},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {2, 16, 2, 2}}, "CHWNc", "CHWNc"},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}}, "NCDHW", "NCDHW"},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}}, "NCDHW", "NDHWC"},
|
|
|
|
TestCase{{miopenHalf, {2}, {1}}, "A", "A"},
|
|
TestCase{{miopenHalf, {2, 2}, {10, 1}}, "AB", "AB"},
|
|
TestCase{{miopenHalf, {2, 2}, {1, 10}}, "AB", "BA"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {100, 10, 1}}, "ABC", "ABC"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {10, 100, 1}}, "ABC", "BAC"},
|
|
TestCase{{miopenHalf, {2, 2, 2}, {1, 100, 10}}, "ABC", "BCA"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 100, 10, 1}}, "NCHW", "NCHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 1, 100, 10}}, "NCHW", "NHWC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {100, 1000, 10, 1}}, "NCHW", "CNHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 1000, 100, 10}}, "NCHW", "CHWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1, 10, 1000, 100}}, "NCHW", "HWCN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {10, 1, 1000, 100}}, "NCHW", "HWNC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, "NCDHW", "NCDHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, "NCDHW", "NDHWC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1000, 10000, 100, 10, 1}}, "NCDHW", "CNDHW"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 10000, 1000, 100, 10}}, "NCDHW", "CDHWN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10, 1, 10000, 1000, 100}}, "NCDHW", "DHWNC"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {1, 10, 10000, 1000, 100}}, "NCDHW", "DHWCN"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}, {6, 5, 4, 3, 2, 1}}, "ABCDEF", "ABCDEF"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}, {1, 2, 3, 4, 5, 6}}, "ABCDEF", "FEDCBA"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}, {7, 6, 5, 4, 3, 2, 1}}, "ABCDEFG", "ABCDEFG"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2}, {1, 2, 3, 4, 5, 6, 7}}, "ABCDEFG", "GFEDCBA"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}, {8, 7, 6, 5, 4, 3, 2, 1}}, "ABCDEFGH", "ABCDEFGH"},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2, 2, 2}, {1, 2, 3, 4, 5, 6, 7, 8}}, "ABCDEFGH", "HGFEDCBA"},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}, {1000, 100, 10, 1}}, "NCHW", "NCHW"},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}, {1000, 1, 100, 10}}, "NCHW", "NHWC"},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}, {1, 1000, 100, 10}}, "NCHW", "CHWN"},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, "NCDHW", "NCDHW"},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, "NCDHW", "NDHWC"},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
ASSERT_EQ(td.GetLayout(p.storage_layout), p.actual_layout);
|
|
}
|
|
};
|
|
|
|
class TestGetVectorLength : public ::testing::TestWithParam<TestCaseGetVectorLength>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseGetVectorLength;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}}, 1},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc4, {2, 8, 2, 2}}, 4},
|
|
TestCase{{miopenHalf, miopenTensorNCHWc8, {2, 16, 2, 2}}, 8},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc4, {2, 8, 2, 2}}, 4},
|
|
TestCase{{miopenHalf, miopenTensorCHWNc8, {2, 16, 2, 2}}, 8},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}}, 1},
|
|
|
|
TestCase{{miopenHalf, {2, 2, 2}, {100, 10, 1}}, 1},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2}, {1000, 100, 10, 1}}, 1},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, 1},
|
|
TestCase{{miopenHalf, {2, 2, 2, 2, 2, 2}, {100000, 10000, 1000, 100, 10, 1}}, 1},
|
|
|
|
TestCase{{miopenHalf, miopenTensorNCHW, {2, 2, 2, 2}, {1000, 100, 10, 1}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorNHWC, {2, 2, 2, 2}, {1000, 1, 100, 10}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorCHWN, {2, 2, 2, 2}, {1, 1000, 100, 10}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorNCDHW, {2, 2, 2, 2, 2}, {10000, 1000, 100, 10, 1}}, 1},
|
|
TestCase{{miopenHalf, miopenTensorNDHWC, {2, 2, 2, 2, 2}, {10000, 1, 1000, 100, 10}}, 1},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
ASSERT_EQ(td.GetVectorLength(), p.actual_vector_length);
|
|
}
|
|
};
|
|
|
|
class TestCheckDimsFitIntoInt : public ::testing::TestWithParam<TestCaseCheckDimsFitIntoInt>
|
|
{
|
|
public:
|
|
static auto GetTestCases()
|
|
{
|
|
using TestCase = TestCaseCheckDimsFitIntoInt;
|
|
const std::size_t maxv = std::numeric_limits<int>::max();
|
|
const std::size_t maxv1 = maxv + 1;
|
|
|
|
return std::vector{
|
|
// clang-format off
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1, 1, 1, 1}}, true, true},
|
|
TestCase{{miopenHalf, {maxv, maxv, maxv, maxv}, {1, 1, 1, 1}}, true, true},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {maxv, maxv, maxv, maxv}}, true, true},
|
|
TestCase{{miopenHalf, {maxv, maxv, maxv, maxv}, {maxv, maxv, maxv, maxv}}, true, true},
|
|
|
|
TestCase{{miopenHalf, {maxv1, maxv1, maxv1, maxv1}, {1, 1, 1, 1}}, false, true},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {maxv1, maxv1, maxv1, maxv1}}, true, false},
|
|
TestCase{{miopenHalf, {maxv1, maxv1, maxv1, maxv1}, {maxv1, maxv1, maxv1, maxv1}}, false, false},
|
|
|
|
TestCase{{miopenHalf, {1, maxv1, 1, 1}, {1, 1, 1, 1}}, false, true},
|
|
TestCase{{miopenHalf, {maxv, maxv, maxv1, maxv}, {1, 1, 1, 1}}, false, true},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {maxv, maxv, maxv, maxv1}}, true, false},
|
|
TestCase{{miopenHalf, {maxv1, maxv, maxv, maxv}, {maxv, maxv, maxv, maxv}}, false, true},
|
|
|
|
TestCase{{miopenHalf, {maxv, maxv1, maxv1, maxv1}, {1, 1, 1, 1}}, false, true},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {maxv1, maxv, maxv1, maxv1}}, true, false},
|
|
TestCase{{miopenHalf, {maxv1, maxv1, maxv1, maxv}, {maxv1, maxv1, maxv1, maxv1}}, false, false},
|
|
|
|
// Boundary at exactly INT_MAX in a single position (other positions trivial).
|
|
// CheckDimsFitIntoInt uses strict `>`, so exactly INT_MAX must pass.
|
|
TestCase{{miopenHalf, {1, 1, 1, maxv}, {1, 1, 1, 1}}, true, true},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1, 1, 1, maxv}}, true, true},
|
|
// One past INT_MAX in a single position must be rejected.
|
|
TestCase{{miopenHalf, {1, 1, 1, maxv1}, {1, 1, 1, 1}}, false, true},
|
|
TestCase{{miopenHalf, {1, 1, 1, 1}, {1, 1, 1, maxv1}}, true, false},
|
|
// clang-format on
|
|
};
|
|
}
|
|
|
|
void RunTest()
|
|
{
|
|
const auto p = GetParam();
|
|
const auto td = p.tp.GetTensorDescriptor();
|
|
const auto all_dims_fit_into_int = (p.lens_fit_into_int && p.strides_fit_into_int);
|
|
ASSERT_EQ(td.AllLengthsFitIntoInt(), p.lens_fit_into_int);
|
|
ASSERT_EQ(td.AllDimsFitIntoInt(), all_dims_fit_into_int);
|
|
}
|
|
};
|
|
|
|
} // namespace
|
|
|
|
using CPU_TensorTestPossibleLayout4D5D_NONE = TestPossibleLayout4D5D;
|
|
using CPU_TensorTestGetLayoutT_NONE = TestGetLayoutT;
|
|
using CPU_TensorTestGetLayoutEnum_NONE = TestGetLayoutEnum;
|
|
using CPU_TensorTestGetLayoutStr_NONE = TestGetLayoutStr;
|
|
using CPU_TensorTestLayoutEnumToStr_NONE = TestLayoutEnumToStr;
|
|
using CPU_TensorTestGetLayout_NONE = TestGetLayout;
|
|
using CPU_TensorTestGetVectorLength_NONE = TestGetVectorLength;
|
|
using CPU_TensorTestCheckDimsFitIntoInt_NONE = TestCheckDimsFitIntoInt;
|
|
|
|
TEST_P(CPU_TensorTestPossibleLayout4D5D_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestGetLayoutT_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestGetLayoutEnum_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestGetLayoutStr_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestLayoutEnumToStr_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestGetLayout_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestGetVectorLength_NONE, TensorDescriptor) { this->RunTest(); };
|
|
TEST_P(CPU_TensorTestCheckDimsFitIntoInt_NONE, TensorDescriptor) { this->RunTest(); };
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestPossibleLayout4D5D_NONE,
|
|
testing::ValuesIn(TestPossibleLayout4D5D::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestGetLayoutT_NONE,
|
|
testing::ValuesIn(TestGetLayoutT::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestGetLayoutEnum_NONE,
|
|
testing::ValuesIn(TestGetLayoutEnum::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestGetLayoutStr_NONE,
|
|
testing::ValuesIn(TestGetLayoutStr::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestLayoutEnumToStr_NONE,
|
|
testing::ValuesIn(TestLayoutEnumToStr::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestGetLayout_NONE,
|
|
testing::ValuesIn(TestGetLayout::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestGetVectorLength_NONE,
|
|
testing::ValuesIn(TestGetVectorLength::GetTestCases()));
|
|
|
|
INSTANTIATE_TEST_SUITE_P(Full,
|
|
CPU_TensorTestCheckDimsFitIntoInt_NONE,
|
|
testing::ValuesIn(TestCheckDimsFitIntoInt::GetTestCases()));
|