JIT: Write up general runtime async inlining details by jakobbotsch · Pull Request #127800 · dotnet/runtime

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

jakobbotsch · 2026-05-05T15:10:13Z

I expect to work on general inlining for runtime async over the next few weeks. This document writes down my thoughts around what needs to happen in the inlined code.

Mostly this is low level details for my own sake, but still cc @agocke @AndyAyersMS @VSadov @stephentoub.

Contributes to #127865

Copilot

Pull request overview

Adds a new JIT design document that captures the proposed semantics for general runtime-async inlining. The doc is meant to guide future implementation work by spelling out how suspension, resumption, context flow, and exception handling would need to behave when async callees are inlined.

Changes:

Introduces a new design note for preserving ExecutionContext and continuation-context behavior across inlined runtime-async calls.
Describes a proposed resumed_* model and post-inline IR needed to reconstruct logical async returns.
Adds worked examples covering synchronization-context and AsyncLocal behavior.

github-actions · 2026-07-19T05:45:05Z

Workflow state for the Holistic Review Orchestrator.

{
"version": 5,
"last_dispatched_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_dispatched_base_ref": "main",
"last_dispatched_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_reviewed_commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"last_reviewed_base_ref": "main",
"last_reviewed_base_sha": "004c358f4376950ead5ef31b95bf4f91a725b42a",
"last_recorded_worker_run_id": "29675329919",
"review_attempt_commit": "",
"review_attempt_base_ref": "",
"review_attempt_count": 0,
"max_review_attempts": 5,
"review_history_format": "holistic-review-disclosure-v1",
"review_history": [
{
"commit": "e64be6c86e4555a9b9df369f212414e61af1a2a1",
"review_id": 4730522467
}
]
}

github-actions

Holistic Review

Motivation: The author (jakobbotsch) is about to implement general inlining of runtime async calls in the JIT and wants to write down the design challenges and intended approach. This is a documentation-only PR adding docs/design/coreclr/jit/runtime-async-inlining.md; it contributes to #127865 and serves as a design record for reviewers (cc'd) and the author.

Approach: A single 342-line Markdown design doc. It establishes background (await/call-site vs. callee behaviors, the context save/restore contract, and the relevant AsyncHelpers/getAsyncInfo helpers), then works through the hard cases of inlining: suspending inside an inlinee, resuming inside an inlinee, synchronous context save/restore, computing per-frame resumed_F flags, representing post-inline IR (introducing a GT_CONTINUATION_FIELD_OFFSET node whose offset is filled in during the async transformation), exception handling in the post-inline IR, and initial scope restrictions (only inline callees that provably never suspend; skip suspend-capable calls in try clauses). Two worked examples illustrate SynchronizationContext switching and AsyncLocal/ExecutionContext restoration.

Summary: As a design document this is clear, internally consistent, and appropriately scoped. It correctly captures the subtle invariants (e.g. resumed_C implies resumed_B implies resumed_A, single-continuation reuse enabling the else branches to keep prior captures, and the reliance on constant propagation to eliminate cruft for non-suspending inlinees). There is no code or test impact, so there is nothing to build or run. I found only two minor, non-blocking documentation issues, filed inline: (1) the trailing prose in the final example is trapped inside a csharp code fence and will render as code rather than text, and (2) a small typo ("progesses"). Neither affects the technical content. LGTM as a design note.

Detailed Findings

Both findings are inline and minor/non-blocking:

Unclosed/mis-scoped code fence around the final example's explanatory text (docs/design/coreclr/jit/runtime-async-inlining.md, lines 317-342) causes narrative prose to render as C#.
Typo "progesses" -> "progresses" (line 150).

Additional non-actionable observation (not filed inline): line 240 has a minor grammatical slip ("the async infrastructures catches"), which the author may wish to tidy but does not affect meaning.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 53.6 AIC · ⌖ 10.5 AIC · ⊞ 10K

