Addressing PR comments

Author: Bensuo

sycl/doc/extensions/experimental/sycl_ext_oneapi_graph.asciidoc

@@ -280,14 +280,12 @@ dependencies in one of three ways. Firstly, through buffer accessors that
 represent data dependencies between two command groups captured as nodes.
 Secondly, by using the `handler::depends_on()` mechanism inside a command group
 captured as a node. However, for an event passed to `handler::depends_on()` to
-create an edge, it must be an event returned from a queue
-submission captured by the same graph. Passing events from other sources (other
-graph submissions, regular SYCL submissions) will not create edges in the graph,
-but will create runtime dependencies for a graph node on those other events.
-`handler::depends_on()` can be used to express edges when a user is working with
-USM memory rather than SYCL buffers. Thirdly, for a graph recorded with an
-in-order queue, an edge is added automatically between two sequential command
-groups submitted to the in-order queue. 
+create an edge, it must be an event returned from a queue submission captured by
+the same graph. Passing events from other sources (other graph submissions,
+regular SYCL submissions) will not create edges in the graph, but will create
+runtime dependencies for a graph node on those other events. Thirdly, for a
+graph recorded with an in-order queue, an edge is added automatically between
+two sequential command groups submitted to the in-order queue. 
 
 |===
 
@@ -478,7 +476,7 @@ Exceptions:
 
 |===
 
-==== Dynamic Parameters
+==== Dynamic Parameters [[dynamic-parameters]]
 
 [source,c++]
 ----
@@ -569,9 +567,9 @@ class depends_on {
     template<typename... NodeTN>
     depends_on(NodeTN... nodes);
 
-    depends_on(const event& ev);
+    depends_on(const event& depEvent);
 
-    depends_on(const std::vector<event>& events);
+    depends_on(const std::vector<event>& depEvents);
 };
 }
 ----
@@ -580,7 +578,7 @@ The API for explicitly adding nodes to a `command_graph` includes a
 `property_list` parameter. This extension defines the `depends_on` property to
 be passed here. `depends_on` may be used in two ways:
 
-* Passing nodes from the same command_graph which will create dependencies and
+* Passing nodes from the same `command_graph` which will create dependencies and
 graph edges between those nodes and the node being added. 
 
 * Passing SYCL events will create runtime dependencies for execution of the
@@ -723,14 +721,16 @@ Updates to a graph will be scheduled after any in-flight executions of the same
 graph and will not affect previous submissions of the same graph. The user is
 not required to wait on any previous submissions of a graph before updating it.
 
-The only type of nodes that are currently supported for updating in a graph are
-kernel execution nodes.
-
 The aspects of a kernel execution node that can be configured during update are:
 
 * Parameters to the kernel.
 * Execution ND-Range of the kernel.
 
+All node types may have the following aspects configured during update:
+
+* Dependent events which were specified using <<dyanmic-events, Dynamic
+Events>>.
+
 To update an executable graph, the `property::graph::updatable` property must
 have been set when the graph was created during finalization. Otherwise, an
 exception will be thrown if a user tries to update an executable graph. This
@@ -777,7 +777,7 @@ will maintain the graphs data dependencies.
 ===== Node Event Dependency Update
 
 Event dependencies for nodes can be updated using <<dynamic-events, Dynamic
-Events>> in a similar usage to Dynamic Parameters.
+Events>> in a similar usage to <<dynamic-parameters, Dynamic Parameters>>.
 
 Event updates are performed using a `dynamic_event` instance and calling
 `dynamic_event::update()` to update all the associated event dependencies of
@@ -1125,6 +1125,20 @@ event get_event(const node& n);
 only for the next execution of the graph. This event can be used as a dependency
 in the same way as normal SYCL events.
 
+Constraints:
+
+* This member function is only available when the `command_graph` state is
+  `graph_state::executable`.
+
+Parameters:
+
+* `n` - The node to get the associated event for.
+
+Exceptions:
+
+* Throws synchronously with error code `invalid` if `n` is not a node within the
+graph.
+
 |===
 
 Table {counter: tableNumber}. Member functions of the `command_graph` class for
@@ -1608,8 +1622,8 @@ different from the one with which the dynamic_parameter was created.
 
 [source,c++]
 ----
-namespace ext::oneapi::experimental{
-  class dynamic_event{
+namespace ext::oneapi::experimental {
+  class dynamic_event {
     dynamic_event();
     dynamic_event(const event& ev);
 
@@ -1620,7 +1634,7 @@ namespace ext::oneapi::experimental{
 
 Dynamic events represent SYCL events from outside of a given `command_graph`
 (either obtained from normal SYCL operations or from another `command_graph`)
-that nodes in that graph may depend on.  Dynamic events also allow for these
+that nodes in that graph may depend on. The `dynamic_event` object enables these
 dependent events to be updated between graph executions.
 
 Dynamic events can be used to add dependencies to a graph node in the same way
@@ -2219,6 +2233,65 @@ node nodeA = myGraph.add([&](handler& cgh) {
 dynParamAccessor.update(bufferB.get_access());
 ----
 
+=== Dynamic Event Update
+
+Example which shows create a dependency between two graphs using dynamic events
+which are then updated between executions.
+
+[source,c++]
+----
+...
+
+using namespace sycl;
+namespace sycl_ext = sycl::ext::oneapi::experimental;
+
+queue myQueue;
+auto myContext = myQueue.get_context();
+auto myDevice = myQueue.get_device();
+
+// Create the first graph
+sycl_ext::command_graph graphA(myContext, myDevice);
+
+// Add a node to graphA
+sycl_ext::node nodeA = graphA.add(...);
+
+sycl_ext::command_graph<sycl_ext::graph_state::executable> execGraphA = 
+  graphA.finalize();
+
+// Get an event for the next execution of nodeA in execGraphA
+event eventA = execGraph.get_event(nodeA);
+
+// Create the second graph
+sycl_ext::command_graph graphB(myContext, myDevice);
+
+// Create the dynamic event which will wrap eventA and use it as a dependency
+// for a node in graphB
+sycl_ext::dynamic_event dynEvent{eventA};
+
+auto nodeB = graphB.add([&](handler& CGH){
+  CGH.depends_on(dynEvent);
+  CGH.parallel_for(...);
+});
+
+auto execGraphB = graphB.finalize({sycl_ext::property::graph::updatable});
+
+// Submit both graphs for execution
+myQueue.submit(execGraphA);
+myQueue.submit(execGraphB);
+myQueue.wait_and_throw();
+
+// Update the dynamic event with a new event frome execGraphA to reflect the
+// next execution
+dynEvent.update(execGraphA.get_event(nodeA));
+// Update execGraphB with the affected node to reflect those changes
+execGraphB.update(nodeB);
+
+// Both graphs can now be executed again with updated dependencies between them.
+myQueue.submit(execGraphA);
+myQueue.submit(execGraphB);
+myQueue.wait_and_throw();
+----
+
 == Future Direction [[future-direction]]
 
 This section contains both features of the specification which have been