Move CPU only unit tests to the cpu test file (#3919)

test/CMakeLists.txt

@@ -352,7 +352,6 @@ set(MULTI_TEST_SRC
     backend/sum.in.cpp
     backend/tan.in.cpp
     backend/tanh.in.cpp
-    backend/tensorview_custom_mem.in.cpp
     backend/tile.in.cpp
     backend/topk.in.cpp
     backend/transpose.in.cpp
@@ -434,7 +433,6 @@ if (NGRAPH_UNIT_TEST_OPENVINO_ENABLE)
             backend/subtract.in.cpp
             backend/tan.in.cpp
             backend/tanh.in.cpp
-            backend/tensorview_custom_mem.in.cpp
             backend/transpose.in.cpp
             backend/validate_call.in.cpp
             backend/zero_sized.in.cpp

test/backend/api.in.cpp

@@ -53,58 +53,6 @@ NGRAPH_TEST(${BACKEND_NAME}, create_tensor_1)
     EXPECT_TRUE(test::all_close_f(read_vector<float>(result), expected, MIN_FLOAT_TOLERANCE_BITS));
 }
 
-// This tests a backend's implementation of the three parameter version of create_tensor
-// Testing using this tensor as a Function input
-NGRAPH_TEST(${BACKEND_NAME}, create_tensor_2_input)
-{
-    Shape shape{2, 2};
-    auto A = make_shared<op::Parameter>(element::f32, shape);
-    auto B = make_shared<op::Parameter>(element::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    vector<float> av = {1, 2, 3, 4};
-    vector<float> bv = {5, 6, 7, 8};
-    shared_ptr<runtime::Tensor> a = backend->create_tensor(element::f32, shape, av.data());
-    shared_ptr<runtime::Tensor> b = backend->create_tensor(element::f32, shape, bv.data());
-    shared_ptr<runtime::Tensor> result = backend->create_tensor(element::f32, shape);
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a, b});
-    vector<float> expected = {6, 8, 10, 12};
-    EXPECT_TRUE(test::all_close_f(read_vector<float>(result), expected, MIN_FLOAT_TOLERANCE_BITS));
-}
-
-// This tests a backend's implementation of the three parameter version of create_tensor
-// Testing using this tensor as a Function output
-NGRAPH_TEST(${BACKEND_NAME}, create_tensor_2_output)
-{
-    Shape shape{2, 2};
-    auto A = make_shared<op::Parameter>(element::f32, shape);
-    auto B = make_shared<op::Parameter>(element::f32, shape);
-    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    vector<float> av = {1, 2, 3, 4};
-    vector<float> bv = {5, 6, 7, 8};
-    shared_ptr<runtime::Tensor> a = backend->create_tensor(element::f32, shape);
-    shared_ptr<runtime::Tensor> b = backend->create_tensor(element::f32, shape);
-    copy_data(a, av);
-    copy_data(b, bv);
-
-    vector<float> actual(4);
-    shared_ptr<runtime::Tensor> result = backend->create_tensor(element::f32, shape, actual.data());
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a, b});
-    vector<float> expected = {6, 8, 10, 12};
-    EXPECT_TRUE(test::all_close_f(actual, expected, MIN_FLOAT_TOLERANCE_BITS));
-}
-
 // This tests a backend's implementation of the copy_from for tensor
 NGRAPH_TEST(${BACKEND_NAME}, tensor_copy_from)
 {

test/backend/one_hot.in.cpp

@@ -94,27 +94,6 @@ NGRAPH_TEST(${BACKEND_NAME}, one_hot_scalar_0_in_3)
     EXPECT_EQ((vector<int32_t>{1, 0, 0}), read_vector<int32_t>(result));
 }
 
-NGRAPH_TEST(${BACKEND_NAME}, one_hot_scalar_oob_in_3)
-{
-    Shape shape_a{};
-    auto A = make_shared<op::Parameter>(element::i32, shape_a);
-    Shape shape_r{3};
-    auto r = make_shared<op::OneHot>(A, Shape{3}, 0);
-    auto f = make_shared<Function>(r, ParameterVector{A});
-
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    // Create some tensors for input/output
-    auto a = backend->create_tensor(element::i32, shape_a);
-    copy_data(a, vector<int32_t>{3});
-    vector<int32_t> r_data(4);
-    auto result = backend->create_tensor(element::i32, shape_r, r_data.data());
-
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a});
-    EXPECT_EQ(r_data[3], 0);
-}
-
 NGRAPH_TEST(${BACKEND_NAME}, one_hot_vector_0)
 {
     Shape shape_a{8};

test/backend/tensorview_custom_mem.in.cpp

-//*****************************************************************************
-// Copyright 2017-2019 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "gtest/gtest.h"
-#include "ngraph/ngraph.hpp"
-#include "util/all_close.hpp"
-#include "util/all_close_f.hpp"
-#include "util/known_element_types.hpp"
-#include "util/ndarray.hpp"
-#include "util/test_control.hpp"
-#include "util/test_tools.hpp"
-
-using namespace std;
-using namespace ngraph;
-
-static string s_manifest = "${MANIFEST}";
-
-NGRAPH_TEST(${BACKEND_NAME}, tensorview_custom_mem)
-{
-    auto backend = runtime::Backend::create("${BACKEND_NAME}");
-
-    Shape shape{2, 2};
-
-    auto make_external = [&]() {
-        auto A = make_shared<op::Parameter>(element::f32, shape);
-        auto B = make_shared<op::Parameter>(element::f32, shape);
-        auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
-
-        return f;
-    };
-
-    auto f = make_external();
-
-    vector<float> av{2, 4, 8, 16};
-    vector<float> bv{1, 2, 4, 8};
-    // use custom mem with tensorview, no need to copy data
-    auto a = backend->create_tensor(element::f32, shape, av.data());
-    auto b = backend->create_tensor(element::f32, shape, bv.data());
-
-    // use custom mem with result tensorview
-    vector<float> rv{0, 0, 0, 0};
-    auto result = backend->create_tensor(element::f32, shape, rv.data());
-
-    // result should be in memory without needing explict read
-    auto handle = backend->compile(f);
-    handle->call_with_validate({result}, {a, b});
-    EXPECT_TRUE(test::all_close_f((vector<float>{2, 2, 2, 2}), rv, MIN_FLOAT_TOLERANCE_BITS));
-}

test/cpu_test.cpp

@@ -2222,3 +2222,108 @@ TEST(cpu_test, convolution_simple_bf16)
               read_vector<bfloat16>(result));
 }
 #endif
