gpu_external_function and gpu constant memory refactor (#1189)

* refactor external function

* wokring version

* fix bug

* add emit_fucntions, emit_declare_constants, emit_declare_functions

* add std::

* add functions declaration

* fix bugs

* fix bugs

* separate temp memory allocation and release

* add invoke_constant_ptr function, clean up outputs for function

* fix bugs, compiled ok

* add ctx to emit_declare_constant

* cleanup code, code style

* remove using std, code style

* revert std changes

* change function names based Chris's comments

* add ResultCopyElimination to pass_manager

* clang format

src/ngraph/runtime/gpu/gpu_external_function.hpp

@@ -26,6 +26,12 @@
 #include "ngraph/codegen/compiler.hpp"
 #include "ngraph/codegen/execution_engine.hpp"
 #include "ngraph/function.hpp"
+#include "ngraph/pass/assign_layout.hpp"
+#include "ngraph/pass/dump_sorted.hpp"
+#include "ngraph/pass/liveness.hpp"
+#include "ngraph/pass/manager.hpp"
+#include "ngraph/pass/memory_layout.hpp"
+#include "ngraph/pass/result_copy_elimination.hpp"
 #include "ngraph/runtime/gpu/gpu_call_frame.hpp"
 #include "ngraph/runtime/gpu/gpu_primitive_emitter.hpp"
 #include "ngraph/runtime/gpu/gpu_tensor_view_wrapper.hpp"
@@ -58,6 +64,7 @@ namespace ngraph
                 GPU_ExternalFunction(const std::shared_ptr<ngraph::Function>& function,
                                      bool release_function = true);
                 ~GPU_ExternalFunction();
+
                 std::shared_ptr<ngraph::runtime::gpu::GPU_CallFrame> make_call_frame();
                 std::unique_ptr<runtime::gpu::GPURuntimeContext>& ctx();
                 const std::unique_ptr<GPUPrimitiveEmitter>& get_primitive_emitter() const
@@ -71,39 +78,46 @@ namespace ngraph
                 EntryPoint m_compiled_function;
 
             private:
-                void emit_debug_function_entry(codegen::CodeWriter& writer,
-                                               Node* node,
-                                               const std::vector<GPU_TensorViewWrapper>& in,
-                                               const std::vector<GPU_TensorViewWrapper>& out);
-                void emit_debug_function_exit(codegen::CodeWriter& writer,
-                                              Node* node,
-                                              const std::vector<GPU_TensorViewWrapper>& in,
-                                              const std::vector<GPU_TensorViewWrapper>& out);
-                void handle_output_alias(
-                    codegen::CodeWriter& writer,
-                    const Node&,
-                    const std::unordered_map<descriptor::TensorView*, std::vector<size_t>>&);
+                void collect_unique_functions();
+                void emit_header();
+                void emit_timer_functions();
+                void emit_constant_declarations();
+                void emit_function_declarations();
+                void emit_functions();
+                void emit_debug_function_entry(Node* node);
+                void emit_debug_function_exit(Node* node);
+                void emit_temp_mem_pool_allocation(std::shared_ptr<Function> current_function);
+                void emit_temp_mem_pool_release();
                 void release_function() { m_function = nullptr; }
+                void store_emitted_functions(const std::string& code);
                 std::string emit_op_as_function(const Node& node, const std::string& function_name);
                 std::string strip_comments(const std::string& s) const;
-                bool is_functionally_identical(
-                    const Node& n1,
-                    const Node& n2,
-                    const std::unordered_map<const Node*, std::string>& node_cache) const;
+
+                codegen::CodeWriter m_writer;
+                pass::Manager m_pass_manager;
 
                 std::unique_ptr<codegen::Compiler> m_compiler;
                 std::unique_ptr<codegen::ExecutionEngine> m_execution_engine;
-                bool m_emit_timing;
-                std::unordered_map<std::string, std::string> m_variable_name_map;
-                std::map<std::string, size_t> m_name_index_map;
+                std::unique_ptr<GPUPrimitiveEmitter> m_primitive_emitter;
+                std::unique_ptr<GPURuntimeContext> m_ctx;
                 std::shared_ptr<ngraph::Function> m_function;
-                bool m_release_function;
+
+                std::map<std::string, size_t> m_name_index_map;
+                std::unordered_map<std::string, std::string> m_variable_name_map;
+                std::unordered_map<const Node*, std::string> m_node_function_map;
+                std::unordered_map<std::shared_ptr<Function>, std::list<std::shared_ptr<Node>>>
+                    m_function_ordered_ops;
+
+                bool m_emit_timing;
                 bool m_is_compiled;
+                bool m_release_function;
+                bool m_temporaries_used;
+
+                std::string m_function_name;
+                std::string m_pch_header_source;
 
                 cublasHandle_t m_cublas_handle;
                 cudnnHandle_t m_cudnn_handle;
-                std::unique_ptr<GPUPrimitiveEmitter> m_primitive_emitter;
-                std::unique_ptr<GPURuntimeContext> m_ctx;
             };
         }
     }