dalgona::PythonHooks Class Reference

#include <PythonHooks.h>

Collaboration diagram for dalgona::PythonHooks:

Public Member Functions
	PythonHooks (luci_interpreter::Interpreter *interpreter)
void	importAnalysis (const std::string &analysis_path, py::object &globals, const std::string &analysis_args)
void	endAnalysis ()
void	startNetworkExecution (loco::Graph *graph)
void	endNetworkExecution (loco::Graph *graph)
void	preOperatorExecute (const luci::CircleNode *node) override
void	postOperatorExecute (const luci::CircleNode *node) override
Public Member Functions inherited from luci_interpreter::ExecutionObserver
virtual	~ExecutionObserver ()
virtual void	postTensorWrite (const luci::CircleNode *node, const Tensor *tensor)

Detailed Description

Definition at line 32 of file PythonHooks.h.

Constructor & Destructor Documentation

PythonHooks()

dalgona::PythonHooks::PythonHooks ( luci_interpreter::Interpreter *  interpreter )

inline

Definition at line 35 of file PythonHooks.h.

                                                        : _interpreter(interpreter)
  {
    // Do nothing
  }

Member Function Documentation

endAnalysis()

void dalgona::PythonHooks::endAnalysis

(

)

Definition at line 103 of file PythonHooks.cpp.

{
  if (py::hasattr(_analysis, "EndAnalysis"))
    pySafeCall(_analysis.attr("EndAnalysis"));
}

References dalgona::pySafeCall().

endNetworkExecution()

void dalgona::PythonHooks::endNetworkExecution

(

loco::Graph *

graph

)

Definition at line 84 of file PythonHooks.cpp.

{
  if (!py::hasattr(_analysis, "EndNetworkExecution"))
    return;
 
  assert(graph != nullptr); // FIX_CALLER_UNLESS
 
  const auto output_nodes = loco::output_nodes(graph);
  py::list outputs;
  // Assumption: output_nodes is iterated in the same order of model outputs
  for (const auto output_node : output_nodes)
  {
    auto circle_node = loco::must_cast<luci::CircleOutput *>(output_node);
    outputs.append(
      outputPyArray(loco::must_cast<luci::CircleNode *>(circle_node->from()), _interpreter));
  }
  pySafeCall(_analysis.attr("EndNetworkExecution"), outputs);
}

References loco::output_nodes(), dalgona::outputPyArray(), and dalgona::pySafeCall().

importAnalysis()

void dalgona::PythonHooks::importAnalysis	(	const std::string &	analysis_path,
		py::object &	globals,
		const std::string &	analysis_args
	)

Definition at line 39 of file PythonHooks.cpp.

{
  const auto base_filename = analysis_path.substr(analysis_path.find_last_of("/\\") + 1);
  // module name must be the same with the python code
  // ex: base_filename = MyAnalysis.py -> module_name = MyAnalysis
  const auto module_name = base_filename.substr(0, base_filename.find_last_of('.'));
 
  py::dict locals;
  locals["path"] = py::cast(analysis_path);
 
  py::eval<py::eval_statements>("import sys\n"
                                "import os\n"
                                "sys.path.append(os.path.dirname(path))\n"
                                "import " +
                                  module_name +
                                  "\n"
                                  "analysis = " +
                                  module_name + "." + module_name + "()",
                                globals, locals);
 
  _analysis = locals["analysis"];
 
  if (py::hasattr(_analysis, "StartAnalysis"))
    pySafeCall(_analysis.attr("StartAnalysis"), analysis_args);
}

References dalgona::pySafeCall().

postOperatorExecute()

void dalgona::PythonHooks::postOperatorExecute ( const luci::CircleNode *  node )

overridevirtual

Reimplemented from luci_interpreter::ExecutionObserver.

Definition at line 33 of file PythonHooks.cpp.

{
  PostOperatorHook hook(_analysis, _interpreter);
  node->accept(&hook);
}

References luci::CircleNode::accept().

preOperatorExecute()

void dalgona::PythonHooks::preOperatorExecute ( const luci::CircleNode *  node )

overridevirtual

Reimplemented from luci_interpreter::ExecutionObserver.

Definition at line 27 of file PythonHooks.cpp.

{
  PreOperatorHook hook(_analysis, _interpreter);
  node->accept(&hook);
}

References luci::CircleNode::accept().

startNetworkExecution()

void dalgona::PythonHooks::startNetworkExecution

(

loco::Graph *

graph

)

Definition at line 66 of file PythonHooks.cpp.

{
  if (!py::hasattr(_analysis, "StartNetworkExecution"))
    return;
 
  assert(graph != nullptr); // FIX_CALLER_UNLESS
 
  const auto input_nodes = loco::input_nodes(graph);
  py::list inputs;
  // Assumption: input_nodes is iterated in the same order of model inputs
  for (const auto input_node : input_nodes)
  {
    auto circle_node = loco::must_cast<luci::CircleInput *>(input_node);
    inputs.append(outputPyArray(circle_node, _interpreter));
  }
  pySafeCall(_analysis.attr("StartNetworkExecution"), inputs);
}

References loco::input_nodes(), dalgona::outputPyArray(), and dalgona::pySafeCall().

---

The documentation for this class was generated from the following files:

• compiler/dalgona/include/PythonHooks.h
• compiler/dalgona/src/PythonHooks.cpp