[pull] main from ChunelFeng:main

python/PyCGraph.cpp

@@ -263,6 +263,10 @@ PYBIND11_MODULE(PyCGraph, cg) {
              py::arg("key"),
              py::call_guard<py::gil_scoped_release>())
         .def("getName", &GElement::getName)
+        .def("getSession", &GElement::getSession)
+        .def("getRelation", &GElement::getRelation)
+        .def("getLoop", &GElement::getLoop)
+        .def("getCurState", &GElement::getCurState)
         .def("setLoop", &GElement::setLoop,
              py::arg("loop"))
         .def("setName", &GElement::setName,
@@ -280,9 +284,6 @@ PYBIND11_MODULE(PyCGraph, cg) {
         .def("isGGroup", &GElement::isGGroup)
         .def("isGAdaptor", &GElement::isGAdaptor)
         .def("isGNode", &GElement::isGNode)
-        .def("getRelation", &GElement::getRelation)
-        .def("getLoop", &GElement::getLoop)
-        .def("getCurState", &GElement::getCurState)
         .def("addGAspect", &GElement::__addGAspect_4py,
              py::arg("aspect"),
              py::keep_alive<1, 2>())

src/GraphCtrl/GraphElement/GElementDefine.h

@@ -57,6 +57,7 @@ enum class GElementShape {
     NORMAL = 0,                               // 普通的元素
     LINKABLE = 1,                             // 后继是唯一元素的情况（类似 list）
     ROOT = 2,                                 // 所有后继元素，只有一个前驱的情况（类似tree root）
+    TAIL = 3,                                 // 尾部节点
 };
 CGRAPH_INTERNAL_NAMESPACE_END
 

src/GraphCtrl/GraphElement/_GEngine/GDynamicEngine/GDynamicEngine.cpp

@@ -133,6 +133,7 @@ CVoid GDynamicEngine::process(GElementPtr element, CBool affinity) {
             // 当且仅当整体状正常，且当前状态异常的时候，进入赋值逻辑。确保不重复赋值
             CGRAPH_LOCK_GUARD lk(status_lock_);
             cur_status_ += curStatus;
+            locker_.cv_.notify_one();
         }
         afterElementRun(element);
     };
@@ -148,37 +149,45 @@ CVoid GDynamicEngine::process(GElementPtr element, CBool affinity) {
 
 CVoid GDynamicEngine::afterElementRun(GElementPtr element) {
     element->done_ = true;
-    if (!element->run_before_.empty() && cur_status_.isOK()) {
-        if (internal::GElementShape::LINKABLE == element->shape_) {
-            process(element->run_before_.front(), true);
-        } else if (internal::GElementShape::ROOT == element->shape_) {
-            for (CSize i = 0; i < element->run_before_.size(); i++) {
-                process(element->run_before_[i], i == element->run_before_.size() - 1);
+    if (unlikely(cur_status_.isErr())) {
+        return;
+    }
+
+    switch (element->shape_) {
+        case internal::GElementShape::NORMAL:
+            {
+                GElementPtr reserved = nullptr;
+                for (auto* cur : element->run_before_) {
+                    if (--cur->left_depend_ <= 0) {
+                        if (reserved) {
+                            process(cur, false);
+                        } else {
+                            reserved = cur;    // 留一个作为亲和性的，在当前线程运行
+                        }
+                    }
+                }
+
+                if (reserved) { process(reserved, true); }
             }
-        } else {
-            GElementPtr reserved = nullptr;
+            break;
+        case internal::GElementShape::LINKABLE:
+            process(element->run_before_.front(), true);
+            break;
+        case internal::GElementShape::ROOT:
             for (auto* cur : element->run_before_) {
-                if (--cur->left_depend_ <= 0) {
-                    if (reserved) {
-                        process(cur, false);
-                    } else {
-                        reserved = cur;    // 留一个作为亲和性的，在当前线程运行
-                    }
+                process(cur, element->run_before_.back() == cur);
+            }
+            break;
+        case internal::GElementShape::TAIL:
+            {
+                CGRAPH_LOCK_GUARD lock(locker_.mtx_);
+                if ((++finished_end_size_ >= total_end_size_)) {
+                    locker_.cv_.notify_one();
                 }
             }
-            if (reserved) { process(reserved, true); }
-        }
-    } else {
-        CGRAPH_LOCK_GUARD lock(locker_.mtx_);
-        /**
-         * 满足一下条件之一，则通知wait函数停止等待
-         * 1，无后缀节点全部执行完毕(在运行正常的情况下，只有无后缀节点执行完成的时候，才可能整体运行结束)
-         * 2，有节点执行状态异常
-         */
-        if ((element->run_before_.empty() && (++finished_end_size_ >= total_end_size_))
-            || cur_status_.isErr()) {
-            locker_.cv_.notify_one();
-        }
+            break;
+        default:
+            break;
     }
 }
 

src/GraphCtrl/GraphElement/_GEngine/GDynamicEngine/GDynamicEngine.h

@@ -97,7 +97,7 @@ class GDynamicEngine : public GEngine {
     CSize finished_end_size_ = 0;                                                        // 执行结束节点数量
     CStatus cur_status_;                                                                 // 当前全局的状态信息
     std::atomic<CSize> parallel_run_num_ {0};                                            // 纯并行时，执行的个数信息
-    GElementPtrMat2D parallel_element_matrix_ {};                                        // 纯并行时，记录
+    GElementPtrMat2D parallel_element_matrix_ {};                                        // 纯并行时，记录分解后的数据
 
     internal::GEngineDagType dag_type_ = { internal::GEngineDagType::COMMON };           // 当前元素的排布形式
 

src/GraphCtrl/GraphElement/_GEngine/GEngine.h

@@ -57,6 +57,8 @@ class GEngine : public GElementObject {
                        && std::all_of(succession.begin(), succession.end(),
                                       [](GElementPtr ptr) { return 1 == ptr->dependence_.size();})) {
                 element->shape_ = internal::GElementShape::ROOT;
+            } else if (element->run_before_.empty()) {
+                element->shape_ = internal::GElementShape::TAIL;
             } else {
                 element->shape_ = internal::GElementShape::NORMAL;
             }