Fixes #656, fixes #656: Stream capture functionality work:

* Now offering global capture mode as a default (so the user doesn't need to always specify it explicitly)
* Can now start and stop capturing using stand-alone functions in addition to stream_t methods
* Also marked `cuda::stream::capture::state()` as `inline`, although it  may not have needed it

examples/modified_cuda_samples/simpleCudaGraphs/simpleCudaGraphs.cu

@@ -278,6 +278,12 @@ void cudaGraphsManual(
 
 	graph.insert.edge(memcpy_result_node, host_function_node);
 
+	auto instance = graph.instantiate();
+	cuda::graph::node::parameters_t<node_kind_t::kernel_launch>* params_ptr = nullptr;
+	cuda::graph::instance::set_node_parameters<node_kind_t::kernel_launch>(instance, reduce_final_node, *params_ptr);
+
+
+
 	use(device, graph, graph_construction_mode);
 }
 
@@ -410,7 +416,7 @@ void cudaGraphsUsingStreamCapture(
 	auto reduce_output_memset_event = cuda::event::create(device);
 	auto final_result_memset_event = cuda::event::create(device);
 
-	stream_1.begin_capture(cuda::stream::capture::mode_t::global);
+	stream_1.begin_capture();
 
 	stream_1.enqueue.event(fork_stream_event);
 	stream_2.enqueue.wait(fork_stream_event);
@@ -419,15 +425,15 @@ void cudaGraphsUsingStreamCapture(
 	stream_1.enqueue.copy(inputVec_d, inputVec_h);
 	stream_2.enqueue.memzero(outputVec_d);
 
-	stream_2.enqueue.event(reduce_output_memset_event);
+	stream_2.enqueue.event();
 	stream_3.enqueue.memzero(result_d);
 	stream_3.enqueue.event(final_result_memset_event);
 
 	stream_1.enqueue.wait(reduce_output_memset_event);
 
 	auto launch_config = cuda::launch_config_builder()
-		.grid_dimensions(outputVec_d.size())
-		.block_dimensions(THREADS_PER_BLOCK)
+		.grid_size(outputVec_d.size())
+		.block_size(THREADS_PER_BLOCK)
 		.build();
 
 	stream_1.enqueue.kernel_launch(reduce, launch_config,

src/cuda/api/multi_wrapper_impls/graph.hpp

@@ -209,14 +209,21 @@ inline ::std::string describe(graph::instance::update_status_t update_status, op
 		   graph::instance::detail_::describe(update_status, node.value().handle(), node.value().containing_graph_handle());
 }
 
-inline graph::template_t stream_t::end_capture() const
+namespace stream {
+namespace capture {
+
+inline graph::template_t end(const cuda::stream_t& stream)
 {
 	graph::template_::handle_t new_graph;
-	auto status = cuStreamEndCapture(handle_, &new_graph);
-	throw_if_error_lazy(status, "Completing the capture of operations into a graph on " + stream::detail_::identify(*this));
+	auto status = cuStreamEndCapture(stream.handle(), &new_graph);
+	throw_if_error_lazy(status,
+		"Completing the capture of operations into a graph on " + stream::detail_::identify(stream));
 	return graph::template_::wrap(new_graph, do_take_ownership);
 }
 
+} // namespace capture
+} // namespace stream
+
 inline void stream_t::enqueue_t::graph_launch(const graph::instance_t& graph_instance) const
 {
 	graph::launch(graph_instance, associated_stream);

src/cuda/api/stream.hpp

@@ -214,6 +214,15 @@ namespace capture {
 
 inline state_t state(const stream_t& stream);
 
+/**
+ * @brief Have a stream capture operations enqueued from now on, for later generation
+ * of an execution graph.
+ *
+ * @note See also @ref graph::template_t
+ */
+void begin(const cuda::stream_t& stream, stream::capture::mode_t mode = cuda::stream::capture::mode_t::global);
+graph::template_t end(const cuda::stream_t& stream);
+
 } // namespace capture
 
 inline bool is_capturing(const stream_t& stream)
@@ -855,10 +864,9 @@ class stream_t {
 	 *
 	 * @note See also @ref graph::template_t
 	 */
-	void begin_capture(stream::capture::mode_t mode) const {
-		context::current::detail_::scoped_override_t set_context_for_this_scope(context_handle_);
-		auto status = cuStreamBeginCapture(handle_, static_cast<CUstreamCaptureMode>(mode));
-		throw_if_error_lazy(status, "Failed beginning to capture on " + stream::detail_::identify(*this));
+	void begin_capture(stream::capture::mode_t mode = cuda::stream::capture::mode_t::global) const
+	{
+		stream::capture::begin(*this, mode);
 	}
 
 	/**
@@ -872,7 +880,10 @@ class stream_t {
 	 * @return A CUDA execution graph template, comprising of all operations enqueued on this stream
 	 * between the last invocation of @ref begin_capture and the invocation of this one.
 	 */
-	graph::template_t end_capture() const;
+	graph::template_t end_capture() const
+	{
+		return stream::capture::end(*this);
+	}
 #endif // CUDA_VERSION >= 10000
 
 protected: // constructor
@@ -1121,7 +1132,7 @@ stream_t create(
 #if CUDA_VERSION >= 10000
 namespace capture {
 
-state_t state(const stream_t& stream)
+inline state_t state(const stream_t& stream)
 {
 	context::current::detail_::scoped_override_t set_context_for_this_scope(stream.context_handle());
 	CUstreamCaptureStatus capture_status;
@@ -1130,6 +1141,13 @@ state_t state(const stream_t& stream)
 	return static_cast<state_t>(capture_status);
 }
 
+inline void begin(const cuda::stream_t& stream, stream::capture::mode_t mode)
+{
+	context::current::detail_::scoped_override_t set_context_for_this_scope(stream.context_handle());
+	auto status = cuStreamBeginCapture(stream.handle(), static_cast<CUstreamCaptureMode>(mode));
+	throw_if_error_lazy(status, "Failed beginning to capture on " + stream::detail_::identify(stream));
+}
+
 } // namespace capture
 #endif // CUDA_VERSION >= 10000