util.cpp 10.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*******************************************************************************
* Copyright 2017-2018 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.
*******************************************************************************/
Robert Kimball's avatar
Robert Kimball committed
16

17
#include <fstream>
Robert Kimball's avatar
Robert Kimball committed
18
#include <sstream>
19 20
#include <string>
#include <vector>
Robert Kimball's avatar
Robert Kimball committed
21 22 23

#include "gtest/gtest.h"

24
#include "ngraph/file_util.hpp"
Robert Kimball's avatar
Robert Kimball committed
25
#include "ngraph/function.hpp"
varun-intel's avatar
varun-intel committed
26
#include "ngraph/graph_util.hpp"
27
#include "ngraph/ngraph.hpp"
28
#include "ngraph/serializer.hpp"
29
#include "util/all_close.hpp"
30
#include "util/ndarray.hpp"
Robert Kimball's avatar
Robert Kimball committed
31 32

using namespace std;
33
using namespace ngraph;
Robert Kimball's avatar
Robert Kimball committed
34 35 36 37 38

TEST(util, split)
{
    {
        string s1 = "this,is,a,test";
39
        auto r1 = split(s1, ',');
Robert Kimball's avatar
Robert Kimball committed
40 41 42 43 44 45 46 47 48
        ASSERT_EQ(4, r1.size());
        EXPECT_STRCASEEQ("this", r1[0].c_str());
        EXPECT_STRCASEEQ("is", r1[1].c_str());
        EXPECT_STRCASEEQ("a", r1[2].c_str());
        EXPECT_STRCASEEQ("test", r1[3].c_str());
    }

    {
        string s1 = "this,is,a,test,";
49
        auto r1 = split(s1, ',');
Robert Kimball's avatar
Robert Kimball committed
50 51 52 53 54 55 56 57 58 59
        ASSERT_EQ(5, r1.size());
        EXPECT_STRCASEEQ("this", r1[0].c_str());
        EXPECT_STRCASEEQ("is", r1[1].c_str());
        EXPECT_STRCASEEQ("a", r1[2].c_str());
        EXPECT_STRCASEEQ("test", r1[3].c_str());
        EXPECT_STRCASEEQ("", r1[4].c_str());
    }

    {
        string s1 = ",this,is,a,test";
60
        auto r1 = split(s1, ',');
Robert Kimball's avatar
Robert Kimball committed
61 62 63 64 65 66 67 68 69 70
        ASSERT_EQ(5, r1.size());
        EXPECT_STRCASEEQ("", r1[0].c_str());
        EXPECT_STRCASEEQ("this", r1[1].c_str());
        EXPECT_STRCASEEQ("is", r1[2].c_str());
        EXPECT_STRCASEEQ("a", r1[3].c_str());
        EXPECT_STRCASEEQ("test", r1[4].c_str());
    }

    {
        string s1 = "this,,is,a,test";
71
        auto r1 = split(s1, ',');
Robert Kimball's avatar
Robert Kimball committed
72 73 74 75 76 77 78 79 80 81
        ASSERT_EQ(5, r1.size());
        EXPECT_STRCASEEQ("this", r1[0].c_str());
        EXPECT_STRCASEEQ("", r1[1].c_str());
        EXPECT_STRCASEEQ("is", r1[2].c_str());
        EXPECT_STRCASEEQ("a", r1[3].c_str());
        EXPECT_STRCASEEQ("test", r1[4].c_str());
    }

    {
        string s1 = "this";
82
        auto r1 = split(s1, ',');
Robert Kimball's avatar
Robert Kimball committed
83 84 85 86 87 88
        ASSERT_EQ(1, r1.size());
        EXPECT_STRCASEEQ("this", r1[0].c_str());
    }

    {
        string s1 = "";
89
        auto r1 = split(s1, ',');
Robert Kimball's avatar
Robert Kimball committed
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
        ASSERT_EQ(1, r1.size());
        EXPECT_STRCASEEQ("", r1[0].c_str());
    }
}

