Skip to content

GitLab

Unverified Commit d3051d75 authored by Chao Liu's avatar Chao Liu Committed by GitHub
Browse files

add license in file (#303)

parent d1db6a0c
Hide whitespace changes
Inline Side-by-side
Showing with 1030 additions and 970 deletions
profiler/src/profile_gemm_bias_2d.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
profiler/src/profile_gemm_bias_add_reduce.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
profiler/src/profile_gemm_bias_relu.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
profiler/src/profile_gemm_bias_relu_add.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
profiler/src/profile_gemm_reduce.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
profiler/src/profile_grouped_gemm.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
profiler/src/profile_reduce.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
#include <cstdlib> #include <cstdlib>
......
profiler/src/profiler.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
test/batched_gemm/batched_gemm_fp16.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include "profiler/include/profile_batched_gemm_impl.hpp" #include "profiler/include/profile_batched_gemm_impl.hpp"
......
test/batched_gemm/batched_gemm_util.hpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#ifndef BATCHED_GEMM_UTILS_HPP #ifndef BATCHED_GEMM_UTILS_HPP
#define BATCHED_GEMM_UTILS_HPP #define BATCHED_GEMM_UTILS_HPP
......
test/batched_gemm_reduce/batched_gemm_reduce_fp16.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include "profiler/include/profile_batched_gemm_reduce_impl.hpp" #include "profiler/include/profile_batched_gemm_reduce_impl.hpp"
......
test/block_to_ctile_map/test_block_to_ctile_map.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#include <gtest/gtest.h> #include <gtest/gtest.h>
......
test/conv2d_bwd_data/conv2d_bwd_data.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include "config.hpp" #include "config.hpp"
#include "device.hpp" #include "device.hpp"
#include "host_tensor.hpp" #include "host_tensor.hpp"
......
test/conv2d_bwd_weight/conv2d_bwd_weight.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
test/conv_util/conv_util.cpp
View file @ d3051d75
#include <iostream> // SPDX-License-Identifier: MIT
#include <string> // Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <vector>
#include <gtest/gtest.h> #include <iostream>
#include <string>
#include "ck/ck.hpp" #include <vector>
#include "ck/tensor_operation/gpu/device/tensor_layout.hpp" #include <gtest/gtest.h>
#include "ck/library/utility/check_err.hpp" #include "ck/ck.hpp"
#include "ck/library/utility/conv_util.hpp" #include "ck/tensor_operation/gpu/device/tensor_layout.hpp"
namespace { #include "ck/library/utility/check_err.hpp"
#include "ck/library/utility/conv_util.hpp"
class TestConvUtil : public ::testing::Test
{ namespace {
public:
void SetNDParams(std::size_t ndims) class TestConvUtil : public ::testing::Test
{ {
conv_params.num_dim_spatial_ = ndims; public:
conv_params.filter_spatial_lengths_ = std::vector<ck::index_t>(ndims, 3); void SetNDParams(std::size_t ndims)
conv_params.input_spatial_lengths_ = std::vector<ck::index_t>(ndims, 71); {
conv_params.conv_filter_strides_ = std::vector<ck::index_t>(ndims, 2); conv_params.num_dim_spatial_ = ndims;
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>(ndims, 1); conv_params.filter_spatial_lengths_ = std::vector<ck::index_t>(ndims, 3);
conv_params.input_left_pads_ = std::vector<ck::index_t>(ndims, 1); conv_params.input_spatial_lengths_ = std::vector<ck::index_t>(ndims, 71);
conv_params.input_right_pads_ = std::vector<ck::index_t>(ndims, 1); conv_params.conv_filter_strides_ = std::vector<ck::index_t>(ndims, 2);
} conv_params.conv_filter_dilations_ = std::vector<ck::index_t>(ndims, 1);
conv_params.input_left_pads_ = std::vector<ck::index_t>(ndims, 1);
protected: conv_params.input_right_pads_ = std::vector<ck::index_t>(ndims, 1);
// ------- default 2D ------- }
// input NCHW {128,192,71,71},
// weights KCYX {256,192,3,3}, protected:
// stride {2,2}, // ------- default 2D -------
// dilations {1,1}, // input NCHW {128,192,71,71},
// padding {{1,1}, {1,1}} // weights KCYX {256,192,3,3},
ck::utils::conv::ConvParams conv_params; // stride {2,2},
}; // dilations {1,1},
// padding {{1,1}, {1,1}}
} // namespace ck::utils::conv::ConvParams conv_params;
};
TEST_F(TestConvUtil, ConvParamsGetOutputSpatialLengths2D)
{ } // namespace
ck::utils::conv::ConvParams conv_params;
std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths(); TEST_F(TestConvUtil, ConvParamsGetOutputSpatialLengths2D)
EXPECT_TRUE(ck::utils::check_err(out_spatial_len, {
std::vector<ck::index_t>{36, 36}, ck::utils::conv::ConvParams conv_params;
"Error: ConvParams 2D default constructor.")); std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths();
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1}; std::vector<ck::index_t>{36, 36},
out_spatial_len = conv_params.GetOutputSpatialLengths(); "Error: ConvParams 2D default constructor."));
EXPECT_TRUE(ck::utils::check_err(
out_spatial_len, std::vector<ck::index_t>{71, 71}, "Error: ConvParams 2D stride {1,1}.")); conv_params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1};
out_spatial_len = conv_params.GetOutputSpatialLengths();
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{2, 2}; EXPECT_TRUE(ck::utils::check_err(
conv_params.input_left_pads_ = std::vector<ck::index_t>{2, 2}; out_spatial_len, std::vector<ck::index_t>{71, 71}, "Error: ConvParams 2D stride {1,1}."));
conv_params.input_right_pads_ = std::vector<ck::index_t>{2, 2};
out_spatial_len = conv_params.GetOutputSpatialLengths(); conv_params.conv_filter_strides_ = std::vector<ck::index_t>{2, 2};
EXPECT_TRUE(ck::utils::check_err(out_spatial_len, conv_params.input_left_pads_ = std::vector<ck::index_t>{2, 2};
std::vector<ck::index_t>{37, 37}, conv_params.input_right_pads_ = std::vector<ck::index_t>{2, 2};
"Error: ConvParams 2D padding left/right {2,2}.")); out_spatial_len = conv_params.GetOutputSpatialLengths();
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2}; std::vector<ck::index_t>{37, 37},
out_spatial_len = conv_params.GetOutputSpatialLengths(); "Error: ConvParams 2D padding left/right {2,2}."));
EXPECT_TRUE(ck::utils::check_err(
out_spatial_len, std::vector<ck::index_t>{36, 36}, "Error: ConvParams 2D dilation {2,2}.")); conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2};
out_spatial_len = conv_params.GetOutputSpatialLengths();
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{3, 3}; EXPECT_TRUE(ck::utils::check_err(
conv_params.input_left_pads_ = std::vector<ck::index_t>{1, 1}; out_spatial_len, std::vector<ck::index_t>{36, 36}, "Error: ConvParams 2D dilation {2,2}."));
conv_params.input_right_pads_ = std::vector<ck::index_t>{1, 1};
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2}; conv_params.conv_filter_strides_ = std::vector<ck::index_t>{3, 3};
out_spatial_len = conv_params.GetOutputSpatialLengths(); conv_params.input_left_pads_ = std::vector<ck::index_t>{1, 1};
EXPECT_TRUE( conv_params.input_right_pads_ = std::vector<ck::index_t>{1, 1};
ck::utils::check_err(out_spatial_len, conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2};
std::vector<ck::index_t>{23, 23}, out_spatial_len = conv_params.GetOutputSpatialLengths();
"Error: ConvParams 2D strides{3,3}, padding {1,1}, dilations {2,2}.")); EXPECT_TRUE(
} ck::utils::check_err(out_spatial_len,
std::vector<ck::index_t>{23, 23},
TEST_F(TestConvUtil, ConvParamsGetOutputSpatialLengths1D) "Error: ConvParams 2D strides{3,3}, padding {1,1}, dilations {2,2}."));
{ }
SetNDParams(1);
TEST_F(TestConvUtil, ConvParamsGetOutputSpatialLengths1D)
std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths(); {
EXPECT_TRUE(ck::utils::check_err( SetNDParams(1);
out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D."));
std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths();
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{1}; EXPECT_TRUE(ck::utils::check_err(
out_spatial_len = conv_params.GetOutputSpatialLengths(); out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D."));
EXPECT_TRUE(ck::utils::check_err(
out_spatial_len, std::vector<ck::index_t>{71}, "Error: ConvParams 1D stride {1}.")); conv_params.conv_filter_strides_ = std::vector<ck::index_t>{1};
out_spatial_len = conv_params.GetOutputSpatialLengths();
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{2}; EXPECT_TRUE(ck::utils::check_err(
conv_params.input_left_pads_ = std::vector<ck::index_t>{2}; out_spatial_len, std::vector<ck::index_t>{71}, "Error: ConvParams 1D stride {1}."));
conv_params.input_right_pads_ = std::vector<ck::index_t>{2};
out_spatial_len = conv_params.GetOutputSpatialLengths(); conv_params.conv_filter_strides_ = std::vector<ck::index_t>{2};
EXPECT_TRUE(ck::utils::check_err(out_spatial_len, conv_params.input_left_pads_ = std::vector<ck::index_t>{2};
std::vector<ck::index_t>{37}, conv_params.input_right_pads_ = std::vector<ck::index_t>{2};
"Error: ConvParams 1D padding left/right {2}.")); out_spatial_len = conv_params.GetOutputSpatialLengths();
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2}; std::vector<ck::index_t>{37},
out_spatial_len = conv_params.GetOutputSpatialLengths(); "Error: ConvParams 1D padding left/right {2}."));
EXPECT_TRUE(ck::utils::check_err(
out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D dilation {2}.")); conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2};
out_spatial_len = conv_params.GetOutputSpatialLengths();
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{3}; EXPECT_TRUE(ck::utils::check_err(
conv_params.input_left_pads_ = std::vector<ck::index_t>{1}; out_spatial_len, std::vector<ck::index_t>{36}, "Error: ConvParams 1D dilation {2}."));
conv_params.input_right_pads_ = std::vector<ck::index_t>{1};
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2}; conv_params.conv_filter_strides_ = std::vector<ck::index_t>{3};
out_spatial_len = conv_params.GetOutputSpatialLengths(); conv_params.input_left_pads_ = std::vector<ck::index_t>{1};
EXPECT_TRUE( conv_params.input_right_pads_ = std::vector<ck::index_t>{1};
ck::utils::check_err(out_spatial_len, conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2};
std::vector<ck::index_t>{23}, out_spatial_len = conv_params.GetOutputSpatialLengths();
"Error: ConvParams 1D strides{3}, padding {1}, dilations {2}.")); EXPECT_TRUE(
} ck::utils::check_err(out_spatial_len,
std::vector<ck::index_t>{23},
TEST_F(TestConvUtil, ConvParamsGetOutputSpatialLengths3D) "Error: ConvParams 1D strides{3}, padding {1}, dilations {2}."));
{ }
SetNDParams(3);
TEST_F(TestConvUtil, ConvParamsGetOutputSpatialLengths3D)
std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths(); {
EXPECT_TRUE(ck::utils::check_err( SetNDParams(3);
out_spatial_len, std::vector<ck::index_t>{36, 36, 36}, "Error: ConvParams 3D."));
std::vector<ck::index_t> out_spatial_len = conv_params.GetOutputSpatialLengths();
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1}; EXPECT_TRUE(ck::utils::check_err(
out_spatial_len = conv_params.GetOutputSpatialLengths(); out_spatial_len, std::vector<ck::index_t>{36, 36, 36}, "Error: ConvParams 3D."));
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
std::vector<ck::index_t>{71, 71, 71}, conv_params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1};
"Error: ConvParams 3D stride {1, 1, 1}.")); out_spatial_len = conv_params.GetOutputSpatialLengths();
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{2, 2, 2}; std::vector<ck::index_t>{71, 71, 71},
conv_params.input_left_pads_ = std::vector<ck::index_t>{2, 2, 2}; "Error: ConvParams 3D stride {1, 1, 1}."));
conv_params.input_right_pads_ = std::vector<ck::index_t>{2, 2, 2};
out_spatial_len = conv_params.GetOutputSpatialLengths(); conv_params.conv_filter_strides_ = std::vector<ck::index_t>{2, 2, 2};
EXPECT_TRUE(ck::utils::check_err(out_spatial_len, conv_params.input_left_pads_ = std::vector<ck::index_t>{2, 2, 2};
std::vector<ck::index_t>{37, 37, 37}, conv_params.input_right_pads_ = std::vector<ck::index_t>{2, 2, 2};
"Error: ConvParams 3D padding left/right {2, 2, 2}.")); out_spatial_len = conv_params.GetOutputSpatialLengths();
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2, 2}; std::vector<ck::index_t>{37, 37, 37},
out_spatial_len = conv_params.GetOutputSpatialLengths(); "Error: ConvParams 3D padding left/right {2, 2, 2}."));
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
std::vector<ck::index_t>{36, 36, 36}, conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2, 2};
"Error: ConvParams 3D dilation {2, 2, 2}.")); out_spatial_len = conv_params.GetOutputSpatialLengths();
EXPECT_TRUE(ck::utils::check_err(out_spatial_len,
conv_params.conv_filter_strides_ = std::vector<ck::index_t>{3, 3, 3}; std::vector<ck::index_t>{36, 36, 36},
conv_params.input_left_pads_ = std::vector<ck::index_t>{1, 1, 1}; "Error: ConvParams 3D dilation {2, 2, 2}."));
conv_params.input_right_pads_ = std::vector<ck::index_t>{1, 1, 1};
conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2, 2}; conv_params.conv_filter_strides_ = std::vector<ck::index_t>{3, 3, 3};
out_spatial_len = conv_params.GetOutputSpatialLengths(); conv_params.input_left_pads_ = std::vector<ck::index_t>{1, 1, 1};
EXPECT_TRUE(ck::utils::check_err( conv_params.input_right_pads_ = std::vector<ck::index_t>{1, 1, 1};
out_spatial_len, conv_params.conv_filter_dilations_ = std::vector<ck::index_t>{2, 2, 2};
std::vector<ck::index_t>{23, 23, 23}, out_spatial_len = conv_params.GetOutputSpatialLengths();
"Error: ConvParams 3D strides{3, 3, 3}, padding {1, 1, 1}, dilations {2, 2, 2}.")); EXPECT_TRUE(ck::utils::check_err(
} out_spatial_len,
std::vector<ck::index_t>{23, 23, 23},
TEST(ConvUtil, GetHostTensorDescriptor) "Error: ConvParams 3D strides{3, 3, 3}, padding {1, 1, 1}, dilations {2, 2, 2}."));
{ }
namespace tl = ck::tensor_layout::convolution;
std::vector<std::size_t> dims{2, 3, 4, 5}; TEST(ConvUtil, GetHostTensorDescriptor)
HostTensorDescriptor h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NHWC{}); {
EXPECT_TRUE(ck::utils::check_err( namespace tl = ck::tensor_layout::convolution;
h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NHWC dimensions lengths!")); std::vector<std::size_t> dims{2, 3, 4, 5};
EXPECT_TRUE(ck::utils::check_err( HostTensorDescriptor h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NHWC{});
h.GetStrides(), {3 * 4 * 5, 1, 3 * 5, 3}, "Error: wrong NHWC dimensions strides!")); EXPECT_TRUE(ck::utils::check_err(
h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NHWC dimensions lengths!"));
h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCHW{}); EXPECT_TRUE(ck::utils::check_err(
EXPECT_TRUE(ck::utils::check_err( h.GetStrides(), {3 * 4 * 5, 1, 3 * 5, 3}, "Error: wrong NHWC dimensions strides!"));
h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NCHW dimensions lengths!"));
EXPECT_TRUE(ck::utils::check_err( h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCHW{});
h.GetStrides(), {3 * 4 * 5, 4 * 5, 5, 1}, "Error: wrong NCHW dimensions strides!")); EXPECT_TRUE(ck::utils::check_err(
h.GetLengths(), {2, 3, 4, 5}, "Error: wrong NCHW dimensions lengths!"));
dims = std::vector<std::size_t>{2, 3, 4}; EXPECT_TRUE(ck::utils::check_err(
h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NWC{}); h.GetStrides(), {3 * 4 * 5, 4 * 5, 5, 1}, "Error: wrong NCHW dimensions strides!"));
EXPECT_TRUE(
ck::utils::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NWC dimensions lengths!")); dims = std::vector<std::size_t>{2, 3, 4};
EXPECT_TRUE(ck::utils::check_err( h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NWC{});
h.GetStrides(), {3 * 4, 1, 3}, "Error: wrong NWC dimensions strides!")); EXPECT_TRUE(
ck::utils::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NWC dimensions lengths!"));
h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCW{}); EXPECT_TRUE(ck::utils::check_err(
EXPECT_TRUE( h.GetStrides(), {3 * 4, 1, 3}, "Error: wrong NWC dimensions strides!"));
ck::utils::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NCW dimensions lengths!"));
EXPECT_TRUE(ck::utils::check_err( h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCW{});
h.GetStrides(), {3 * 4, 4, 1}, "Error: wrong NCW dimensions strides!")); EXPECT_TRUE(
ck::utils::check_err(h.GetLengths(), {2, 3, 4}, "Error: wrong NCW dimensions lengths!"));
dims = std::vector<std::size_t>{2, 3, 4, 5, 6}; EXPECT_TRUE(ck::utils::check_err(
h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NDHWC{}); h.GetStrides(), {3 * 4, 4, 1}, "Error: wrong NCW dimensions strides!"));
EXPECT_TRUE(
ck::utils::check_err(h.GetLengths(), dims, "Error: wrong NDHWC dimensions lengths!")); dims = std::vector<std::size_t>{2, 3, 4, 5, 6};
EXPECT_TRUE(ck::utils::check_err(h.GetStrides(), h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NDHWC{});
{3 * 4 * 5 * 6, // N EXPECT_TRUE(
1, // C ck::utils::check_err(h.GetLengths(), dims, "Error: wrong NDHWC dimensions lengths!"));
3 * 5 * 6, // D EXPECT_TRUE(ck::utils::check_err(h.GetStrides(),
3 * 6, // H {3 * 4 * 5 * 6, // N
3}, // W 1, // C
"Error: wrong NDHWC dimensions strides!")); 3 * 5 * 6, // D
3 * 6, // H
h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCDHW{}); 3}, // W
EXPECT_TRUE( "Error: wrong NDHWC dimensions strides!"));
ck::utils::check_err(h.GetLengths(), dims, "Error: wrong NCDHW dimensions lengths!"));
EXPECT_TRUE(ck::utils::check_err(h.GetStrides(), h = ck::utils::conv::get_host_tensor_descriptor(dims, tl::NCDHW{});
{3 * 4 * 5 * 6, // N EXPECT_TRUE(
4 * 5 * 6, // C ck::utils::check_err(h.GetLengths(), dims, "Error: wrong NCDHW dimensions lengths!"));
5 * 6, // D EXPECT_TRUE(ck::utils::check_err(h.GetStrides(),
6, // H {3 * 4 * 5 * 6, // N
1}, // W 4 * 5 * 6, // C
"Error: wrong NCDHW dimensions strides!")); 5 * 6, // D
} 6, // H
1}, // W
"Error: wrong NCDHW dimensions strides!"));
}
test/convnd_bwd_data/convnd_bwd_data.cpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <iostream> #include <iostream>
#include <numeric> #include <numeric>
#include <initializer_list> #include <initializer_list>
......
test/convnd_fwd/conv1d_fwd.cpp
View file @ d3051d75
#include <iostream> // SPDX-License-Identifier: MIT
#include <tuple> // Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <vector>
#include <gtest/gtest.h> #include <iostream>
#include <tuple>
#include "ck/utility/data_type.hpp" #include <vector>
#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp" #include <gtest/gtest.h>
#include "ck/library/utility/conv_util.hpp"
#include "test/convnd_fwd/conv_util.hpp" #include "ck/utility/data_type.hpp"
#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp"
namespace { #include "ck/library/utility/conv_util.hpp"
#include "test/convnd_fwd/conv_util.hpp"
class Conv1dFwdNWCInstances : public ::testing::Test
{ namespace {
public:
template <typename T> class Conv1dFwdNWCInstances : public ::testing::Test
bool test_conv1d_nwc_instances(const std::vector<test::conv::DeviceConvFwdNoOpPtr>& conv_ptrs, {
const ck::utils::conv::ConvParams& params) public:
{ template <typename T>
using namespace std::placeholders; bool test_conv1d_nwc_instances(const std::vector<test::conv::DeviceConvFwdNoOpPtr>& conv_ptrs,
using namespace ck::utils; const ck::utils::conv::ConvParams& params)
namespace ctl = ck::tensor_layout::convolution; {
using namespace std::placeholders;
conv::ConvFwdOpInstance<T, using namespace ck::utils;
T, namespace ctl = ck::tensor_layout::convolution;
T,
ctl::NWC, conv::ConvFwdOpInstance<T,
ctl::KXC, T,
ctl::NWK, T,
ck::tensor_operation::element_wise::PassThrough, ctl::NWC,
ck::tensor_operation::element_wise::PassThrough, ctl::KXC,
ck::tensor_operation::element_wise::PassThrough, ctl::NWK,
FillUniformDistributionIntegerValue<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistributionIntegerValue<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, ck::tensor_operation::element_wise::PassThrough,
true, FillUniformDistributionIntegerValue<T>,
FillUniformDistributionIntegerValue<T>{}, FillUniformDistributionIntegerValue<T>>
FillUniformDistributionIntegerValue<T>{}); conv_instance(params,
auto reference_conv_fwd_fun = true,
std::bind(conv::run_reference_convolution_forward<1, T, T, T>, params, _1, _2, _3); FillUniformDistributionIntegerValue<T>{},
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun); FillUniformDistributionIntegerValue<T>{});
run_engine.SetAtol(atol_); auto reference_conv_fwd_fun =
run_engine.SetRtol(rtol_); std::bind(conv::run_reference_convolution_forward<1, T, T, T>, params, _1, _2, _3);
return run_engine.Test(conv_ptrs); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(atol_);
run_engine.SetRtol(rtol_);
template <typename T> return run_engine.Test(conv_ptrs);
bool test_default() }
{
return test_conv1d_nwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<1>(), params_default_); bool test_default()
} {
return test_conv1d_nwc_instances<T>(
template <typename T> ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<1>(), params_default_);
bool test_filter1x1_stride1_pad0() }
{
return test_conv1d_nwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<1>(), bool test_filter1x1_stride1_pad0()
params_filter1x1_stride1_pad0_); {
} return test_conv1d_nwc_instances<T>(
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<1>(),
template <typename T> params_filter1x1_stride1_pad0_);
bool test_filter1x1_pad0() }
{
return test_conv1d_nwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<1>(), bool test_filter1x1_pad0()
params_filter1x1_pad0_); {
} return test_conv1d_nwc_instances<T>(
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<1>(),
static inline ck::utils::conv::ConvParams params_default_{ params_filter1x1_pad0_);
1, 4, 256, 64, {3}, {71}, {2}, {2}, {2}, {2}}; }
static inline ck::utils::conv::ConvParams params_filter1x1_stride1_pad0_{
1, 4, 256, 64, {1}, {28}, {1}, {1}, {0}, {0}}; static inline ck::utils::conv::ConvParams params_default_{
static inline ck::utils::conv::ConvParams params_filter1x1_pad0_{ 1, 4, 256, 64, {3}, {71}, {2}, {2}, {2}, {2}};
1, 4, 256, 64, {1}, {28}, {2}, {1}, {0}, {0}}; static inline ck::utils::conv::ConvParams params_filter1x1_stride1_pad0_{
1, 4, 256, 64, {1}, {28}, {1}, {1}, {0}, {0}};
private: static inline ck::utils::conv::ConvParams params_filter1x1_pad0_{
double atol_{1e-5}; 1, 4, 256, 64, {1}, {28}, {2}, {1}, {0}, {0}};
double rtol_{1e-4};
}; private:
double atol_{1e-5};
} // anonymous namespace double rtol_{1e-4};
};
TEST(Conv1DFwdNWC, IntegerValues)
{ } // anonymous namespace
using namespace std::placeholders;
using namespace ck::utils; TEST(Conv1DFwdNWC, IntegerValues)
namespace ctl = ck::tensor_layout::convolution; {
using T = float; using namespace std::placeholders;
using namespace ck::utils;
ck::utils::conv::ConvParams params{1, 4, 256, 64, {3}, {36}, {1}, {2}, {2}, {2}}; namespace ctl = ck::tensor_layout::convolution;
using T = float;
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
test::conv::get_test_convolution_fwd_instance<1, T, T, T, T>(conv_ptrs); ck::utils::conv::ConvParams params{1, 4, 256, 64, {3}, {36}, {1}, {2}, {2}, {2}};
conv::ConvFwdOpInstance<T,
T, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
T, test::conv::get_test_convolution_fwd_instance<1, T, T, T, T>(conv_ptrs);
ctl::NWC, conv::ConvFwdOpInstance<T,
ctl::KXC, T,
ctl::NWK, T,
ck::tensor_operation::element_wise::PassThrough, ctl::NWC,
ck::tensor_operation::element_wise::PassThrough, ctl::KXC,
ck::tensor_operation::element_wise::PassThrough, ctl::NWK,
FillUniformDistributionIntegerValue<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistributionIntegerValue<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, ck::tensor_operation::element_wise::PassThrough,
true, FillUniformDistributionIntegerValue<T>,
FillUniformDistributionIntegerValue<T>{}, FillUniformDistributionIntegerValue<T>>
FillUniformDistributionIntegerValue<T>{}); conv_instance(params,
true,
auto reference_conv_fwd_fun = FillUniformDistributionIntegerValue<T>{},
std::bind(conv::run_reference_convolution_forward<1, T, T, T>, params, _1, _2, _3); FillUniformDistributionIntegerValue<T>{});
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
run_engine.SetAtol(1e-5); auto reference_conv_fwd_fun =
run_engine.SetRtol(1e-4); std::bind(conv::run_reference_convolution_forward<1, T, T, T>, params, _1, _2, _3);
EXPECT_TRUE(run_engine.Test(conv_ptrs)); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(1e-5);
run_engine.SetRtol(1e-4);
TEST(Conv1DFwdNWC, FloatingPointValues) EXPECT_TRUE(run_engine.Test(conv_ptrs));
{ }
using namespace std::placeholders;
using namespace ck::utils; TEST(Conv1DFwdNWC, FloatingPointValues)
namespace ctl = ck::tensor_layout::convolution; {
using T = ck::half_t; using namespace std::placeholders;
using namespace ck::utils;
ck::utils::conv::ConvParams params{1, 4, 256, 64, {3}, {36}, {1}, {2}, {2}, {2}}; namespace ctl = ck::tensor_layout::convolution;
using T = ck::half_t;
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
test::conv::get_test_convolution_fwd_instance<1, T, T, T, float>(conv_ptrs); ck::utils::conv::ConvParams params{1, 4, 256, 64, {3}, {36}, {1}, {2}, {2}, {2}};
conv::ConvFwdOpInstance<T,
T, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
T, test::conv::get_test_convolution_fwd_instance<1, T, T, T, float>(conv_ptrs);
ctl::NWC, conv::ConvFwdOpInstance<T,
ctl::KXC, T,
ctl::NWK, T,
ck::tensor_operation::element_wise::PassThrough, ctl::NWC,
ck::tensor_operation::element_wise::PassThrough, ctl::KXC,
ck::tensor_operation::element_wise::PassThrough, ctl::NWK,
FillUniformDistribution<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistribution<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, true, FillUniformDistribution<T>{}, FillUniformDistribution<T>{}); ck::tensor_operation::element_wise::PassThrough,
FillUniformDistribution<T>,
auto reference_conv_fwd_fun = FillUniformDistribution<T>>
std::bind(conv::run_reference_convolution_forward<1, T, T, T>, params, _1, _2, _3); conv_instance(params, true, FillUniformDistribution<T>{}, FillUniformDistribution<T>{});
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
run_engine.SetAtol(0.1); auto reference_conv_fwd_fun =
run_engine.SetRtol(1e-2); std::bind(conv::run_reference_convolution_forward<1, T, T, T>, params, _1, _2, _3);
EXPECT_TRUE(run_engine.Test(conv_ptrs)); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(0.1);
run_engine.SetRtol(1e-2);
TEST_F(Conv1dFwdNWCInstances, BF16_default) { EXPECT_TRUE(this->test_default<ck::bhalf_t>()); } EXPECT_TRUE(run_engine.Test(conv_ptrs));
TEST_F(Conv1dFwdNWCInstances, BF16_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>()); TEST_F(Conv1dFwdNWCInstances, BF16_default) { EXPECT_TRUE(this->test_default<ck::bhalf_t>()); }
} TEST_F(Conv1dFwdNWCInstances, BF16_filter1x1_stride1_pad0)
TEST_F(Conv1dFwdNWCInstances, BF16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>()); }
} TEST_F(Conv1dFwdNWCInstances, BF16_filter1x1_pad0)
{
TEST_F(Conv1dFwdNWCInstances, F16_default) { EXPECT_TRUE(this->test_default<ck::half_t>()); } EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>());
TEST_F(Conv1dFwdNWCInstances, F16_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>()); TEST_F(Conv1dFwdNWCInstances, F16_default) { EXPECT_TRUE(this->test_default<ck::half_t>()); }
} TEST_F(Conv1dFwdNWCInstances, F16_filter1x1_stride1_pad0)
TEST_F(Conv1dFwdNWCInstances, F16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>()); }
} TEST_F(Conv1dFwdNWCInstances, F16_filter1x1_pad0)
{
TEST_F(Conv1dFwdNWCInstances, F32_default) { EXPECT_TRUE(this->test_default<float>()); } EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>());
TEST_F(Conv1dFwdNWCInstances, F32_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>()); TEST_F(Conv1dFwdNWCInstances, F32_default) { EXPECT_TRUE(this->test_default<float>()); }
} TEST_F(Conv1dFwdNWCInstances, F32_filter1x1_stride1_pad0)
TEST_F(Conv1dFwdNWCInstances, F32_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>());
EXPECT_TRUE(this->test_filter1x1_pad0<float>()); }
} TEST_F(Conv1dFwdNWCInstances, F32_filter1x1_pad0)
{
TEST_F(Conv1dFwdNWCInstances, I8_default) { EXPECT_TRUE(this->test_default<int8_t>()); } EXPECT_TRUE(this->test_filter1x1_pad0<float>());
TEST_F(Conv1dFwdNWCInstances, I8_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>()); TEST_F(Conv1dFwdNWCInstances, I8_default) { EXPECT_TRUE(this->test_default<int8_t>()); }
} TEST_F(Conv1dFwdNWCInstances, I8_filter1x1_stride1_pad0)
TEST_F(Conv1dFwdNWCInstances, I8_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>()); }
} TEST_F(Conv1dFwdNWCInstances, I8_filter1x1_pad0)
{
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>());
}
test/convnd_fwd/conv2d_fwd.cpp
View file @ d3051d75
#include <tuple> // SPDX-License-Identifier: MIT
#include <vector> // Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <gtest/gtest.h>
#include <tuple>
#include "ck/utility/data_type.hpp" #include <vector>
#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp" #include <gtest/gtest.h>
#include "ck/library/utility/conv_util.hpp"
#include "test/convnd_fwd/conv_util.hpp" #include "ck/utility/data_type.hpp"
#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp"
namespace { #include "ck/library/utility/conv_util.hpp"
#include "test/convnd_fwd/conv_util.hpp"
class Conv2dFwdNHWCInstances : public ::testing::Test
{ namespace {
public:
template <typename T> class Conv2dFwdNHWCInstances : public ::testing::Test
bool test_conv2d_nhwc_instances(const std::vector<test::conv::DeviceConvFwdNoOpPtr>& conv_ptrs, {
const ck::utils::conv::ConvParams& params) public:
{ template <typename T>
using namespace std::placeholders; bool test_conv2d_nhwc_instances(const std::vector<test::conv::DeviceConvFwdNoOpPtr>& conv_ptrs,
using namespace ck::utils; const ck::utils::conv::ConvParams& params)
{
conv::ConvFwdOpInstance<T, using namespace std::placeholders;
T, using namespace ck::utils;
T,
ck::tensor_layout::convolution::NHWC, conv::ConvFwdOpInstance<T,
ck::tensor_layout::convolution::KYXC, T,
ck::tensor_layout::convolution::NHWK, T,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::NHWC,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::KYXC,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::NHWK,
FillUniformDistributionIntegerValue<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistributionIntegerValue<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, ck::tensor_operation::element_wise::PassThrough,
true, FillUniformDistributionIntegerValue<T>,
FillUniformDistributionIntegerValue<T>{}, FillUniformDistributionIntegerValue<T>>
FillUniformDistributionIntegerValue<T>{}); conv_instance(params,
auto reference_conv_fwd_fun = true,
std::bind(conv::run_reference_convolution_forward<2, T, T, T>, params, _1, _2, _3); FillUniformDistributionIntegerValue<T>{},
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun); FillUniformDistributionIntegerValue<T>{});
run_engine.SetAtol(atol_); auto reference_conv_fwd_fun =
run_engine.SetRtol(rtol_); std::bind(conv::run_reference_convolution_forward<2, T, T, T>, params, _1, _2, _3);
return run_engine.Test(conv_ptrs); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(atol_);
run_engine.SetRtol(rtol_);
template <typename T> return run_engine.Test(conv_ptrs);
bool test_default(bool use_convnd = false) }
{
if(use_convnd) template <typename T>
{ bool test_default(bool use_convnd = false)
return test_conv2d_nhwc_instances<T>( {
test::conv::ConvolutionNDFwdInstances<T, T, T>::Get(2), params_default_); if(use_convnd)
} {
else return test_conv2d_nhwc_instances<T>(
{ test::conv::ConvolutionNDFwdInstances<T, T, T>::Get(2), params_default_);
return test_conv2d_nhwc_instances<T>( }
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(), else
params_default_); {
} return test_conv2d_nhwc_instances<T>(
} ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(),
params_default_);
template <typename T> }
bool test_filter1x1_stride1_pad0(bool use_convnd = false) }
{
if(use_convnd) template <typename T>
{ bool test_filter1x1_stride1_pad0(bool use_convnd = false)
return test_conv2d_nhwc_instances<T>( {
test::conv::ConvolutionNDFwdInstances<T, T, T>::Get(2), if(use_convnd)
params_filter1x1_stride1_pad0_); {
} return test_conv2d_nhwc_instances<T>(
else test::conv::ConvolutionNDFwdInstances<T, T, T>::Get(2),
{ params_filter1x1_stride1_pad0_);
return test_conv2d_nhwc_instances<T>( }
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(), else
params_filter1x1_stride1_pad0_); {
} return test_conv2d_nhwc_instances<T>(
} ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(),
params_filter1x1_stride1_pad0_);
template <typename T> }
bool test_filter1x1_pad0(bool use_convnd = false) }
{
if(use_convnd) template <typename T>
{ bool test_filter1x1_pad0(bool use_convnd = false)
return test_conv2d_nhwc_instances<T>( {
test::conv::ConvolutionNDFwdInstances<T, T, T>::Get(2), params_filter1x1_pad0_); if(use_convnd)
} {
else return test_conv2d_nhwc_instances<T>(
{ test::conv::ConvolutionNDFwdInstances<T, T, T>::Get(2), params_filter1x1_pad0_);
return test_conv2d_nhwc_instances<T>( }
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(), else
params_filter1x1_pad0_); {
} return test_conv2d_nhwc_instances<T>(
} ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(),
params_filter1x1_pad0_);
template <typename T> }
bool test_oddC() }
{
return test_conv2d_nhwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(), params_oddC_); bool test_oddC()
} {
return test_conv2d_nhwc_instances<T>(
static inline ck::utils::conv::ConvParams params_default_{ ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<2>(), params_oddC_);
2, 4, 256, 64, {3, 3}, {36, 36}, {2, 2}, {2, 2}, {2, 2}, {2, 2}}; }
static inline ck::utils::conv::ConvParams params_filter1x1_stride1_pad0_{
2, 4, 256, 64, {1, 1}, {28, 28}, {1, 1}, {1, 1}, {0, 0}, {0, 0}}; static inline ck::utils::conv::ConvParams params_default_{
static inline ck::utils::conv::ConvParams params_filter1x1_pad0_{ 2, 4, 256, 64, {3, 3}, {36, 36}, {2, 2}, {2, 2}, {2, 2}, {2, 2}};
2, 4, 256, 64, {1, 1}, {28, 28}, {2, 2}, {1, 1}, {0, 0}, {0, 0}}; static inline ck::utils::conv::ConvParams params_filter1x1_stride1_pad0_{
static inline ck::utils::conv::ConvParams params_oddC_{ 2, 4, 256, 64, {1, 1}, {28, 28}, {1, 1}, {1, 1}, {0, 0}, {0, 0}};
2, 4, 256, 3, {3, 3}, {28, 28}, {1, 1}, {1, 1}, {0, 0}, {0, 0}}; static inline ck::utils::conv::ConvParams params_filter1x1_pad0_{
2, 4, 256, 64, {1, 1}, {28, 28}, {2, 2}, {1, 1}, {0, 0}, {0, 0}};
private: static inline ck::utils::conv::ConvParams params_oddC_{
double atol_{1e-5}; 2, 4, 256, 3, {3, 3}, {28, 28}, {1, 1}, {1, 1}, {0, 0}, {0, 0}};
double rtol_{1e-4};
}; private:
double atol_{1e-5};
} // anonymous namespace double rtol_{1e-4};
};
TEST(Conv2DFwdNHWC, IntegerValues)
{ } // anonymous namespace
using namespace std::placeholders;
using namespace ck::utils; TEST(Conv2DFwdNHWC, IntegerValues)
using T = float; {
using namespace std::placeholders;
ck::utils::conv::ConvParams params{ using namespace ck::utils;
2, 4, 256, 64, {3, 3}, {36, 36}, {1, 1}, {2, 2}, {2, 2}, {2, 2}}; using T = float;
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; ck::utils::conv::ConvParams params{
test::conv::get_test_convolution_fwd_instance<2, T, T, T, T>(conv_ptrs); 2, 4, 256, 64, {3, 3}, {36, 36}, {1, 1}, {2, 2}, {2, 2}, {2, 2}};
conv::ConvFwdOpInstance<T,
T, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
T, test::conv::get_test_convolution_fwd_instance<2, T, T, T, T>(conv_ptrs);
ck::tensor_layout::convolution::NHWC, conv::ConvFwdOpInstance<T,
ck::tensor_layout::convolution::KYXC, T,
ck::tensor_layout::convolution::NHWK, T,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::NHWC,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::KYXC,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::NHWK,
FillUniformDistributionIntegerValue<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistributionIntegerValue<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, ck::tensor_operation::element_wise::PassThrough,
true, FillUniformDistributionIntegerValue<T>,
FillUniformDistributionIntegerValue<T>{}, FillUniformDistributionIntegerValue<T>>
FillUniformDistributionIntegerValue<T>{}); conv_instance(params,
true,
auto reference_conv_fwd_fun = FillUniformDistributionIntegerValue<T>{},
std::bind(conv::run_reference_convolution_forward<2, T, T, T>, params, _1, _2, _3); FillUniformDistributionIntegerValue<T>{});
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
run_engine.SetAtol(1e-5); auto reference_conv_fwd_fun =
run_engine.SetRtol(1e-4); std::bind(conv::run_reference_convolution_forward<2, T, T, T>, params, _1, _2, _3);
EXPECT_TRUE(run_engine.Test(conv_ptrs)); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(1e-5);
run_engine.SetRtol(1e-4);
TEST(Conv2DFwdNHWC, FloatingPointValues) EXPECT_TRUE(run_engine.Test(conv_ptrs));
{ }
using namespace std::placeholders;
using namespace ck::utils; TEST(Conv2DFwdNHWC, FloatingPointValues)
using T = ck::half_t; {
using namespace std::placeholders;
ck::utils::conv::ConvParams params{ using namespace ck::utils;
2, 4, 256, 64, {3, 3}, {36, 36}, {2, 2}, {2, 2}, {2, 2}, {2, 2}}; using T = ck::half_t;
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; ck::utils::conv::ConvParams params{
test::conv::get_test_convolution_fwd_instance<2, T, T, T, float>(conv_ptrs); 2, 4, 256, 64, {3, 3}, {36, 36}, {2, 2}, {2, 2}, {2, 2}, {2, 2}};
conv::ConvFwdOpInstance<T,
T, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
T, test::conv::get_test_convolution_fwd_instance<2, T, T, T, float>(conv_ptrs);
ck::tensor_layout::convolution::NHWC, conv::ConvFwdOpInstance<T,
ck::tensor_layout::convolution::KYXC, T,
ck::tensor_layout::convolution::NHWK, T,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::NHWC,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::KYXC,
ck::tensor_operation::element_wise::PassThrough, ck::tensor_layout::convolution::NHWK,
FillUniformDistribution<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistribution<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, true, FillUniformDistribution<T>{}, FillUniformDistribution<T>{}); ck::tensor_operation::element_wise::PassThrough,
FillUniformDistribution<T>,
auto reference_conv_fwd_fun = FillUniformDistribution<T>>
std::bind(conv::run_reference_convolution_forward<2, T, T, T>, params, _1, _2, _3); conv_instance(params, true, FillUniformDistribution<T>{}, FillUniformDistribution<T>{});
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
run_engine.SetAtol(2e-4); auto reference_conv_fwd_fun =
run_engine.SetRtol(1e-3); std::bind(conv::run_reference_convolution_forward<2, T, T, T>, params, _1, _2, _3);
EXPECT_TRUE(run_engine.Test(conv_ptrs)); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(2e-4);
run_engine.SetRtol(1e-3);
TEST_F(Conv2dFwdNHWCInstances, BF16_default) { EXPECT_TRUE(this->test_default<ck::bhalf_t>()); } EXPECT_TRUE(run_engine.Test(conv_ptrs));
TEST_F(Conv2dFwdNHWCInstances, BF16_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>()); TEST_F(Conv2dFwdNHWCInstances, BF16_default) { EXPECT_TRUE(this->test_default<ck::bhalf_t>()); }
} TEST_F(Conv2dFwdNHWCInstances, BF16_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, BF16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>()); }
} TEST_F(Conv2dFwdNHWCInstances, BF16_filter1x1_pad0)
TEST_F(Conv2dFwdNHWCInstances, F16_default) { EXPECT_TRUE(this->test_default<ck::half_t>()); } {
TEST_F(Conv2dFwdNHWCInstances, F16_filter1x1_stride1_pad0) EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>());
{ }
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>()); TEST_F(Conv2dFwdNHWCInstances, F16_default) { EXPECT_TRUE(this->test_default<ck::half_t>()); }
} TEST_F(Conv2dFwdNHWCInstances, F16_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, F16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>()); }
} TEST_F(Conv2dFwdNHWCInstances, F16_filter1x1_pad0)
TEST_F(Conv2dFwdNHWCInstances, F16_oddC) { EXPECT_TRUE(this->test_oddC<ck::half_t>()); } {
TEST_F(Conv2dFwdNHWCInstances, F32_default) { EXPECT_TRUE(this->test_default<float>()); } EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>());
TEST_F(Conv2dFwdNHWCInstances, F32_filter1x1_stride1_pad0) }
{ TEST_F(Conv2dFwdNHWCInstances, F16_oddC) { EXPECT_TRUE(this->test_oddC<ck::half_t>()); }
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>()); TEST_F(Conv2dFwdNHWCInstances, F32_default) { EXPECT_TRUE(this->test_default<float>()); }
} TEST_F(Conv2dFwdNHWCInstances, F32_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, F32_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>());
EXPECT_TRUE(this->test_filter1x1_pad0<float>()); }
} TEST_F(Conv2dFwdNHWCInstances, F32_filter1x1_pad0)
TEST_F(Conv2dFwdNHWCInstances, I8_default) { EXPECT_TRUE(this->test_default<int8_t>()); } {
TEST_F(Conv2dFwdNHWCInstances, I8_filter1x1_stride1_pad0) EXPECT_TRUE(this->test_filter1x1_pad0<float>());
{ }
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>()); TEST_F(Conv2dFwdNHWCInstances, I8_default) { EXPECT_TRUE(this->test_default<int8_t>()); }
} TEST_F(Conv2dFwdNHWCInstances, I8_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, I8_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>()); }
} TEST_F(Conv2dFwdNHWCInstances, I8_filter1x1_pad0)
{
TEST_F(Conv2dFwdNHWCInstances, ND_BF16_default) EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>());
{ }
EXPECT_TRUE(this->test_default<ck::bhalf_t>(true));
} TEST_F(Conv2dFwdNHWCInstances, ND_BF16_default)
TEST_F(Conv2dFwdNHWCInstances, ND_BF16_filter1x1_stride1_pad0) {
{ EXPECT_TRUE(this->test_default<ck::bhalf_t>(true));
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_BF16_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_BF16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>(true));
EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_BF16_filter1x1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_F16_default) {
{ EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>(true));
EXPECT_TRUE(this->test_default<ck::half_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_F16_default)
TEST_F(Conv2dFwdNHWCInstances, ND_F16_filter1x1_stride1_pad0) {
{ EXPECT_TRUE(this->test_default<ck::half_t>(true));
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_F16_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_F16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>(true));
EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_F16_filter1x1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_F32_default) { EXPECT_TRUE(this->test_default<float>(true)); } {
TEST_F(Conv2dFwdNHWCInstances, ND_F32_filter1x1_stride1_pad0) EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>(true));
{ }
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>(true)); TEST_F(Conv2dFwdNHWCInstances, ND_F32_default) { EXPECT_TRUE(this->test_default<float>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_F32_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_F32_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>(true));
EXPECT_TRUE(this->test_filter1x1_pad0<float>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_F32_filter1x1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_I8_default) { EXPECT_TRUE(this->test_default<int8_t>(true)); } {
TEST_F(Conv2dFwdNHWCInstances, ND_I8_filter1x1_stride1_pad0) EXPECT_TRUE(this->test_filter1x1_pad0<float>(true));
{ }
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>(true)); TEST_F(Conv2dFwdNHWCInstances, ND_I8_default) { EXPECT_TRUE(this->test_default<int8_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_I8_filter1x1_stride1_pad0)
TEST_F(Conv2dFwdNHWCInstances, ND_I8_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>(true));
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>(true)); }
} TEST_F(Conv2dFwdNHWCInstances, ND_I8_filter1x1_pad0)
{
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>(true));
}
test/convnd_fwd/conv3d_fwd.cpp
View file @ d3051d75
#include <iostream> // SPDX-License-Identifier: MIT
#include <stdexcept> // Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#include <tuple>
#include <vector> #include <iostream>
#include <gtest/gtest.h> #include <stdexcept>
#include <tuple>
#include "ck/utility/data_type.hpp" #include <vector>
#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp" #include <gtest/gtest.h>
#include "ck/library/utility/conv_util.hpp" #include "ck/utility/data_type.hpp"
#include "ck/tensor_operation/gpu/element/element_wise_operation.hpp"
#include "test/convnd_fwd/conv_util.hpp"
#include "ck/library/utility/conv_util.hpp"
namespace {
#include "test/convnd_fwd/conv_util.hpp"
class Conv3dFwdNDHWCInstances : public ::testing::Test
{ namespace {
public:
template <typename T> class Conv3dFwdNDHWCInstances : public ::testing::Test
bool test_conv3d_nwc_instances(const std::vector<test::conv::DeviceConvFwdNoOpPtr>& conv_ptrs, {
const ck::utils::conv::ConvParams& params) public:
{ template <typename T>
using namespace std::placeholders; bool test_conv3d_nwc_instances(const std::vector<test::conv::DeviceConvFwdNoOpPtr>& conv_ptrs,
using namespace ck::utils; const ck::utils::conv::ConvParams& params)
namespace ctl = ck::tensor_layout::convolution; {
using namespace std::placeholders;
conv::ConvFwdOpInstance<T, using namespace ck::utils;
T, namespace ctl = ck::tensor_layout::convolution;
T,
ctl::NDHWC, conv::ConvFwdOpInstance<T,
ctl::KZYXC, T,
ctl::NDHWK, T,
ck::tensor_operation::element_wise::PassThrough, ctl::NDHWC,
ck::tensor_operation::element_wise::PassThrough, ctl::KZYXC,
ck::tensor_operation::element_wise::PassThrough, ctl::NDHWK,
FillUniformDistributionIntegerValue<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistributionIntegerValue<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, ck::tensor_operation::element_wise::PassThrough,
true, FillUniformDistributionIntegerValue<T>,
FillUniformDistributionIntegerValue<T>{}, FillUniformDistributionIntegerValue<T>>
FillUniformDistributionIntegerValue<T>{}); conv_instance(params,
auto reference_conv_fwd_fun = true,
std::bind(conv::run_reference_convolution_forward<3, T, T, T>, params, _1, _2, _3); FillUniformDistributionIntegerValue<T>{},
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun); FillUniformDistributionIntegerValue<T>{});
run_engine.SetAtol(atol_); auto reference_conv_fwd_fun =
run_engine.SetRtol(rtol_); std::bind(conv::run_reference_convolution_forward<3, T, T, T>, params, _1, _2, _3);
return run_engine.Test(conv_ptrs); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(atol_);
run_engine.SetRtol(rtol_);
template <typename T> return run_engine.Test(conv_ptrs);
bool test_default() }
{
return test_conv3d_nwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<3>(), params_default_); bool test_default()
} {
return test_conv3d_nwc_instances<T>(
template <typename T> ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<3>(), params_default_);
bool test_filter1x1_stride1_pad0() }
{
return test_conv3d_nwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<3>(), bool test_filter1x1_stride1_pad0()
params_filter1x1_stride1_pad0_); {
} return test_conv3d_nwc_instances<T>(
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<3>(),
template <typename T> params_filter1x1_stride1_pad0_);
bool test_filter1x1_pad0() }
{
return test_conv3d_nwc_instances<T>( template <typename T>
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<3>(), bool test_filter1x1_pad0()
params_filter1x1_pad0_); {
} return test_conv3d_nwc_instances<T>(
ck::utils::conv::ConvolutionFwdInstances<T, T, T>::template Get<3>(),
static inline ck::utils::conv::ConvParams params_default_{ params_filter1x1_pad0_);
3, 4, 256, 64, {3, 3, 3}, {28, 28, 28}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}}; }
static inline ck::utils::conv::ConvParams params_filter1x1_stride1_pad0_{
3, 4, 256, 64, {1, 1, 1}, {28, 28, 28}, {1, 1, 1}, {1, 1, 1}, {0, 0, 0}, {0, 0, 0}}; static inline ck::utils::conv::ConvParams params_default_{
static inline ck::utils::conv::ConvParams params_filter1x1_pad0_{ 3, 4, 256, 64, {3, 3, 3}, {28, 28, 28}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}};
3, 4, 256, 64, {1, 1, 1}, {28, 28, 28}, {2, 2, 2}, {1, 1, 1}, {0, 0, 0}, {0, 0, 0}}; static inline ck::utils::conv::ConvParams params_filter1x1_stride1_pad0_{
3, 4, 256, 64, {1, 1, 1}, {28, 28, 28}, {1, 1, 1}, {1, 1, 1}, {0, 0, 0}, {0, 0, 0}};
private: static inline ck::utils::conv::ConvParams params_filter1x1_pad0_{
double atol_{1e-5}; 3, 4, 256, 64, {1, 1, 1}, {28, 28, 28}, {2, 2, 2}, {1, 1, 1}, {0, 0, 0}, {0, 0, 0}};
double rtol_{1e-4};
}; private:
double atol_{1e-5};
} // anonymous namespace double rtol_{1e-4};
};
TEST(Conv3DFwdNDHWC, IntegerValues)
{ } // anonymous namespace
using namespace std::placeholders;
using namespace ck::utils; TEST(Conv3DFwdNDHWC, IntegerValues)
namespace ctl = ck::tensor_layout::convolution; {
using T = float; using namespace std::placeholders;
using namespace ck::utils;
ck::utils::conv::ConvParams params{ namespace ctl = ck::tensor_layout::convolution;
3, 4, 256, 64, {3, 3, 3}, {18, 18, 18}, {1, 1, 1}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}}; using T = float;
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; ck::utils::conv::ConvParams params{
test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs); 3, 4, 256, 64, {3, 3, 3}, {18, 18, 18}, {1, 1, 1}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}};
conv::ConvFwdOpInstance<T,
T, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
T, test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs);
ctl::NDHWC, conv::ConvFwdOpInstance<T,
ctl::KZYXC, T,
ctl::NDHWK, T,
ck::tensor_operation::element_wise::PassThrough, ctl::NDHWC,
ck::tensor_operation::element_wise::PassThrough, ctl::KZYXC,
ck::tensor_operation::element_wise::PassThrough, ctl::NDHWK,
FillUniformDistributionIntegerValue<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistributionIntegerValue<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, ck::tensor_operation::element_wise::PassThrough,
true, FillUniformDistributionIntegerValue<T>,
FillUniformDistributionIntegerValue<T>{}, FillUniformDistributionIntegerValue<T>>
FillUniformDistributionIntegerValue<T>{}); conv_instance(params,
true,
auto reference_conv_fwd_fun = FillUniformDistributionIntegerValue<T>{},
std::bind(conv::run_reference_convolution_forward<3, T, T, T>, params, _1, _2, _3); FillUniformDistributionIntegerValue<T>{});
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
run_engine.SetAtol(1e-5); auto reference_conv_fwd_fun =
run_engine.SetRtol(1e-3); std::bind(conv::run_reference_convolution_forward<3, T, T, T>, params, _1, _2, _3);
EXPECT_TRUE(run_engine.Test(conv_ptrs)); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(1e-5);
run_engine.SetRtol(1e-3);
TEST(Conv3DFwdNDHWC, FloatingPointValues) EXPECT_TRUE(run_engine.Test(conv_ptrs));
{ }
using namespace std::placeholders;
using namespace ck::utils; TEST(Conv3DFwdNDHWC, FloatingPointValues)
namespace ctl = ck::tensor_layout::convolution; {
using T = ck::half_t; using namespace std::placeholders;
using namespace ck::utils;
ck::utils::conv::ConvParams params{ namespace ctl = ck::tensor_layout::convolution;
3, 4, 256, 64, {3, 3, 3}, {18, 18, 18}, {1, 1, 1}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}}; using T = ck::half_t;
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; ck::utils::conv::ConvParams params{
test::conv::get_test_convolution_fwd_instance<3, T, T, T, float>(conv_ptrs); 3, 4, 256, 64, {3, 3, 3}, {18, 18, 18}, {1, 1, 1}, {2, 2, 2}, {2, 2, 2}, {2, 2, 2}};
conv::ConvFwdOpInstance<T,
T, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
T, test::conv::get_test_convolution_fwd_instance<3, T, T, T, float>(conv_ptrs);
ctl::NDHWC, conv::ConvFwdOpInstance<T,
ctl::KZYXC, T,
ctl::NDHWK, T,
ck::tensor_operation::element_wise::PassThrough, ctl::NDHWC,
ck::tensor_operation::element_wise::PassThrough, ctl::KZYXC,
ck::tensor_operation::element_wise::PassThrough, ctl::NDHWK,
FillUniformDistribution<T>, ck::tensor_operation::element_wise::PassThrough,
FillUniformDistribution<T>> ck::tensor_operation::element_wise::PassThrough,
conv_instance(params, true, FillUniformDistribution<T>{}, FillUniformDistribution<T>{}); ck::tensor_operation::element_wise::PassThrough,
FillUniformDistribution<T>,
auto reference_conv_fwd_fun = FillUniformDistribution<T>>
std::bind(conv::run_reference_convolution_forward<3, T, T, T>, params, _1, _2, _3); conv_instance(params, true, FillUniformDistribution<T>{}, FillUniformDistribution<T>{});
OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
run_engine.SetAtol(1e-3); auto reference_conv_fwd_fun =
run_engine.SetRtol(1e-3); std::bind(conv::run_reference_convolution_forward<3, T, T, T>, params, _1, _2, _3);
EXPECT_TRUE(run_engine.Test(conv_ptrs)); OpInstanceRunEngine<T, T, T> run_engine(conv_instance, reference_conv_fwd_fun);
} run_engine.SetAtol(1e-3);
run_engine.SetRtol(1e-3);
TEST(Conv3DFwdNDHWC, InputOver2GB) EXPECT_TRUE(run_engine.Test(conv_ptrs));
{ }
using PassThrough = ck::tensor_operation::element_wise::PassThrough;
using namespace ck::utils; TEST(Conv3DFwdNDHWC, InputOver2GB)
using T = float; {
using PassThrough = ck::tensor_operation::element_wise::PassThrough;
// >2GB Input using namespace ck::utils;
conv::ConvParams params; using T = float;
params.num_dim_spatial_ = 3;
params.N_ = 2; // >2GB Input
params.K_ = 16; conv::ConvParams params;
params.C_ = 32; params.num_dim_spatial_ = 3;
params.filter_spatial_lengths_ = std::vector<ck::index_t>{3, 3, 3}; params.N_ = 2;
params.input_spatial_lengths_ = std::vector<ck::index_t>{32, 1000, 1000}; params.K_ = 16;
params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1}; params.C_ = 32;
params.conv_filter_dilations_ = std::vector<ck::index_t>{1, 1, 1}; params.filter_spatial_lengths_ = std::vector<ck::index_t>{3, 3, 3};
params.input_left_pads_ = std::vector<ck::index_t>{1, 1, 1}; params.input_spatial_lengths_ = std::vector<ck::index_t>{32, 1000, 1000};
params.input_right_pads_ = std::vector<ck::index_t>{1, 1, 1}; params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1};
params.conv_filter_dilations_ = std::vector<ck::index_t>{1, 1, 1};
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; params.input_left_pads_ = std::vector<ck::index_t>{1, 1, 1};
test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs); params.input_right_pads_ = std::vector<ck::index_t>{1, 1, 1};
auto arg = conv_ptrs.back()->MakeArgumentPointer(nullptr,
nullptr, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
nullptr, test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs);
params.N_, auto arg = conv_ptrs.back()->MakeArgumentPointer(nullptr,
params.K_, nullptr,
params.C_, nullptr,
params.input_spatial_lengths_, params.N_,
params.filter_spatial_lengths_, params.K_,
params.GetOutputSpatialLengths(), params.C_,
params.conv_filter_strides_, params.input_spatial_lengths_,
params.conv_filter_dilations_, params.filter_spatial_lengths_,
params.input_left_pads_, params.GetOutputSpatialLengths(),
params.input_right_pads_, params.conv_filter_strides_,
PassThrough{}, params.conv_filter_dilations_,
PassThrough{}, params.input_left_pads_,
PassThrough{}); params.input_right_pads_,
EXPECT_FALSE(conv_ptrs.back()->IsSupportedArgument(arg.get())); PassThrough{},
} PassThrough{},
PassThrough{});
TEST(Conv3DFwdNDHWC, FiltersOver2GB) EXPECT_FALSE(conv_ptrs.back()->IsSupportedArgument(arg.get()));
{ }
using PassThrough = ck::tensor_operation::element_wise::PassThrough;
using namespace ck::utils; TEST(Conv3DFwdNDHWC, FiltersOver2GB)
using T = float; {
using PassThrough = ck::tensor_operation::element_wise::PassThrough;
// >2GB Filters using namespace ck::utils;
conv::ConvParams params; using T = float;
params.num_dim_spatial_ = 3;
params.N_ = 2; // >2GB Filters
params.K_ = 16; conv::ConvParams params;
params.C_ = 32; params.num_dim_spatial_ = 3;
params.filter_spatial_lengths_ = std::vector<ck::index_t>{4, 1000, 1000}; params.N_ = 2;
params.input_spatial_lengths_ = std::vector<ck::index_t>{16, 16, 16}; params.K_ = 16;
params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1}; params.C_ = 32;
params.conv_filter_dilations_ = std::vector<ck::index_t>{1, 1, 1}; params.filter_spatial_lengths_ = std::vector<ck::index_t>{4, 1000, 1000};
params.input_left_pads_ = std::vector<ck::index_t>{1, 1, 1}; params.input_spatial_lengths_ = std::vector<ck::index_t>{16, 16, 16};
params.input_right_pads_ = std::vector<ck::index_t>{1, 1, 1}; params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1};
params.conv_filter_dilations_ = std::vector<ck::index_t>{1, 1, 1};
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; params.input_left_pads_ = std::vector<ck::index_t>{1, 1, 1};
test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs); params.input_right_pads_ = std::vector<ck::index_t>{1, 1, 1};
auto arg = conv_ptrs.back()->MakeArgumentPointer(nullptr,
nullptr, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
nullptr, test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs);
params.N_, auto arg = conv_ptrs.back()->MakeArgumentPointer(nullptr,
params.K_, nullptr,
params.C_, nullptr,
params.input_spatial_lengths_, params.N_,
params.filter_spatial_lengths_, params.K_,
params.GetOutputSpatialLengths(), params.C_,
params.conv_filter_strides_, params.input_spatial_lengths_,
params.conv_filter_dilations_, params.filter_spatial_lengths_,
params.input_left_pads_, params.GetOutputSpatialLengths(),
params.input_right_pads_, params.conv_filter_strides_,
PassThrough{}, params.conv_filter_dilations_,
PassThrough{}, params.input_left_pads_,
PassThrough{}); params.input_right_pads_,
EXPECT_FALSE(conv_ptrs.back()->IsSupportedArgument(arg.get())); PassThrough{},
} PassThrough{},
PassThrough{});
TEST(Conv3DFwdNDHWC, OutputOver2GB) EXPECT_FALSE(conv_ptrs.back()->IsSupportedArgument(arg.get()));
{ }
using PassThrough = ck::tensor_operation::element_wise::PassThrough;
using namespace ck::utils; TEST(Conv3DFwdNDHWC, OutputOver2GB)
using T = float; {
using PassThrough = ck::tensor_operation::element_wise::PassThrough;
// >2GB Output using namespace ck::utils;
conv::ConvParams params; using T = float;
params.num_dim_spatial_ = 3;
params.N_ = 2; // >2GB Output
params.K_ = 16; conv::ConvParams params;
params.C_ = 2; params.num_dim_spatial_ = 3;
params.filter_spatial_lengths_ = std::vector<ck::index_t>{1, 1, 1}; params.N_ = 2;
params.input_spatial_lengths_ = std::vector<ck::index_t>{1000, 1000, 30}; params.K_ = 16;
params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1}; params.C_ = 2;
params.conv_filter_dilations_ = std::vector<ck::index_t>{1, 1, 1}; params.filter_spatial_lengths_ = std::vector<ck::index_t>{1, 1, 1};
params.input_left_pads_ = std::vector<ck::index_t>{2, 2, 2}; params.input_spatial_lengths_ = std::vector<ck::index_t>{1000, 1000, 30};
params.input_right_pads_ = std::vector<ck::index_t>{2, 2, 2}; params.conv_filter_strides_ = std::vector<ck::index_t>{1, 1, 1};
params.conv_filter_dilations_ = std::vector<ck::index_t>{1, 1, 1};
std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs; params.input_left_pads_ = std::vector<ck::index_t>{2, 2, 2};
test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs); params.input_right_pads_ = std::vector<ck::index_t>{2, 2, 2};
auto arg = conv_ptrs.back()->MakeArgumentPointer(nullptr,
nullptr, std::vector<test::conv::DeviceConvFwdNoOpPtr> conv_ptrs;
nullptr, test::conv::get_test_convolution_fwd_instance<3, T, T, T, T>(conv_ptrs);
params.N_, auto arg = conv_ptrs.back()->MakeArgumentPointer(nullptr,
params.K_, nullptr,
params.C_, nullptr,
params.input_spatial_lengths_, params.N_,
params.filter_spatial_lengths_, params.K_,
params.GetOutputSpatialLengths(), params.C_,
params.conv_filter_strides_, params.input_spatial_lengths_,
params.conv_filter_dilations_, params.filter_spatial_lengths_,
params.input_left_pads_, params.GetOutputSpatialLengths(),
params.input_right_pads_, params.conv_filter_strides_,
PassThrough{}, params.conv_filter_dilations_,
PassThrough{}, params.input_left_pads_,
PassThrough{}); params.input_right_pads_,
EXPECT_FALSE(conv_ptrs.back()->IsSupportedArgument(arg.get())); PassThrough{},
} PassThrough{},
PassThrough{});
TEST_F(Conv3dFwdNDHWCInstances, BF16_default) { EXPECT_TRUE(this->test_default<ck::bhalf_t>()); } EXPECT_FALSE(conv_ptrs.back()->IsSupportedArgument(arg.get()));
TEST_F(Conv3dFwdNDHWCInstances, BF16_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>()); TEST_F(Conv3dFwdNDHWCInstances, BF16_default) { EXPECT_TRUE(this->test_default<ck::bhalf_t>()); }
} TEST_F(Conv3dFwdNDHWCInstances, BF16_filter1x1_stride1_pad0)
TEST_F(Conv3dFwdNDHWCInstances, BF16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::bhalf_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>()); }
} TEST_F(Conv3dFwdNDHWCInstances, BF16_filter1x1_pad0)
{
TEST_F(Conv3dFwdNDHWCInstances, F16_default) { EXPECT_TRUE(this->test_default<ck::half_t>()); } EXPECT_TRUE(this->test_filter1x1_pad0<ck::bhalf_t>());
TEST_F(Conv3dFwdNDHWCInstances, F16_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>()); TEST_F(Conv3dFwdNDHWCInstances, F16_default) { EXPECT_TRUE(this->test_default<ck::half_t>()); }
} TEST_F(Conv3dFwdNDHWCInstances, F16_filter1x1_stride1_pad0)
TEST_F(Conv3dFwdNDHWCInstances, F16_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<ck::half_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>()); }
} TEST_F(Conv3dFwdNDHWCInstances, F16_filter1x1_pad0)
{
TEST_F(Conv3dFwdNDHWCInstances, F32_default) { EXPECT_TRUE(this->test_default<float>()); } EXPECT_TRUE(this->test_filter1x1_pad0<ck::half_t>());
TEST_F(Conv3dFwdNDHWCInstances, F32_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>()); TEST_F(Conv3dFwdNDHWCInstances, F32_default) { EXPECT_TRUE(this->test_default<float>()); }
} TEST_F(Conv3dFwdNDHWCInstances, F32_filter1x1_stride1_pad0)
TEST_F(Conv3dFwdNDHWCInstances, F32_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<float>());
EXPECT_TRUE(this->test_filter1x1_pad0<float>()); }
} TEST_F(Conv3dFwdNDHWCInstances, F32_filter1x1_pad0)
{
TEST_F(Conv3dFwdNDHWCInstances, I8_default) { EXPECT_TRUE(this->test_default<int8_t>()); } EXPECT_TRUE(this->test_filter1x1_pad0<float>());
TEST_F(Conv3dFwdNDHWCInstances, I8_filter1x1_stride1_pad0) }
{
EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>()); TEST_F(Conv3dFwdNDHWCInstances, I8_default) { EXPECT_TRUE(this->test_default<int8_t>()); }
} TEST_F(Conv3dFwdNDHWCInstances, I8_filter1x1_stride1_pad0)
TEST_F(Conv3dFwdNDHWCInstances, I8_filter1x1_pad0) {
{ EXPECT_TRUE(this->test_filter1x1_stride1_pad0<int8_t>());
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>()); }
} TEST_F(Conv3dFwdNDHWCInstances, I8_filter1x1_pad0)
{
EXPECT_TRUE(this->test_filter1x1_pad0<int8_t>());
}
test/convnd_fwd/conv_util.hpp
View file @ d3051d75
// SPDX-License-Identifier: MIT
// Copyright (c) 2018-2022, Advanced Micro Devices, Inc. All rights reserved.
#pragma once #pragma once
#include <tuple> #include <tuple>
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment