In the [fluid](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/fluid.md), we encourage user use deep learning programming paradigms to describe training process. When the user-written Python program is executed, it will create a protobuf message
[`ProgramDesc`](https://github.com/PaddlePaddle/Paddle/blob/a91efdde6910ce92a78e3aa7157412c4c88d9ee8/paddle/framework/framework.proto#L145) that describes the process and is conceptually like an [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
We use executor to do the runtime evaluation of a `ProgramDesc`.
The executor runs the `ProgramDesc` like an interpreter. `ProgramDesc` contains intrinsics/operators and variables which will be used, executor explicitly execute the stored precompiled code.
## Overview
## Overview
An executor takes a `ProgramDesc`, a `block_id` and a `Scope`. The `ProgramDesc` is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The `block_id` specifies the entrance block. And the `Scope` is the container of all the variable instance, which is persistent throughout different runs.
An executor takes a `ProgramDesc`, a `block_id` and a `Scope`. The `ProgramDesc` is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The `block_id` specifies the entrance block. And the `Scope` is the container of all the variable instance, which is persistent throughout different runs.
### What does executor do?
## Executor
It evaluates all the operators in the `block_id`th block of a `ProgramDesc`.
`Executor` explicitly executes all the intrinsics/operators in the `block_id`th block of a `ProgramDesc`. Essentially, it instantiates Variables and Operators, then runs all the operators in sequence. It is very similar to push stack frame when entering the block, it will destroy the temporary variables when mini-batch is finished, but it does not have stack frame pop process.
### What does executor NOT do?
### Interface
```c++
Executor(places);
```
A executor does not own any computing resources, user can only construct an executor with specified places.
It does not do runtime optimization, meaning intelligently parse the dependency of each op a choose which one to be run and in which order they should be run.
It does not do graph partitioning, meaning dividing the `ProgramDesc` into several small pieces and executing them on different devices.
A executor only provides an unified way to execute `ProgramDesc`. `ProgramDesc` is the target will be executed, scope specifies the variable container. `block_id` indicates the entrance block, `create_local_scope` means if it will destroy the temporary variables after execution finished.
`Executor` evaluates a `ProgramDesc`. Essentially, it instantiates Variables and Operators, then run all the operators in sequence. [[code]](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/executor.cc)
<spanid="executor-design-doc"></span><h1>Executor Design Doc<aclass="headerlink"href="#executor-design-doc"title="Permalink to this headline">¶</a></h1>
<spanid="executor-design-doc"></span><h1>Executor Design Doc<aclass="headerlink"href="#executor-design-doc"title="Permalink to this headline">¶</a></h1>
<divclass="section"id="motivation">
<divclass="section"id="motivation">
<spanid="motivation"></span><h2>Motivation<aclass="headerlink"href="#motivation"title="Permalink to this headline">¶</a></h2>
<spanid="motivation"></span><h2>Motivation<aclass="headerlink"href="#motivation"title="Permalink to this headline">¶</a></h2>
<p>We use executor to do the runtime evaluation of a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>.</p>
<p>In the <aclass="reference external"href="https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/fluid.md">fluid</a>, we encourage user use deep learning programming paradigms to describe training process. When the user-written Python program is executed, it will create a protobuf message
<aclass="reference external"href="https://github.com/PaddlePaddle/Paddle/blob/a91efdde6910ce92a78e3aa7157412c4c88d9ee8/paddle/framework/framework.proto#L145"><codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code></a> that describes the process and is conceptually like an <aclass="reference external"href="https://en.wikipedia.org/wiki/Abstract_syntax_tree">abstract syntax tree</a>.</p>
<p>The executor runs the <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> like an interpreter. <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> contains intrinsics/operators and variables which will be used, executor explicitly execute the stored precompiled code.</p>
</div>
</div>
<divclass="section"id="overview">
<divclass="section"id="overview">
<spanid="overview"></span><h2>Overview<aclass="headerlink"href="#overview"title="Permalink to this headline">¶</a></h2>
<spanid="overview"></span><h2>Overview<aclass="headerlink"href="#overview"title="Permalink to this headline">¶</a></h2>
<p>An executor takes a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>, a <codeclass="docutils literal"><spanclass="pre">block_id</span></code> and a <codeclass="docutils literal"><spanclass="pre">Scope</span></code>. The <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The <codeclass="docutils literal"><spanclass="pre">block_id</span></code> specifies the entrance block. And the <codeclass="docutils literal"><spanclass="pre">Scope</span></code> is the container of all the variable instance, which is persistent throughout different runs.</p>
<p>An executor takes a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>, a <codeclass="docutils literal"><spanclass="pre">block_id</span></code> and a <codeclass="docutils literal"><spanclass="pre">Scope</span></code>. The <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The <codeclass="docutils literal"><spanclass="pre">block_id</span></code> specifies the entrance block. And the <codeclass="docutils literal"><spanclass="pre">Scope</span></code> is the container of all the variable instance, which is persistent throughout different runs.</p>
<divclass="section"id="what-does-executor-do">
<spanid="what-does-executor-do"></span><h3>What does executor do?<aclass="headerlink"href="#what-does-executor-do"title="Permalink to this headline">¶</a></h3>
<p>It evaluates all the operators in the <codeclass="docutils literal"><spanclass="pre">block_id</span></code>th block of a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>.</p>
<spanid="what-does-executor-not-do"></span><h3>What does executor NOT do?<aclass="headerlink"href="#what-does-executor-not-do"title="Permalink to this headline">¶</a></h3>
<spanid="executor"></span><h2>Executor<aclass="headerlink"href="#executor"title="Permalink to this headline">¶</a></h2>
<p>It does not do runtime optimization, meaning intelligently parse the dependency of each op a choose which one to be run and in which order they should be run.</p>
<p><codeclass="docutils literal"><spanclass="pre">Executor</span></code> explicitly executes all the intrinsics/operators in the <codeclass="docutils literal"><spanclass="pre">block_id</span></code>th block of a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>. Essentially, it instantiates Variables and Operators, then runs all the operators in sequence. It is very similar to push stack frame when entering the block, it will destroy the temporary variables when mini-batch is finished, but it does not have stack frame pop process.</p>
<p>It does not do graph partitioning, meaning dividing the <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> into several small pieces and executing them on different devices.</p>
<divclass="section"id="interface">
<spanid="interface"></span><h3>Interface<aclass="headerlink"href="#interface"title="Permalink to this headline">¶</a></h3>
<p>A executor only provides an unified way to execute <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>. <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> is the target will be executed, scope specifies the variable container. <codeclass="docutils literal"><spanclass="pre">block_id</span></code> indicates the entrance block, <codeclass="docutils literal"><spanclass="pre">create_local_scope</span></code> means if it will destroy the temporary variables after execution finished.</p>
</div>
</div>
<divclass="section"id="implementation">
<spanid="implementation"></span><h2>Implementation<aclass="headerlink"href="#implementation"title="Permalink to this headline">¶</a></h2>
<p><codeclass="docutils literal"><spanclass="pre">Executor</span></code> evaluates a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>. Essentially, it instantiates Variables and Operators, then run all the operators in sequence. <aclass="reference external"href="https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/executor.cc">[code]</a></p>
In the [fluid](https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/fluid.md), we encourage user use deep learning programming paradigms to describe training process. When the user-written Python program is executed, it will create a protobuf message
[`ProgramDesc`](https://github.com/PaddlePaddle/Paddle/blob/a91efdde6910ce92a78e3aa7157412c4c88d9ee8/paddle/framework/framework.proto#L145) that describes the process and is conceptually like an [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
We use executor to do the runtime evaluation of a `ProgramDesc`.
The executor runs the `ProgramDesc` like an interpreter. `ProgramDesc` contains intrinsics/operators and variables which will be used, executor explicitly execute the stored precompiled code.
## Overview
## Overview
An executor takes a `ProgramDesc`, a `block_id` and a `Scope`. The `ProgramDesc` is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The `block_id` specifies the entrance block. And the `Scope` is the container of all the variable instance, which is persistent throughout different runs.
An executor takes a `ProgramDesc`, a `block_id` and a `Scope`. The `ProgramDesc` is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The `block_id` specifies the entrance block. And the `Scope` is the container of all the variable instance, which is persistent throughout different runs.
### What does executor do?
## Executor
It evaluates all the operators in the `block_id`th block of a `ProgramDesc`.
`Executor` explicitly executes all the intrinsics/operators in the `block_id`th block of a `ProgramDesc`. Essentially, it instantiates Variables and Operators, then runs all the operators in sequence. It is very similar to push stack frame when entering the block, it will destroy the temporary variables when mini-batch is finished, but it does not have stack frame pop process.
### What does executor NOT do?
### Interface
```c++
Executor(places);
```
A executor does not own any computing resources, user can only construct an executor with specified places.
It does not do runtime optimization, meaning intelligently parse the dependency of each op a choose which one to be run and in which order they should be run.
It does not do graph partitioning, meaning dividing the `ProgramDesc` into several small pieces and executing them on different devices.
A executor only provides an unified way to execute `ProgramDesc`. `ProgramDesc` is the target will be executed, scope specifies the variable container. `block_id` indicates the entrance block, `create_local_scope` means if it will destroy the temporary variables after execution finished.
`Executor` evaluates a `ProgramDesc`. Essentially, it instantiates Variables and Operators, then run all the operators in sequence. [[code]](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/executor.cc)
<p>We use executor to do the runtime evaluation of a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>.</p>
<p>In the <aclass="reference external"href="https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/fluid.md">fluid</a>, we encourage user use deep learning programming paradigms to describe training process. When the user-written Python program is executed, it will create a protobuf message
<aclass="reference external"href="https://github.com/PaddlePaddle/Paddle/blob/a91efdde6910ce92a78e3aa7157412c4c88d9ee8/paddle/framework/framework.proto#L145"><codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code></a> that describes the process and is conceptually like an <aclass="reference external"href="https://en.wikipedia.org/wiki/Abstract_syntax_tree">abstract syntax tree</a>.</p>
<p>The executor runs the <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> like an interpreter. <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> contains intrinsics/operators and variables which will be used, executor explicitly execute the stored precompiled code.</p>
<p>An executor takes a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>, a <codeclass="docutils literal"><spanclass="pre">block_id</span></code> and a <codeclass="docutils literal"><spanclass="pre">Scope</span></code>. The <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The <codeclass="docutils literal"><spanclass="pre">block_id</span></code> specifies the entrance block. And the <codeclass="docutils literal"><spanclass="pre">Scope</span></code> is the container of all the variable instance, which is persistent throughout different runs.</p>
<p>An executor takes a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>, a <codeclass="docutils literal"><spanclass="pre">block_id</span></code> and a <codeclass="docutils literal"><spanclass="pre">Scope</span></code>. The <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> is a list of blocks and each block contains the protobuf definition of all the parameters and operators. The <codeclass="docutils literal"><spanclass="pre">block_id</span></code> specifies the entrance block. And the <codeclass="docutils literal"><spanclass="pre">Scope</span></code> is the container of all the variable instance, which is persistent throughout different runs.</p>
<divclass="section"id="what-does-executor-do">
<spanid="what-does-executor-do"></span><h3>What does executor do?<aclass="headerlink"href="#what-does-executor-do"title="永久链接至标题">¶</a></h3>
<p>It evaluates all the operators in the <codeclass="docutils literal"><spanclass="pre">block_id</span></code>th block of a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>.</p>
<spanid="what-does-executor-not-do"></span><h3>What does executor NOT do?<aclass="headerlink"href="#what-does-executor-not-do"title="永久链接至标题">¶</a></h3>
<p>It does not do runtime optimization, meaning intelligently parse the dependency of each op a choose which one to be run and in which order they should be run.</p>
<p><codeclass="docutils literal"><spanclass="pre">Executor</span></code> explicitly executes all the intrinsics/operators in the <codeclass="docutils literal"><spanclass="pre">block_id</span></code>th block of a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>. Essentially, it instantiates Variables and Operators, then runs all the operators in sequence. It is very similar to push stack frame when entering the block, it will destroy the temporary variables when mini-batch is finished, but it does not have stack frame pop process.</p>
<p>It does not do graph partitioning, meaning dividing the <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> into several small pieces and executing them on different devices.</p>
<p>A executor only provides an unified way to execute <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>. <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code> is the target will be executed, scope specifies the variable container. <codeclass="docutils literal"><spanclass="pre">block_id</span></code> indicates the entrance block, <codeclass="docutils literal"><spanclass="pre">create_local_scope</span></code> means if it will destroy the temporary variables after execution finished.</p>
<p><codeclass="docutils literal"><spanclass="pre">Executor</span></code> evaluates a <codeclass="docutils literal"><spanclass="pre">ProgramDesc</span></code>. Essentially, it instantiates Variables and Operators, then run all the operators in sequence. <aclass="reference external"href="https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/framework/executor.cc">[code]</a></p>
