void RuntimeGraph::ProbeNextLayer(const std::shared_ptr<RuntimeOperator> &current_op,std::deque<std::shared_ptr<RuntimeOperator>> &operator_queue,std::vector<std::shared_ptr<Tensor<float>>> layer_output_datas) {const auto &next_ops = current_op->output_operators;std::vector<std::vector<std::shared_ptr<ftensor>>> next_input_datas_arr;for (const auto &next_op : next_ops) {const auto &next_rt_operator = next_op.second;const auto &next_input_operands = next_rt_operator->input_operands;// 找到后继节点if (next_input_operands.find(current_op->name) != next_input_operands.end()) {std::vector<std::shared_ptr<ftensor>> next_input_datas =next_input_operands.at(current_op->name)->datas;next_input_datas_arr.push_back(next_input_datas);next_rt_operator->meet_num += 1;
//检查 next_rt_operator 是否需要当前操作符的输出数据作为输入（通过检查 next_input_operands 中是否包//含当前操作符的名字）。
//如果需要当前操作符的输出作为输入，那么就获取相应的输入数据（next_input_datas）。
//将 next_input_datas 存入 next_input_datas_arr，这是一个二维向量，用于存储所有下一层操作符的输入数//据。
//增加 next_rt_operator 的 meet_num，可能是用来追踪该操作符已满足的条件数目。if (std::find(operator_queue.begin(), operator_queue.end(),next_rt_operator) == operator_queue.end()) {if (CheckOperatorReady(next_rt_operator)) {operator_queue.push_back(next_rt_operator);
//代码检查 next_rt_operator 是否已经存在于 operator_queue 中：
//如果不存在于队列中，并且满足一定的就绪条件（通过 CheckOperatorReady 函数判断），则将 //next_rt_operator 添加到 operator_queue 中，以便后续处理。
//最后，调用 SetOpInputData 函数，将之前收集到的下一层操作符的输入数据与当前层的输出数据关联起来。//如果ready了，那就把后继节点放入到队列之中}}}}SetOpInputData(layer_output_datas, next_input_datas_arr);
}

void RuntimeGraph::ProbeNextLayer(const std::shared_ptr<RuntimeOperator> &current_op,std::deque<std::shared_ptr<RuntimeOperator>> &operator_queue,std::vector<std::shared_ptr<Tensor<float>>> layer_output_datas)

可以看到该函数有三个参数，分别为current_op,operator_queue和layer_output_datas，这三个参数的定义如下：

current_op表示当前执行完毕的节点，operator_queue就是在上一节中提到的节点执行队列，layer_output_datas就是当前current_op被执行后得到的对应输出。

const auto &next_ops = current_op->output_operators;std::vector<std::vector<std::shared_ptr<ftensor>>> next_input_datas_arr;

得到当前节点current_op的后继节点, next_ops

std::vector<std::vector<std::shared_ptr<ftensor>>> next_input_datas_arr;for (const auto &next_op : next_ops) {const auto &next_rt_operator = next_op.second;// layer_output_datas 需要拷贝到next_input_operands的datas中const auto &next_input_operands = next_rt_operator->input_operands;

这里对next_ops进行遍历，依次获得后继节点中的其中一个next_op，随后我们得到next_op的输入数据引用。

我们要得到next_op.input_operands呢？我们就是要把current_op.output_data拷贝到其中，完成current_op输出到后继节点输入的拷贝。

next_rt_operator->meet_num += 1; // 0 --> 1
if (std::find(operator_queue.begin(), operator_queue.end(),next_rt_operator) == operator_queue.end()) {if (CheckOperatorReady(next_rt_operator)) {// 把后继节点放入到执行队列operator_queue.push_back(next_rt_operator);}
}

可以看到其中的meet_num，对于一个节点next_operator来说，如果meet_num的数量等于它前驱的数量，说明它现在可以被放入到执行队列中。

bool RuntimeGraph::CheckOperatorReady(const std::shared_ptr<RuntimeOperator> &op) {CHECK(op != nullptr);CHECK(op->meet_num <= op->input_operands.size());if (op->meet_num == op->input_operands.size()) {return true;} else {return false;}
}

判断，如果meet_num == 输入节点数的话，那就代表之前节点的输出已经全部结束了，现在可以将他们放入到下一节点的输入里面了。

void RuntimeGraph::SetOpInputData(std::vector<std::shared_ptr<Tensor<float>>> &src,std::vector<std::vector<std::shared_ptr<Tensor<float>>>> &dest) {CHECK(!src.empty() && !dest.empty()) << "Src or dest array is empty!";for (uint32_t j = 0; j < src.size(); ++j) {const auto &src_data = src.at(j)->data();for (uint32_t i = 0; i < dest.size(); ++i) {//      CHECK(!dest.empty() && dest.at(i).size() == src.size());dest.at(i).at(j)->set_data(src_data);}}
}// 这是一个名为 SetOpInputData 的函数，可能是在运行时图中进行数据关联操作的一部分。// 函数的参数包括：//   src：一个存储浮点类型张量（Tensor）共享指针的向量，表示要用于设置输入数据的源数据。// dest：一个二维向量，其中每行表示一个操作符的输入数据，每列表示不同的源数据。// 函数开始时，会使用断言（CHECK）来确保源数据 src 和目标数据 dest 都不为空，否则会产生错误信息。//  然后，通过两个嵌套的循环遍历源数据 src 和目标数据 dest：//    外部循环遍历源数据 src 中的每个元素。//  内部循环遍历目标数据 dest 中的每一行（操作符的输入数据）。//  在内部循环中，获取源数据 src 的具体数据（src_data）。// 接着，将源数据 src_data 设置到目标数据中，这个过程通过 dest.at(i).at(j)->set_data(src_data) 来实现。这里 i 表示操作符的索引，j 表示源数据的索引。

总体是将layer_output_datas这个输出张量复制到next_input_datas_arr这个张量数组（后继的输入）上，指针复制几乎无消耗。

广度优先搜索的执行顺序的实现

就是在咱们的Forward函数中：

我们首先来看它的两个参数，inputs为模型的输入张量，debug表示是否开启打印调试功能。

std::vector<std::shared_ptr<Tensor<float>>> RuntimeGraph::Forward(const std::vector<std::shared_ptr<Tensor<float>>> &inputs, bool debug)

这里是Forward方法中对图状态的检查，只有图状态为complete的时候才能执行图的调度，图的complete时间发生在：

1. 图中的计算节点都初始化完毕
2. 输入输入输出算子都准备好相关的空间之后

input_op为整张图的开始执行节点，也就是模型的执行入口。

if (graph_state_ < GraphState::Complete) {LOG(FATAL) << "Graph need be build!";}CHECK(graph_state_ == GraphState::Complete)<< "Graph status error, current state is " << int(graph_state_);std::shared_ptr<RuntimeOperator> input_op;if (input_operators_maps_.find(input_name_) == input_operators_maps_.end()) {LOG(FATAL) << "Can not find the input node: " << input_name_;} else {input_op = input_operators_maps_.at(input_name_);}

将输入节点送入到执行队列中， 执行队列在这里的变量为operator_queue，是一个deque结构，方便从尾部插入，并从头部取出（完成先进先出）。

std::deque<std::shared_ptr<RuntimeOperator>> operator_queue;
operator_queue.push_back(input_op);std::map<std::string, double> run_duration_infos;
while (!operator_queue.empty()) {std::shared_ptr<RuntimeOperator> current_op = operator_queue.front();operator_queue.pop_front();if (!current_op || current_op == output_op) {if (debug) {LOG(INFO) << "Model Inference End";}break;}  ......
}

std::shared_ptr\<RuntimeOperator> current_op = operator_queue.front(); 从队列中获取一个被执行的节点，按照先进先出的顺序执行。

if (current_op == input_op) {ProbeNextLayer(current_op, operator_queue, inputs);
}

这里分为两种情况，如果 当前节点是输入节点，就直接使用ProbeNextLayer将输入拷贝到输入节点的下一层中（因为input节点不涉及到别的操作，所以可以直接赋值）。

std::string current_op_name = current_op->name;
if (!CheckOperatorReady(current_op)) {if (operator_queue.empty()) {// 当current op是最后一个节点的时候，说明它已经不能被ready 就是说既没有ready，又是最后一个节点，所以没有其他的节点，不能被meet_num+1了。LOG(FATAL) << "Current operator is not ready!";break;} else {// 如果不是最后一个节点，它还有被ready的可能性，只是可能由于什么原因放错了位置，那就放回到里面等待再meet_num+1再执行operator_queue.push_back(current_op);}
}

如果当前的节点(current_op)不是输入节点(input_operator)就对它是否准备好进行检查，检查的方式同样是使用CheckOperatorReady检查当前节点的入度，如果入度等于0，那么当前的节点就允许被执行。

如果这个节点还没有ready，就需要重新被放入到operator_queue当中。

const std::vector<std::shared_ptr<RuntimeOperand>> &input_operand_datas = current_op->input_operands_seq;
std::vector<std::shared_ptr<Tensor<float>>> layer_input_datas;
for (const auto &input_operand_data : input_operand_datas) {for (const auto &input_data : input_operand_data->datas) {layer_input_datas.push_back(input_data);}
}

将当前op中的input移动到layer_input_datas(全指针拷贝，损耗可以忽略不计)，也就是从op->input_operands_seq中到layer_input_datas中。

InferStatus status = current_op->layer->Forward(layer_input_datas, current_op->output_operands->datas);

在op自身ready，且输入已经准备到layer_input_data之后，开始执行算子，但是这节课中算子执行不讨论。

ProbeNextLayer(current_op, operator_queue, current_op->output_operands->datas);

在执行完毕后，对当前的算子current_op的输出同步它下一级后继节点的输入中。

while (!operator_queue.empty())

当执行队列中的节点执行均执行完毕，且图中没有未执行的节点时就跳出循环。

CHECK(output_op->input_operands.size() == 1)<< "The graph only support one path to the output node yet!";const auto &output_op_input_operand = output_op->input_operands.begin();const auto &output_operand = output_op_input_operand->second;return output_operand->datas;

将output operator的input operand输出为最后的结果，换句话理解，输出节点的输入张量就是最后得到的结果。

最后可以看到对于resnet18的输出网络，实现执行分支再执行最下面的