RE: the breakpoint, you could just add a break to main and then follow the flow on down into function calls.
The overall flow looks like:

Load the model. This can be e.g. ONNX, Caffe2, etc. This will iterate over a protobuf for the model and create one or more Glow Nodes for every op in the model.
Optimize the Node IR (GraphOptimizer.cpp)
Quantize/add profiling nodes, and/or convert to fp16, if requested
Optimize Node IR some more
If requested by the backend, lower to other Nodes, e.g. take an LSTM and lower it to constituent nodes such as Mul, Add, Sigmoid, Tanh, etc. (Lower.cpp)
Optimize Node IR some more
Either load into the backend’s API here at Node IR level, or lower to Glow Instruction level (IRGen.cpp)

If using Instruction IR, perform Instruction-level optimizations (IROptimizer.cpp)


Backend produces some binary at this point as a [Backend]CompiledFunction object
Host Runtime (HostManager.cpp) now takes that CompiledFunction object and deploys to a device if needed (Provisioner.cpp)
For image-classifier, then images are loaded in and converted/normalized if needed, and then passed in as input tensors to the CompiledFunction to run. Results are returned and processed in image-classifier to determine the most likely label, and that’s printed.

It may be useful to take a look at our documentation on our IR:
  
      github.com
  
  
    pytorch/glow/blob/master/docs/IR.md 4
## Design of the Glow Intermediate Representation

### Introduction

This document describes the motivation behind the Glow intermediate
representation (IR) and some implementation details.

Glow is a retargetable compiler that supports a number of different backends.
This means that the first few layers of the compiler are target-independent, but
as you get closer to the different backends things start to diverge.  The first
two levels of IR are shared between all targets. Different backends may have
additional layers of IR.

### High-level IR

The high-level IR is a dataflow node-based graph representation that is similar
to a graph that you may find inside Caffe or in ONNX format. When we load a
neural network model from some file we construct this graph with a direct
translation of one operator to one or more nodes. The high-level IR is a simple
graph that allows basic transformations such as replacing all uses of some node


  This file has been truncated. show original