+
+// This tests a backend's implementation of the three parameter version of create_tensor
+// Testing using this tensor as a Function input
+TEST(cpu_test, create_tensor_2_input)
+{
+    Shape shape{2, 2};
+    auto A = make_shared<op::Parameter>(element::f32, shape);
+    auto B = make_shared<op::Parameter>(element::f32, shape);
+    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+
+    auto backend = runtime::Backend::create("CPU");
+
+    // Create some tensors for input/output
+    vector<float> av = {1, 2, 3, 4};
+    vector<float> bv = {5, 6, 7, 8};
+    shared_ptr<runtime::Tensor> a = backend->create_tensor(element::f32, shape, av.data());
+    shared_ptr<runtime::Tensor> b = backend->create_tensor(element::f32, shape, bv.data());
+    shared_ptr<runtime::Tensor> result = backend->create_tensor(element::f32, shape);
+
+    auto handle = backend->compile(f);
+    handle->call_with_validate({result}, {a, b});
+    vector<float> expected = {6, 8, 10, 12};
+    EXPECT_TRUE(test::all_close_f(read_vector<float>(result), expected, MIN_FLOAT_TOLERANCE_BITS));
+}
+
+// This tests a backend's implementation of the three parameter version of create_tensor
+// Testing using this tensor as a Function output
+TEST(cpu_test, create_tensor_2_output)
+{
+    Shape shape{2, 2};
+    auto A = make_shared<op::Parameter>(element::f32, shape);
+    auto B = make_shared<op::Parameter>(element::f32, shape);
+    auto f = make_shared<Function>(make_shared<op::Add>(A, B), ParameterVector{A, B});
+
+    auto backend = runtime::Backend::create("CPU");
+
+    // Create some tensors for input/output
+    vector<float> av = {1, 2, 3, 4};
+    vector<float> bv = {5, 6, 7, 8};
+    shared_ptr<runtime::Tensor> a = backend->create_tensor(element::f32, shape);
+    shared_ptr<runtime::Tensor> b = backend->create_tensor(element::f32, shape);
+    copy_data(a, av);
+    copy_data(b, bv);
+
+    vector<float> actual(4);
+    shared_ptr<runtime::Tensor> result = backend->create_tensor(element::f32, shape, actual.data());
+
+    auto handle = backend->compile(f);
+    handle->call_with_validate({result}, {a, b});
+    vector<float> expected = {6, 8, 10, 12};
+    EXPECT_TRUE(test::all_close_f(actual, expected, MIN_FLOAT_TOLERANCE_BITS));
+}
+
+TEST(cpu_test, tensorview_custom_mem)
+{
+    auto backend = runtime::Backend::create("CPU");
+
+    Shape shape{2, 2};
+
+    auto make_external = [&]() {
+        auto A = make_shared<op::Parameter>(element::f32, shape);
+        auto B = make_shared<op::Parameter>(element::f32, shape);
+        auto f = make_shared<Function>(make_shared<op::Divide>(A, B), ParameterVector{A, B});
+
+        return f;
+    };
+
+    auto f = make_external();
+
+    vector<float> av{2, 4, 8, 16};
+    vector<float> bv{1, 2, 4, 8};
+    // use custom mem with tensorview, no need to copy data
+    auto a = backend->create_tensor(element::f32, shape, av.data());
+    auto b = backend->create_tensor(element::f32, shape, bv.data());
+
+    // use custom mem with result tensorview
+    vector<float> rv{0, 0, 0, 0};
+    auto result = backend->create_tensor(element::f32, shape, rv.data());
+
+    // result should be in memory without needing explict read
+    auto handle = backend->compile(f);
+    handle->call_with_validate({result}, {a, b});
+    EXPECT_TRUE(test::all_close_f((vector<float>{2, 2, 2, 2}), rv, MIN_FLOAT_TOLERANCE_BITS));
+}
+
+TEST(cpu_test, one_hot_scalar_oob_in_3)
+{
+    Shape shape_a{};
+    auto A = make_shared<op::Parameter>(element::i32, shape_a);
+    Shape shape_r{3};
+    auto r = make_shared<op::OneHot>(A, Shape{3}, 0);
+    auto f = make_shared<Function>(r, ParameterVector{A});
+
+    auto backend = runtime::Backend::create("CPU");
+
+    // Create some tensors for input/output
+    auto a = backend->create_tensor(element::i32, shape_a);
+    copy_data(a, vector<int32_t>{3});
+    vector<int32_t> r_data(4);
+    auto result = backend->create_tensor(element::i32, shape_r, r_data.data());
+
+    auto handle = backend->compile(f);
+    handle->call_with_validate({result}, {a});
+    EXPECT_EQ(r_data[3], 0);
+}