updated sanitizer

twhuang-utah · twhuang-utah · commit 46bc2d310552 · 2021-06-17T15:06:19.000-06:00
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
@@ -20,6 +20,7 @@ list(APPEND TF_EXAMPLES
   limited_concurrency
   cancel
   cancel_async
+  sanitizer
 )
 
 foreach(example IN LISTS TF_EXAMPLES)
diff --git a/examples/sanitizer.cpp b/examples/sanitizer.cpp
@@ -0,0 +1,16 @@
+#include <taskflow/taskflow.hpp>
+#include <taskflow/sanitizer/sanitizer.hpp>
+
+int main() {
+
+  tf::Taskflow taskflow;
+
+  // create tasks in taskflow ...
+  
+  tf::Sanitizer sanitizer;
+
+  sanitizer.check_nonreachable(taskflow, std::cout);
+
+
+  return 0;
+}
diff --git a/taskflow/core/declarations.hpp b/taskflow/core/declarations.hpp
@@ -43,6 +43,9 @@ class syclGraph;
 class syclTask;
 class syclFlow;
 
+// clas
+class Sanitizer;
+
 
 }  // end of namespace tf -----------------------------------------------------
 
diff --git a/taskflow/core/graph.hpp b/taskflow/core/graph.hpp
@@ -35,6 +35,7 @@ class Graph {
   friend class Node;
   friend class Taskflow;
   friend class Executor;
+  friend class Sanitizer;
 
   public:
 
@@ -77,6 +78,7 @@ class Node {
   friend class Executor;
   friend class FlowBuilder;
   friend class Subflow;
+  friend class Sanitizer;
 
   TF_ENABLE_POOLABLE_ON_THIS;
 
diff --git a/taskflow/cuda/cuda_capturer.hpp b/taskflow/cuda/cuda_capturer.hpp
@@ -49,8 +49,8 @@ That is, the callable that describes a %cudaFlowCapturer
 will be executed sequentially.
 Inside a %cudaFlow capturer task, different GPU tasks (tf::cudaTask) may run
 in parallel depending on the selected optimization algorithm.
-By default, we use tf::cudaSequentialCapturing to generate a sequential
-CUDA graph.
+By default, we use tf::cudaRoundRobinCapturing to transform a user-level
+graph into a native CUDA graph.
 
 Please refer to @ref GPUTaskingcudaFlowCapturer for details.
 */
@@ -125,6 +125,11 @@ class cudaFlowCapturer {
     a user-described %cudaFlow:
       + tf::cudaSequentialCapturing
       + tf::cudaRoundRobinCapturing
+      + tf::cudaLinearCapturing
+
+    By default, tf::cudaFlowCapturer uses the round-robin optimization 
+    algorithm with four streams to transform a user-level graph into
+    a native CUDA graph.
     */
     template <typename OPT, typename... ArgsT>
     OPT& make_optimizer(ArgsT&&... args);
@@ -1126,6 +1131,7 @@ inline cudaTask cudaFlowCapturer::memcpy(
   });
 }
 
+// Function: copy
 template <typename T, std::enable_if_t<!std::is_same_v<T, void>, void>*>
 cudaTask cudaFlowCapturer::copy(T* tgt, const T* src, size_t num) {
   return on([tgt, src, num] (cudaStream_t stream) mutable {
diff --git a/taskflow/sanitizer/sanitizer.hpp b/taskflow/sanitizer/sanitizer.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../core/taskflow.hpp"
+
+namespace tf {
+
+class Sanitizer {
+
+
+  public:
+
+    bool check_nonreachable(const Taskflow& taskflow, std::ostream& os) {
+      
+      os << "hello I am checking your taskflow with nonreachable tasks\n";
+      
+      // TODO (McKay): design the graph data structure extracted from taskflow
+      //               understand tf::Taskflow::dump
+
+      return false;
+    }
+
+};
+
+
+} // end of namespace tf 

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ list(APPEND TF_EXAMPLES`
`20`	`20`	`limited_concurrency`
`21`	`21`	`cancel`
`22`	`22`	`cancel_async`
	`23`	`+ sanitizer`
`23`	`24`	`)`
`24`	`25`
`25`	`26`	`foreach(example IN LISTS TF_EXAMPLES)`