Update parallel.async<_stream> syntax.

Author: jayy-wu

documentation/general-async.md

@@ -1,3 +1,70 @@
 ### Synchronization and Asynchronous `parallel-by`
-Similar to `inthreads`, `parallel-by` can also be made asynchronous.
 
+Similar to `inthreads`, `parallel-by` can also be made asynchronous by appending `.async`:
+
+```choreo
+parallel.async p by 6 : block {
+  // asynchronous kernel launch (no host-side synchronization)
+}
+```
+
+Without `.async`, the host waits for the kernel to finish before continuing:
+
+```choreo
+parallel p by 6 : block {
+  // synchronous kernel launch (host blocks until completion)
+}
+// host continues only after the kernel finishes
+```
+
+With `.async`, the host code continues immediately after launching the kernel.
+This is essential for overlapping computation with data transfers or launching
+independent kernels concurrently.
+
+### Stream Binding
+
+CUDA streams allow multiple kernels and memory transfers to execute concurrently
+on the GPU. In Choreo, you can bind a `parallel-by` block to a specific stream
+using angle-bracket syntax:
+
+```choreo
+__co__ void foo(stream s0, stream s1, f32[M] a, f32[N] b) {
+  parallel.async<s0> p by M : block {
+    a.at(p) = 1.0f;
+  }
+  parallel.async<s1> q by N : block {
+    b.at(q) = 2.0f;
+  }
+}
+```
+
+In this example:
+
+- **`stream s0, stream s1`**: Stream parameters passed from the host.
+- **`parallel.async<s0>`**: Launches the kernel asynchronously on stream `s0`.
+- **`parallel.async<s1>`**: Launches a second kernel on stream `s1`.
+
+Since both kernels are launched on different streams with `.async`, they can
+execute concurrently on the GPU.
+
+### Stream Binding without `.async`
+
+Stream binding also works with synchronous `parallel-by`. In this case, the host
+launches the kernel on the specified stream and then waits for that stream to
+complete:
+
+```choreo
+__co__ void bar(stream _s, f32[M] a) {
+  parallel<_s> p by M : block {
+    a.at(p) = 1.0f;
+  }
+  // host synchronizes on stream _s before continuing
+}
+```
+
+### Rules
+
+- Stream binding is only allowed on **block-level** parallel (`: block`).
+- The identifier inside `<...>` must be a `stream`-typed variable.
+- Without stream binding, synchronous `parallel-by` uses device-wide
+  synchronization, and asynchronous `parallel-by` uses the default stream.

documentation/parallel-in-choreo.md

@@ -117,6 +117,21 @@ For example, for *CUDA/Cute* targets, a *spanned* buffer must be annotated with
 
 Additionally, *shared* and *local* memory types have a lifetime limited to the duration of the kernel launch. Therefore, referencing them outside the *parallel execution block* is not possible. This constraint ensures proper lifetime management of these memory types.
 
+### Asynchronous Kernel Launch and Stream Binding
+
+By default, the host waits for a `parallel-by` kernel to complete before continuing. To launch kernels asynchronously, use `parallel.async`. To bind a kernel to a specific CUDA stream, use angle-bracket syntax:
+
+```choreo
+__co__ void foo(stream s, f32[M] a) {
+  parallel.async<s> p by M : block {
+    a.at(p) = 1.0f;
+  }
+  // host continues immediately (no synchronization)
+}
+```
+
+This is covered in detail in the [Asynchronous parallel-by](general-async.md) section.
+
 ### Quick Summary
 
 In this section, we explored Choreo's approach to parallelism in heterogeneous computing environments, focusing on the `parallel-by` block syntax and the management of multiple and sub-level parallelism. We also discussed how Choreo abstracts kernel launches and imposes memory management constraints, enabling us to leverage parallel hardware effectively.

tutorial/ch05-branch-control.md

@@ -254,18 +254,10 @@ parallel.async {px, py} by [grid_m, grid_n] : block {
   // kernel body
 }
 ```
-<!-- 
-```choreo
-parallel.async {px, py} by [grid_m, grid_n] : block {
-  stream s;
-  // kernel body
-}
-```
--->
 
 **`parallel.async`** returns control to the host immediately — the kernel is enqueued but the host does not wait for completion. This is the Croqtile equivalent of `cudaLaunchKernel` with a non-default stream.
 
-<!-- **`stream s`** pins the kernel to CUDA stream `s`. Multiple `parallel.async` blocks with different streams can overlap on the GPU if there are enough SMs. -->
+**`parallel.async<s>`** pins the kernel to CUDA stream `s`. Multiple `parallel.async` blocks with different streams can overlap on the GPU if there are enough SMs.
 
 This is **host orchestration**, orthogonal to in-kernel control flow. It does not replace `inthreads.async` for thread partitioning or `if` for runtime predicates — it decides *when* and *where* a grid runs relative to other grids.
 
@@ -299,7 +291,7 @@ parallel p by BLK_CNT: block {
 | `int total_tiles = expr`         | Local integer variable                                               |
 | `parallel.async ... : block`     | Non-blocking kernel launch                                           |
 | `yield`                          | Early return from `parallel` block                                   |
-<!-- | `stream s`                       | Bind kernel to CUDA stream `s`                                       | -->
+| `stream s`                       | Bind kernel to CUDA stream `s`                                       |
 
 ## Chapter summary