inference-engine/thirdparty/clDNN/src/include/network_impl.h

   1 /*
   2 // Copyright (c) 2016 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 ///////////////////////////////////////////////////////////////////////////////////////////////////
  18 #pragma once
  19
  20 #include "api/network.hpp"
  21
  22 #include "engine_impl.h"
  23 #include "event_impl.h"
  24 #include "program_impl.h"
  25 #include "refcounted_obj.h"
  26
  27 #include <map>
  28 #include <vector>
  29 #include <unordered_map>
  30 #include <string>
  31 #include <memory>
  32 #include <list>
  33 #include <set>
  34
  35 namespace cldnn {
  36
  37 class primitive_inst;
  38
  39 struct network_impl : public refcounted_obj<network_impl> {
  40 public:
  41     network_impl(const program_impl& program, uint16_t stream_id, bool is_internal = false);
  42     network_impl(engine_impl& engine,
  43                  const topology_impl& topo,
  44                  const build_options& options = build_options(),
  45                  uint16_t stream_id = 0,
  46                  bool is_internal = false);
  47     network_impl(engine_impl& engine,
  48                  const std::set<std::shared_ptr<program_node>>& nodes,
  49                  const build_options& options,
  50                  bool is_internal);
  51
  52     const program_impl& get_program() const { return *_program; }
  53     engine_impl& get_engine() const { return _program->get_engine(); }
  54
  55     void reset_execution(bool wait = true);
  56     void set_input_data(const primitive_id& id, memory_impl& data);
  57
  58     void set_learning_rate(const float lr);
  59     float get_learning_rate();
  60     uint16_t get_stream_id() const { return _stream_id; }
  61
  62     std::vector<std::shared_ptr<primitive_inst>> const& get_outputs() { return _outputs; }
  63
  64     const std::vector<std::shared_ptr<const primitive_inst>>& get_outputs() const {
  65         return reinterpret_cast<const std::vector<std::shared_ptr<const primitive_inst>>&>(_outputs);
  66     }
  67
  68     std::vector<primitive_id> get_output_ids() const;
  69     std::vector<primitive_id> get_executed_primitive_ids() const;
  70     std::vector<primitive_id> get_all_primitive_ids() const;
  71     std::vector<primitive_id> get_all_primitive_org_ids() const;
  72     const program_impl::primitives_info& get_primitives_info() const;
  73     const program_impl::graph_optimizer_info& get_optimizer_passes_info() const;
  74     void execute(const std::vector<event_impl::ptr>& events);
  75     void validate_primitives();
  76     // Implementation specific calls
  77     std::shared_ptr<primitive_inst> get_primitive(const primitive_id& id);
  78     std::string get_primitive_info(const primitive_id& id) const;
  79     const event_impl::ptr& get_primitive_event(const primitive_id& id) const { return _events.at(id); }
  80     std::vector<std::shared_ptr<primitive_inst>> get_primitives(const std::vector<primitive_id>& ids);
  81     std::vector<std::shared_ptr<primitive_inst>> get_primitives(const std::vector<program_node*>& nodes);
  82     void execute_primitive(const std::shared_ptr<primitive_inst>& primitive,
  83                            const std::vector<event_impl::ptr>& events);
  84     void allocate_primitives();
  85     void build_insts_deps();
  86     uint32_t get_id() const { return net_id; }
  87     void build_exec_order();
  88     bool is_internal() const { return _internal; }
  89
  90 private:
  91     uint32_t net_id = 0;
  92     const program_impl::cptr _program;
  93     uint16_t _stream_id;
  94     bool _internal;
  95     float _learning_rate = static_cast<float>(0.00001);
  96
  97     std::map<primitive_id, std::shared_ptr<primitive_inst>> _primitives;
  98     std::vector<std::shared_ptr<primitive_inst>> _inputs;
  99     std::vector<std::shared_ptr<primitive_inst>> _outputs;
 100     std::list<std::shared_ptr<primitive_inst>> _exec_order;
 101     std::list<std::shared_ptr<primitive_inst>> _data_outputs;
 102
 103     std::unordered_map<primitive_id, event_impl::ptr> _events;
 104
 105     void allocate_primitive_instance(program_node const& node);
 106     void allocate_mutable_data_for_streams(std::vector<std::shared_ptr<program_node>>& mutable_data_nodes);
 107     void add_to_exec_order(const primitive_id& id);
 108     std::shared_ptr<primitive_inst> find_in_internal_networks(const primitive_id& id);
 109     std::shared_ptr<primitive_inst> find_primitive(const primitive_id& id);
 110     void check_names();
 111 };
 112 }  // namespace cldnn