|
function_block 1
function_block 1
对ccsrc\pipeline\jit\parse\function_block.h的部分注释
知识浅薄，还有许多未理解之处，欢迎各位纠正、讨论。
相对路径：mindspore\ccsrc\pipeline\jit\parse\function_block.h
function_block是功能块（组件），介绍了pipeline（管道）方法中解析部分的功能块，function_block.h则先进行了函数声明，宏定义，函数原型这一部分。
h文件是C语言和【C++】语言的头文件，一般在【.h】类的头文件里面只放入函数声明，宏定义，函数原型，而具体的实现在【.cpp】文件里面。
C程序的定义文件以.c为后缀,C++程序的定义文件通常以.cpp为后缀(也有一些系统以.cc或.cxx为后缀)
#ifndef MINDSPORE_CCSRC_PIPELINE_JIT_PARSE_FUNCTION_BLOCK_H_//防止双重定义
#define MINDSPORE_CCSRC_PIPELINE_JIT_PARSE_FUNCTION_BLOCK_H_//预编译命令
//导入系统库
#include <vector>
#include <string>
#include <map>
#include <set>
#include <unordered_map>//无序图库
#include <memory>
#include <utility>定义标准模块库（STL）类型.函数和运算符
//引用自定义头文件
#include "pipeline/jit/parse/parse_base.h"
#include "utils/log_adapter.h"
#include "utils/ordered_set.h"
namespace mindspore {//创建一个名为mindspore的空间，并在其中嵌套一个名为parse解析器(作语法分析)的空间
namespace parse {
class Parser;//解析类
class NameSpace;//命名空间类
class Symbol;//符号类
class FunctionBlock;//功能块类
using FunctionBlockPtr = std::shared_ptr<FunctionBlock>;//使用功能块类这个空间
// A function block is a straight-line code sequence with no branches, every block has one one exit point
// which is return. When parsing function, loop or branch , we use function block to track the structure of
// the original source code.
/*功能块是一个没有分支的直线代码序列，每个功能块都有一个出口点
这就是回报。在解析函数、循环或分支时，我们使用函数块跟踪原始源代码。*/
class FunctionBlock : public std::enable_shared_from_this<FunctionBlock> {//从该站点启用共享
public:
explicit FunctionBlock(const Parser &parser);
virtual ~FunctionBlock() {}
FuncGraphPtr func_graph() { return func_graph_; }//获取函数图
void WriteVariable(const std::string &var_name, const AnfNodePtr &node);//写入变量
AnfNodePtr ReadVariable(const std::string &var_name);//读变量
void AddPrevBlock(const FunctionBlockPtr &block);//添加块
void SetPhiArgument(const ParameterPtr &phi);//设置φ参数
bool CollectRemovablePhi(const ParameterPtr &phi);//判断是否可收集可移除的PHI
// A block is matured if all its predecessors is generated
//如果一个块的所有前辈(前面的操作)都已生成，则该块已成熟
void Mature();
CNodePtr ForceToBoolNode(const AnfNodePtr &cond);//强制布尔节点
CNodePtr ForceToWhileCond(const AnfNodePtr &cond);//强制至毫秒
void Jump(const FunctionBlockPtr &block, const AnfNodePtr &node);//跳转操作
AnfNodePtr SearchReplaceNode(const std::string &var, const ParameterPtr &phi);//搜索替换节点
void ConditionalJump(AnfNodePtr condNode, const FunctionBlockPtr &trueBlock, const FunctionBlockPtr &falseBlock,
bool unroll_loop = true);
//条件跳转
// Create cnode for the assign statement like self.target = source.
//为assign语句创建cnode，如self.target=source。
void SetStateAssign(const AnfNodePtr &target, const AnfNodePtr &source);//设置状态分配
void AddGlobalVar(const std::string &var_name) { (void)global_vars_.insert(var_name); }//添加全局变量
bool IsGlobalVar(const std::string &var_name) { return global_vars_.find(var_name) != global_vars_.end(); }//判断是否是全局变量
AnfNodePtr MakeResolveAstOp(const py::object &op);
AnfNodePtr MakeResolveClassMember(const std::string &attr);//使解析类成为成员
AnfNodePtr MakeResolveSymbol(const std::string &value);//生成解析符号
AnfNodePtr MakeResolveOperation(const std::string &value);//进行解析操作
AnfNodePtr MakeResolve(const std::shared_ptr<NameSpace> &name_space, const std::shared_ptr<Symbol> &resolve_symbol);
const std::unordered_map<ParameterPtr, AnfNodePtr> &removable_phis() const { return removable_phis_; }
void FindIsolatedNodes();//查找被分离的节点
void AddIsolatedNode(const AnfNodePtr &target);//添加隔离节点
void AttachIsolatedNodesBeforeReturn();//在返回之前附加隔离节点
private:
// Block graph
//块图
FuncGraphPtr func_graph_;
// Block parser
//块分析器
const Parser &parser_;
// A block is matured if all its prev_blocks is processed
// 如果一个区块的所有上一个区块都被处理，则该区块将到期
bool matured_;
// Store the nest-level block.
// Refer to comments in Parser::func_block_list_;
//存储嵌套级别的块。
//请参阅Parser:：func\u block\u list\ux中的注释；
std::vector<FunctionBlock *> prev_blocks_;
// Store args and variable's node, use a bool flag to indicate if the variable is used.
存储参数和变量的节点，使用bool标志指示是否使用了变量。
std::map<std::string, std::pair<AnfNodePtr, bool>> vars_;
// Map the parameter node to variable, it can be resolved if the block's predecessors are processed
// 将参数节点映射到变量，如果处理块的前置项，则可以解析该变量
std::map<ParameterPtr, std::string> phi_nodes_;
// Jumps map the successor block and the function call that perform jump
// Refer to comments in Parser::func_block_list_ that how to break the cyclic reference
//跳转映射后续块和执行跳转的函数调用
//请参阅Parser:：func_block_list_中的注释，了解如何中断循环引用
std::map<FunctionBlock *, CNodePtr> jumps_;
// Keep all removable phis which will be removed in one pass.
//保留所有将一次性删除的可移除的PHI。
std::unordered_map<ParameterPtr, AnfNodePtr> removable_phis_;
// Keep the map for the resolve node to the removable phi node.
// For the case that ReadVariable returns a phi node although this phi node
// generated in the prev block is identified as removable. The other blocks
// should find this phi node.
/*保留解析节点到可移动phi节点的映射。对于Read变量返回phi节点的情况，尽管此phi节点
在prev块中生成的被标识为可移动。其他块区应该找到这个phi节点。*/
std::unordered_map<AnfNodePtr, ParameterPtr> resolve_to_removable_phis_;
// Hold declared global variables in function
//在函数中保留声明的全局变量
std::set<std::string> global_vars_;
// Keep new made resolve symbol for the variable not found in vars_.
//为变量保留新生成的解析符号，但在变量中找不到。
std::unordered_map<std::string, AnfNodePtr> var_to_resolve_;
// Isolated nodes.
// 孤立节点。
OrderedSet<AnfNodePtr> isolated_nodes_;//包含孤立节点的有序集
};
} // namespace parse
} // namespace mindspore
#endif // MINDSPORE_CCSRC_PIPELINE_JIT_PARSE_FUNCTION_BLOCK_H_
以上即为本篇的所有内容，因学识与能力有限，如有不足之处，请多多包涵与指教。?
|