TEST(DISABLED_util, dump)
{
    string text = "this is a text string used to test the dump function.";

    dump(cout, text.data(), text.size());
}

TEST(util, stopwatch)
{
    stopwatch t1;

    t1.start();
    usleep(1000);
    t1.stop();

    t1.start();
    usleep(1000);
    t1.stop();

    t1.start();
    usleep(1000);
    t1.stop();

    EXPECT_EQ(3, t1.get_call_count());

    EXPECT_GT(t1.get_total_microseconds(), t1.get_microseconds());
}

TEST(util, trim)
{
    EXPECT_STREQ("test", trim("test").c_str());
    EXPECT_STREQ("test", trim(" test").c_str());
    EXPECT_STREQ("test", trim("test ").c_str());
    EXPECT_STREQ("test", trim(" test ").c_str());
    EXPECT_STREQ("test", trim("           test            ").c_str());
    EXPECT_STREQ("test", trim("\ttest").c_str());
    EXPECT_STREQ("test", trim("test\t").c_str());
    EXPECT_STREQ("test", trim("\ttest\t").c_str());
    EXPECT_STREQ("test", trim(" \t test \t ").c_str());
}

TEST(util, contains)
{
    vector<int> v1 = {1, 2, 3, 4, 5, 6};

    EXPECT_TRUE(contains(v1, 1));
    EXPECT_TRUE(contains(v1, 4));
    EXPECT_TRUE(contains(v1, 6));
    EXPECT_FALSE(contains(v1, 8));
}

146 147
TEST(util, all_close)
{
148
    auto manager = runtime::Manager::get("INTERPRETER");
149 150 151
    auto backend = manager->allocate_backend();

    // Create some tensors for input/output
152 153
    auto a = backend->make_primary_tensor_view(element::f32, Shape{2, 3});
    auto b = backend->make_primary_tensor_view(element::f32, Shape{2, 3});
Robert Kimball's avatar
Robert Kimball committed
154

155 156
    copy_data(a, test::NDArray<float, 2>({{1, 2, 3}, {3, 4, 5}}).get_vector());
    copy_data(b, test::NDArray<float, 2>({{1, 2, 3}, {3, 4, 5}}).get_vector());
157

158
    EXPECT_TRUE(ngraph::test::all_close<float>(a, b));
159

160
    auto c = backend->make_primary_tensor_view(element::f32, Shape{2, 3});
161
    copy_data(c, test::NDArray<float, 2>({{1.1f, 2, 3}, {3, 4, 5}}).get_vector());
Robert Kimball's avatar
Robert Kimball committed
162

163 164
    EXPECT_FALSE(ngraph::test::all_close<float>(c, a, 0, .05f));
    EXPECT_TRUE(ngraph::test::all_close<float>(c, a, 0, .11f));
165

166 167
    EXPECT_FALSE(ngraph::test::all_close<float>(c, a, .05f, 0));
    EXPECT_TRUE(ngraph::test::all_close<float>(c, a, .11f, 0));
168
}
Robert Kimball's avatar
Robert Kimball committed
169 170 171 172

