rfnoc: graph: Lock release/commit state

Property propagation and action handling depend on the release state,
but they are lengthy operations. It is therefore imperative to not
change the release/commit state during those methods.

This commit changes the following:
- Change the release state counter from an atomic to a non-atomic
  variable
- Instead, use a mutex to lock the release state counter, and use the
  same mutex for locking access to the property propagation and action
  handling

The rfnoc_graph now tries to release the graph before shutting down
blocks to make sure they don't get destroyed while those algorithms are
still running.

1 files changed, 15 insertions, 3 deletions

diff --git a/host/lib/rfnoc/graph.cpp b/host/lib/rfnoc/graph.cpp
index 1a25f84f9..6c849b61f 100644
--- a/host/lib/rfnoc/graph.cpp
+++ b/host/lib/rfnoc/graph.cpp
@@ -175,17 +175,20 @@ void graph_t::connect(node_ref_t src_node, node_ref_t dst_node, graph_edge_t edg
 
 void graph_t::commit()
 {
+    std::lock_guard<std::recursive_mutex> l(_release_mutex);
     if (_release_count) {
         _release_count--;
+    }
+    if (_release_count == 0) {
         _check_topology();
+        resolve_all_properties();
     }
-    UHD_LOG_TRACE(LOG_ID, "graph::commit() => " << _release_count.load());
-    resolve_all_properties();
 }
 
 void graph_t::release()
 {
-    UHD_LOG_TRACE(LOG_ID, "graph::release() => " << _release_count.load());
+    std::lock_guard<std::recursive_mutex> l(_release_mutex);
+    UHD_LOG_TRACE(LOG_ID, "graph::release() => " << _release_count);
     _release_count++;
 }
 
@@ -212,6 +215,11 @@ void graph_t::resolve_all_properties()
     if (boost::num_vertices(_graph) == 0) {
         return;
     }
+    // We can't release during property propagation, so we lock this entire
+    // method to make sure that a) different threads can't interfere with each
+    // other, and b) that we don't release the graph while this method is still
+    // running.
+    std::lock_guard<std::recursive_mutex> l(_release_mutex);
     if (_release_count) {
         return;
     }
@@ -350,6 +358,10 @@ void graph_t::resolve_all_properties()
 void graph_t::enqueue_action(
     node_ref_t src_node, res_source_info src_edge, action_info::sptr action)
 {
+    // We can't release during action handling, so we lock this entire
+    // method to make sure that we don't release the graph while this method is
+    // still running.
+    std::lock_guard<std::recursive_mutex> release_lock(_release_mutex);
     if (_release_count) {
         UHD_LOG_WARNING(LOG_ID,
             "Action propagation is not enabled, graph is not committed! Will not "