inference-engine/tests/unit/engines/mkldnn/graph/layers/internal/graph_leaks_test.cpp

   1 // Copyright (C) 2018 Intel Corporation
   2 //
   3 // SPDX-License-Identifier: Apache-2.0
   4 //
   5
   6 #include <gtest/gtest.h>
   7 #include <gmock/gmock-spec-builders.h>
   8 #include "mkldnn_plugin/mkldnn_graph.h"
   9
  10 #include "test_graph.hpp"
  11
  12 #include <mkldnn_plugin/mkldnn_extension_utils.h>
  13 #include <mkldnn_plugin/mkldnn_plugin.h>
  14 #include <mkldnn_plugin/config.h>
  15
  16 using namespace std;
  17 using namespace mkldnn;
  18
  19 class MKLDNNTestExecNetwork: public MKLDNNPlugin::MKLDNNExecNetwork {
  20 public:
  21     MKLDNNTestExecNetwork(InferenceEngine::ICNNNetwork &network, const MKLDNNPlugin::Config &cfg)
  22             : MKLDNNExecNetwork(network, cfg, {}) {}
  23     MKLDNNPlugin::MKLDNNGraph& getGraph() {
  24         return *graph;
  25     }
  26 };
  27
  28 class MKLDNNTestEngine: public MKLDNNPlugin::Engine {
  29 public:
  30     MKLDNNPlugin::MKLDNNGraph& getGraph() {
  31         auto * execNetworkInt =
  32                 dynamic_cast<InferenceEngine::ExecutableNetworkBase<InferenceEngine::ExecutableNetworkInternal> *>(_loadedNetwork.get());
  33         if (!execNetworkInt)
  34             THROW_IE_EXCEPTION << "Cannot find loaded network!";
  35
  36         auto * network = reinterpret_cast<MKLDNNTestExecNetwork *>(execNetworkInt->getImpl().get());
  37         if (!network)
  38             THROW_IE_EXCEPTION << "Cannot get mkldnn graph!";
  39         return network->getGraph();
  40     }
  41 };
  42
  43 class MKLDNNGraphLeaksTests: public ::testing::Test {
  44 protected:
  45     void addOutputToEachNode(InferenceEngine::CNNNetReader& net_reader, std::vector<std::string>& new_outputs,
  46                              InferenceEngine::CNNLayerPtr cnnLayer) {
  47         auto outputs = net_reader.getNetwork().getOutputsInfo();
  48         if (outputs.find(cnnLayer->name) != outputs.end())
  49             return;
  50
  51         net_reader.getNetwork().addOutput(cnnLayer->name);
  52         new_outputs.push_back(cnnLayer->name);
  53
  54         for (const auto &layer : cnnLayer->outData) {
  55             for (const auto &data : layer->getInputTo()) {
  56                 addOutputToEachNode(net_reader, new_outputs, data.second);
  57             }
  58         }
  59     }
  60
  61     void fill_data(float *data, size_t size, size_t duty_ratio = 10) {
  62         for (size_t i = 0; i < size; i++) {
  63             if ( ( i / duty_ratio)%2 == 1) {
  64                 data[i] = 0.0;
  65             } else {
  66                 data[i] = (float) sin((float)i);
  67             }
  68         }
  69     }
  70 };
  71
  72 TEST_F(MKLDNNGraphLeaksTests, MKLDNN_not_release_outputs_fp32) {
  73     try {
  74         InferenceEngine::CNNNetReader net_reader;
  75         std::string model = "<net name=\"LeNet\" version=\"2\" batch=\"1\">\n"
  76                 "    <layers>\n"
  77                 "        <layer name=\"data\" type=\"Input\" precision=\"FP32\" id=\"0\">\n"
  78                 "            <output>\n"
  79                 "                <port id=\"0\">\n"
  80                 "                    <dim>1</dim>\n"
  81                 "                    <dim>1</dim>\n"
  82                 "                    <dim>28</dim>\n"
  83                 "                    <dim>28</dim>\n"
  84                 "                </port>\n"
  85                 "            </output>\n"
  86                 "        </layer>\n"
  87                 "        <layer name=\"conv1\" type=\"Convolution\" precision=\"FP32\" id=\"1\">\n"
  88                 "            <convolution_data stride-x=\"1\" stride-y=\"1\" pad-x=\"0\" pad-y=\"0\" kernel-x=\"5\" kernel-y=\"5\" output=\"20\" group=\"1\"/>\n"
  89                 "            <input>\n"
  90                 "                <port id=\"1\">\n"
  91                 "                    <dim>1</dim>\n"
  92                 "                    <dim>1</dim>\n"
  93                 "                    <dim>28</dim>\n"
  94                 "                    <dim>28</dim>\n"
  95                 "                </port>\n"
  96                 "            </input>\n"
  97                 "            <output>\n"
  98                 "                <port id=\"2\">\n"
  99                 "                    <dim>1</dim>\n"
 100                 "                    <dim>20</dim>\n"
 101                 "                    <dim>24</dim>\n"
 102                 "                    <dim>24</dim>\n"
 103                 "                </port>\n"
 104                 "            </output>\n"
 105                 "            <weights offset=\"0\" size=\"2000\"/>\n"
 106                 "            <biases offset=\"2000\" size=\"80\"/>\n"
 107                 "        </layer>\n"
 108                 "        <layer name=\"pool1\" type=\"Pooling\" precision=\"FP32\" id=\"2\">\n"
 109                 "            <pooling_data kernel-x=\"2\" kernel-y=\"2\" pad-x=\"0\" pad-y=\"0\" stride-x=\"2\" stride-y=\"2\" rounding-type=\"ceil\" pool-method=\"max\"/>\n"
 110                 "            <input>\n"
 111                 "                <port id=\"3\">\n"
 112                 "                    <dim>1</dim>\n"
 113                 "                    <dim>20</dim>\n"
 114                 "                    <dim>24</dim>\n"
 115                 "                    <dim>24</dim>\n"
 116                 "                </port>\n"
 117                 "            </input>\n"
 118                 "            <output>\n"
 119                 "                <port id=\"4\">\n"
 120                 "                    <dim>1</dim>\n"
 121                 "                    <dim>20</dim>\n"
 122                 "                    <dim>12</dim>\n"
 123                 "                    <dim>12</dim>\n"
 124                 "                </port>\n"
 125                 "            </output>\n"
 126                 "        </layer>\n"
 127                 "        <layer name=\"conv2\" type=\"Convolution\" precision=\"FP32\" id=\"3\">\n"
 128                 "            <convolution_data stride-x=\"1\" stride-y=\"1\" pad-x=\"0\" pad-y=\"0\" kernel-x=\"5\" kernel-y=\"5\" output=\"50\" group=\"1\"/>\n"
 129                 "            <input>\n"
 130                 "                <port id=\"5\">\n"
 131                 "                    <dim>1</dim>\n"
 132                 "                    <dim>20</dim>\n"
 133                 "                    <dim>12</dim>\n"
 134                 "                    <dim>12</dim>\n"
 135                 "                </port>\n"
 136                 "            </input>\n"
 137                 "            <output>\n"
 138                 "                <port id=\"6\">\n"
 139                 "                    <dim>1</dim>\n"
 140                 "                    <dim>50</dim>\n"
 141                 "                    <dim>8</dim>\n"
 142                 "                    <dim>8</dim>\n"
 143                 "                </port>\n"
 144                 "            </output>\n"
 145                 "            <weights offset=\"2080\" size=\"100000\"/>\n"
 146                 "            <biases offset=\"102080\" size=\"200\"/>\n"
 147                 "        </layer>\n"
 148                 "        <layer name=\"pool2\" type=\"Pooling\" precision=\"FP32\" id=\"4\">\n"
 149                 "            <pooling_data kernel-x=\"2\" kernel-y=\"2\" pad-x=\"0\" pad-y=\"0\" stride-x=\"2\" stride-y=\"2\" rounding-type=\"ceil\" pool-method=\"max\"/>\n"
 150                 "            <input>\n"
 151                 "                <port id=\"7\">\n"
 152                 "                    <dim>1</dim>\n"
 153                 "                    <dim>50</dim>\n"
 154                 "                    <dim>8</dim>\n"
 155                 "                    <dim>8</dim>\n"
 156                 "                </port>\n"
 157                 "            </input>\n"
 158                 "            <output>\n"
 159                 "                <port id=\"8\">\n"
 160                 "                    <dim>1</dim>\n"
 161                 "                    <dim>50</dim>\n"
 162                 "                    <dim>4</dim>\n"
 163                 "                    <dim>4</dim>\n"
 164                 "                </port>\n"
 165                 "            </output>\n"
 166                 "        </layer>\n"
 167                 "        <layer name=\"ip1\" type=\"FullyConnected\" precision=\"FP32\" id=\"5\">\n"
 168                 "            <fc_data out-size=\"500\"/>\n"
 169                 "            <input>\n"
 170                 "                <port id=\"9\">\n"
 171                 "                    <dim>1</dim>\n"
 172                 "                    <dim>50</dim>\n"
 173                 "                    <dim>4</dim>\n"
 174                 "                    <dim>4</dim>\n"
 175                 "                </port>\n"
 176                 "            </input>\n"
 177                 "            <output>\n"
 178                 "                <port id=\"10\">\n"
 179                 "                    <dim>1</dim>\n"
 180                 "                    <dim>500</dim>\n"
 181                 "                </port>\n"
 182                 "            </output>\n"
 183                 "            <weights offset=\"102280\" size=\"1600000\"/>\n"
 184                 "            <biases offset=\"1702280\" size=\"2000\"/>\n"
 185                 "        </layer>\n"
 186                 "        <layer name=\"relu1\" type=\"ReLU\" precision=\"FP32\" id=\"6\">\n"
 187                 "            <input>\n"
 188                 "                <port id=\"11\">\n"
 189                 "                    <dim>1</dim>\n"
 190                 "                    <dim>500</dim>\n"
 191                 "                </port>\n"
 192                 "            </input>\n"
 193                 "            <output>\n"
 194                 "                <port id=\"12\">\n"
 195                 "                    <dim>1</dim>\n"
 196                 "                    <dim>500</dim>\n"
 197                 "                </port>\n"
 198                 "            </output>\n"
 199                 "        </layer>\n"
 200                 "        <layer name=\"ip2\" type=\"FullyConnected\" precision=\"FP32\" id=\"7\">\n"
 201                 "            <fc_data out-size=\"10\"/>\n"
 202                 "            <input>\n"
 203                 "                <port id=\"13\">\n"
 204                 "                    <dim>1</dim>\n"
 205                 "                    <dim>500</dim>\n"
 206                 "                </port>\n"
 207                 "            </input>\n"
 208                 "            <output>\n"
 209                 "                <port id=\"14\">\n"
 210                 "                    <dim>1</dim>\n"
 211                 "                    <dim>10</dim>\n"
 212                 "                </port>\n"
 213                 "            </output>\n"
 214                 "            <weights offset=\"1704280\" size=\"20000\"/>\n"
 215                 "            <biases offset=\"1724280\" size=\"40\"/>\n"
 216                 "        </layer>\n"
 217                 "        <layer name=\"prob\" type=\"SoftMax\" precision=\"FP32\" id=\"8\">\n"
 218                 "            <input>\n"
 219                 "                <port id=\"15\">\n"
 220                 "                    <dim>1</dim>\n"
 221                 "                    <dim>10</dim>\n"
 222                 "                </port>\n"
 223                 "            </input>\n"
 224                 "            <output>\n"
 225                 "                <port id=\"16\">\n"
 226                 "                    <dim>1</dim>\n"
 227                 "                    <dim>10</dim>\n"
 228                 "                </port>\n"
 229                 "            </output>\n"
 230                 "        </layer>\n"
 231                 "    </layers>\n"
 232                 "    <edges>\n"
 233                 "        <edge from-layer=\"0\" from-port=\"0\" to-layer=\"1\" to-port=\"1\"/>\n"
 234                 "        <edge from-layer=\"1\" from-port=\"2\" to-layer=\"2\" to-port=\"3\"/>\n"
 235                 "        <edge from-layer=\"2\" from-port=\"4\" to-layer=\"3\" to-port=\"5\"/>\n"
 236                 "        <edge from-layer=\"3\" from-port=\"6\" to-layer=\"4\" to-port=\"7\"/>\n"
 237                 "        <edge from-layer=\"4\" from-port=\"8\" to-layer=\"5\" to-port=\"9\"/>\n"
 238                 "        <edge from-layer=\"5\" from-port=\"10\" to-layer=\"6\" to-port=\"11\"/>\n"
 239                 "        <edge from-layer=\"6\" from-port=\"12\" to-layer=\"7\" to-port=\"13\"/>\n"
 240                 "        <edge from-layer=\"7\" from-port=\"14\" to-layer=\"8\" to-port=\"15\"/>\n"
 241                 "    </edges>\n"
 242                 "</net>";
 243
 244         size_t weights_size = 1724320;
 245         net_reader.ReadNetwork(model.c_str(), model.size());
 246
 247         InferenceEngine::TBlob<uint8_t> *weights = new InferenceEngine::TBlob<uint8_t>(InferenceEngine::Precision::U8, InferenceEngine::C, {weights_size});
 248         weights->allocate();
 249         fill_data((float *) weights->buffer(), weights->size() / sizeof(float));
 250         InferenceEngine::TBlob<uint8_t>::Ptr weights_ptr = InferenceEngine::TBlob<uint8_t>::Ptr(weights);
 251
 252         net_reader.SetWeights(weights_ptr);
 253
 254         auto outputs = net_reader.getNetwork().getOutputsInfo();
 255         std::vector<std::string> new_outputs;
 256
 257         for (auto input : net_reader.getNetwork().getInputsInfo()) {
 258             for (const auto &layer : input.second->getInputData()->getInputTo()) {
 259                 addOutputToEachNode(net_reader, new_outputs, layer.second);
 260             }
 261         }
 262
 263         ASSERT_NE(1, net_reader.getNetwork().getOutputsInfo().size());
 264
 265         std::shared_ptr<MKLDNNTestEngine> score_engine(new MKLDNNTestEngine());
 266         ASSERT_NO_THROW(score_engine->LoadNetwork(net_reader.getNetwork()));
 267
 268         size_t modified_outputs_size = score_engine->getGraph().GetOutputNodes().size();
 269
 270         InferenceEngine::CNNNetReader net_reader2;
 271         net_reader2.ReadNetwork(model.c_str(), model.size());
 272         net_reader2.SetWeights(weights_ptr);
 273         ASSERT_EQ(1, net_reader2.getNetwork().getOutputsInfo().size());
 274
 275         ASSERT_NO_THROW(score_engine->LoadNetwork(net_reader2.getNetwork()));
 276
 277         size_t original_outputs_size = score_engine->getGraph().GetOutputNodes().size();
 278
 279         ASSERT_NE(modified_outputs_size, original_outputs_size);
 280         ASSERT_EQ(1, original_outputs_size);
 281     } catch (...) {
 282         FAIL();
 283     }
 284 }