jakobbotsch · 2026-07-27T11:40:35Z

@davidwrighton I know you gave this some thought yourself. Do you have any feedback or thoughts on the design here?

@dotnet/jit-contrib I would similarly appreciate any feedback or thoughts.

Would like to get this merged. Alternatively I can also wait and merge it together with the actual implementation.

Copilot

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated 5 comments.

+Rather, the existing `B` continuation would be linked to the newly created `C` continuation by async infrastructure.
+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:


+### Exceptions
+
+Inlined functions can finish by throwing exceptions too.
+Under normal circumstances the async infrastructures catches the exception and looks for the next continuation that may handle the exception.


+It would maintain its values from the time we suspended in `C` with `!resumed_C`.
+
+The take away is that the suspension for the inlined `Task.Yield()` needs to roughly accomplish the following, in addition to storing its normal state:
+```csharp


+
+Correct handling requires catching the possible exception and then rethrowing it in the post-inline IR.
+The expansion for calls in try clauses would look roughly like:
+```csharp


+
+- `Foo()` runs in the ambient synchronization context but switches its own synchronization context before awaiting `Bar()`. Its continuation captures `_syncContext1` as the continuation context.
+- `Bar()` also switches its own synchronization context before awaiting `Baz()`. Its continuation captures `_syncContext2` as the continuation context.
+- `Baz()` always suspends, switching onto a thread pool thread. No continuation context is captured for custom awaitables.


jakobbotsch · 2026-07-30T16:56:07Z

Let's do this as part of #131538

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

JIT: Write up general runtime async inlining details
595b8d0

CopilotAI review requested due to automatic review settings May 5, 2026 15:10

Copilotstarted reviewing on behalf of jakobbotsch May 5, 2026 15:10 View session

github-actionsBot added the area-CodeGen-coreclr CLR JIT compiler in src/coreclr/src/jit and related components such as SuperPMI label May 5, 2026

CopilotAI reviewed May 5, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Feedback
e64be6c

github-actionsBot reviewed Jul 19, 2026
View reviewed changes

Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md
Comment threaddocs/design/coreclr/jit/runtime-async-inlining.md Outdated

Address feedback
245b2a9

CopilotAI review requested due to automatic review settings July 27, 2026 11:38

Copilotstarted reviewing on behalf of jakobbotsch July 27, 2026 11:39 View session

CopilotAI reviewed Jul 27, 2026
View reviewed changes

jakobbotsch added this to the 11.0.0 milestone Jul 30, 2026

JulieLeeMSFT added the Priority:1 Work that is critical for the release, but we could probably ship without label Jul 30, 2026

jakobbotsch closed this Jul 30, 2026

Uh oh!

Conversation

jakobbotsch commented May 5, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

github-actionsBot commented Jul 19, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actionsBot left a comment

Choose a reason for hiding this comment

Holistic Review

Detailed Findings

Uh oh!

Uh oh!

Uh oh!

jakobbotsch commented Jul 27, 2026

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

jakobbotsch commented Jul 30, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

jakobbotsch commented May 5, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

github-actionsBot commented Jul 19, 2026• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actionsBot left a comment

Choose a reason for hiding this comment

Holistic Review

Detailed Findings

Uh oh!

Uh oh!

Uh oh!

jakobbotsch commented Jul 27, 2026

Uh oh!

CopilotAI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

jakobbotsch commented Jul 30, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

jakobbotsch commented May 5, 2026•
edited
Loading

github-actionsBot commented Jul 19, 2026•
edited
Loading

jakobbotsch commented May 5, 2026•
edited
Loading

github-actionsBot commented Jul 19, 2026•
edited
Loading

jakobbotsch commented May 5, 2026•
edited
Loading

github-actionsBot commented Jul 19, 2026•
edited
Loading

jakobbotsch commented May 5, 2026•
edited
Loading

github-actionsBot commented Jul 19, 2026•
edited
Loading