TEST(util, traverse_functions)
{
    // First create "f(A,B,C) = (A+B)*C".
173
    Shape shape{2, 2};
174 175 176
    auto A = make_shared<op::Parameter>(element::f32, shape);
    auto B = make_shared<op::Parameter>(element::f32, shape);
    auto C = make_shared<op::Parameter>(element::f32, shape);
177
    auto f = make_shared<Function>((A + B) * C, op::ParameterVector{A, B, C}, "f");
Robert Kimball's avatar
Robert Kimball committed
178 179

    // Now make "g(X,Y,Z) = f(X,Y,Z) + f(X,Y,Z)"
180 181 182
    auto X = make_shared<op::Parameter>(element::f32, shape);
    auto Y = make_shared<op::Parameter>(element::f32, shape);
    auto Z = make_shared<op::Parameter>(element::f32, shape);
183 184 185
    auto g = make_shared<Function>(make_shared<op::FunctionCall>(f, NodeVector{X, Y, Z}) +
                                       make_shared<op::FunctionCall>(f, NodeVector{X, Y, Z}),
                                   op::ParameterVector{X, Y, Z},
Robert Kimball's avatar
Robert Kimball committed
186 187 188
                                   "g");

    // Now make "h(X,Y,Z) = g(X,Y,Z) + g(X,Y,Z)"
189 190 191
    auto X1 = make_shared<op::Parameter>(element::f32, shape);
    auto Y1 = make_shared<op::Parameter>(element::f32, shape);
    auto Z1 = make_shared<op::Parameter>(element::f32, shape);
192 193 194
    auto h = make_shared<Function>(make_shared<op::FunctionCall>(g, NodeVector{X1, Y1, Z1}) +
                                       make_shared<op::FunctionCall>(g, NodeVector{X1, Y1, Z1}),
                                   op::ParameterVector{X1, Y1, Z1},
Robert Kimball's avatar
Robert Kimball committed
195 196 197 198 199 200
                                   "h");

    vector<Function*> functions;
    traverse_functions(h, [&](shared_ptr<Function> fp) { functions.push_back(fp.get()); });
    ASSERT_EQ(3, functions.size());
}
201 202 203 204 205 206

class CloneTest : public ::testing::Test
{
public:
    // (A + B) * C
    Shape shape = Shape{2, 2};
207 208 209
    std::shared_ptr<op::Parameter> A = make_shared<op::Parameter>(element::f32, shape);
    std::shared_ptr<op::Parameter> B = make_shared<op::Parameter>(element::f32, shape);
    std::shared_ptr<op::Parameter> C = make_shared<op::Parameter>(element::f32, shape);
210 211 212 213 214 215
    std::shared_ptr<Node> AplusB = A + B;
    std::shared_ptr<Node> AplusBtimesC = AplusB * C;

    NodeMap node_map;
    std::list<std::shared_ptr<ngraph::Node>> nodes;
    std::shared_ptr<Function> func =
216
        make_shared<Function>(AplusBtimesC, op::ParameterVector{A, B, C}, "f");
217 218 219 220 221 222 223 224 225 226

    void SetUp()
    {
        nodes.push_back(AplusBtimesC);
        nodes.push_back(AplusB);
        nodes.push_back(A);
        nodes.push_back(B);
        nodes.push_back(C);
    }

227 228 229
    bool CompareNodeVector(const std::list<std::shared_ptr<ngraph::Node>>& orig,
                           const std::list<std::shared_ptr<ngraph::Node>>& clone,
                           const NodeMap& nm)
230 231 232 233 234 235 236 237 238
    {
        if (orig.size() != clone.size())
        {
            return false;
        }
        auto origit = orig.begin();
        auto cloneit = clone.begin();
        while (origit != orig.end() && cloneit != clone.end())
        {
varun-intel's avatar
varun-intel committed
239
            if (*cloneit != nm.get_node_map().at(*origit))
240 241 242 243 244 245 246 247 248 249 250 251 252
            {
                return false;
            }
            ++origit;
            ++cloneit;
        }
        return true;
    }
};

TEST_F(CloneTest, clone_nodes_full)
{
    auto cloned_nodes = clone_nodes(nodes, node_map);
253
    ASSERT_TRUE(CompareNodeVector(nodes, cloned_nodes, node_map));
254

varun-intel's avatar
varun-intel committed
255 256 257 258 259
    ASSERT_NE(nullptr, std::dynamic_pointer_cast<op::Parameter>(node_map.get(A)));
    ASSERT_NE(nullptr, std::dynamic_pointer_cast<op::Parameter>(node_map.get(B)));
    ASSERT_NE(nullptr, std::dynamic_pointer_cast<op::Parameter>(node_map.get(C)));
    ASSERT_NE(nullptr, std::dynamic_pointer_cast<op::Add>(node_map.get(AplusB)));
    ASSERT_NE(nullptr, std::dynamic_pointer_cast<op::Multiply>(node_map.get(AplusBtimesC)));
260 261 262

    auto sorted_nodes = topological_sort(nodes);
    auto sorted_cloned_nodes = topological_sort(cloned_nodes);
263
    ASSERT_TRUE(CompareNodeVector(sorted_nodes, sorted_cloned_nodes, node_map));
264 265 266 267 268
}

TEST_F(CloneTest, clone_nodes_partial)
{
    // map A -> A' prior to clone
269
    auto Aprime = make_shared<op::Parameter>(element::f32, shape);
varun-intel's avatar
varun-intel committed
270
    node_map.add(A, Aprime);
271 272

    auto cloned_nodes = clone_nodes(nodes, node_map);
273
    ASSERT_TRUE(CompareNodeVector(nodes, cloned_nodes, node_map));
274 275

    // ensure A -> A' after clone
varun-intel's avatar
varun-intel committed
276
    ASSERT_EQ(Aprime, node_map.get(A));
277 278 279 280 281
}

TEST_F(CloneTest, clone_function_full)
{
    auto cloned_func = clone_function(func, node_map);
282
    ASSERT_TRUE(CompareNodeVector(func->get_ops(), cloned_func->get_ops(), node_map));
283
}
284

285 286
TEST(graph_util, clone_multiple_results)
{
287
    Shape shape{2, 2};
288 289 290 291 292 293
    auto A = make_shared<op::Parameter>(element::f32, shape);
    auto B = make_shared<op::Parameter>(element::f32, shape);
    auto C = make_shared<op::Parameter>(element::f32, shape);
    auto A_add_B = make_shared<op::Add>(A, B);
    auto A_add_B_mul_C = make_shared<op::Multiply>(A_add_B, C);

294 295
    auto f =
        make_shared<Function>(NodeVector{A_add_B, A_add_B_mul_C}, op::ParameterVector{A, B, C});
296 297 298 299 300

    NodeMap node_map;
    auto copy = clone_function(f, node_map);
}

301 302 303 304 305 306 307 308 309
TEST(util, round_up)
{
    EXPECT_EQ(0, round_up(0, 4));
    EXPECT_EQ(4, round_up(1, 4));
    EXPECT_EQ(4, round_up(2, 4));
    EXPECT_EQ(4, round_up(3, 4));
    EXPECT_EQ(4, round_up(4, 4));
    EXPECT_EQ(8, round_up(5, 4));
}
310 311 312 313 314 315 316 317 318 319 320 321 322 323 324

TEST(util, parse_string)
{
    EXPECT_FLOAT_EQ(2, parse_string<float>("2"));
    EXPECT_FLOAT_EQ(2.125, parse_string<float>("2.125"));
    EXPECT_FLOAT_EQ(numeric_limits<float>::infinity(), parse_string<float>("INFINITY"));
    EXPECT_FLOAT_EQ(numeric_limits<float>::infinity(), parse_string<float>("infinity"));
    EXPECT_FLOAT_EQ(-numeric_limits<float>::infinity(), parse_string<float>("-INFINITY"));
    EXPECT_TRUE(isnan(parse_string<float>("NaN")));

    EXPECT_FLOAT_EQ(2, parse_string<double>("2"));
    EXPECT_FLOAT_EQ(2.125, parse_string<double>("2.125"));
    EXPECT_FLOAT_EQ(numeric_limits<double>::infinity(), parse_string<double>("INFINITY"));
    EXPECT_FLOAT_EQ(numeric_limits<double>::infinity(), parse_string<double>("infinity"));
    EXPECT_FLOAT_EQ(-numeric_limits<double>::infinity(), parse_string<double>("-INFINITY"));
325
    EXPECT_TRUE(std::isnan(parse_string<double>("NaN")));
326
}