Skip to content

Async exports never free the block of indirect parameters #1757

Open

Description

@Aditya1404Sal

Summary

When the parameters of an export flatten to more than 16 core values, the caller writes them into a block of the callee's linear memory. The caller allocates this block with the callee's cabi_realloc, and the callee must free it.

For sync exports, the generated code frees the block after the call. For async exports, the generated code never frees it. Each call of such an async export leaks the block.

Where

crates/core/src/abi.rs, in LiftArgsLowerResults, emits the free only for sync exports:

if sig.indirect_params && !async_ {
    // GetArg 0, GuestDeallocate { size, align }
}

No generator frees the block in its own code for async exports.

Effect

  • Rust, C, C# and MoonBit: async exports with indirect parameters leak the block on each call. (C++ generates no async exports. I did not check Go.)
  • Example: an async export with nine string parameters leaks 72 bytes per call.
  • In Golem, each method call of a Rust agent goes through an async export with such a block. Each call leaks 136 bytes, and linear memory does not shrink.

Why a change in abi.rs alone does not fix it

  • A free before the call is too early. The C generator reads the parameters only at the call. The Rust generator reads option and result payloads only at the call. Both then read freed memory.
  • A free after the call (remove && !async_) is too late, or it is in the wrong function:
    • Rust: the free comes after .await. A call that is cancelled while it waits never reaches the free.
    • C, C# and MoonBit: the code after an async call goes into a different function: the task-return function in C and MoonBit, and the async method in C#. The block pointer is not available there. For C, clang reports use of undeclared identifier 'arg'.

So each generator must free the block at a safe point in its own code: after it reads all parameters, and before the first point where the task can wait.

Possible fix (Rust)

In the Rust generator, CallInterface can free the block between the creation of the future and the first .await:

let call = T_::method(args);
cabi_dealloc(arg0, size, align);
call.await

The creation of the future reads all arguments out of the block, so the free comes after the last read. The free also comes before the first point where the task can wait, so a cancelled call frees the block too. wit-bindgen-core does not change.

I tried this change with a runtime test. The test component counts its live heap bytes. The runner calls each async export 10 times and checks that the count does not change:

  • 9 strings, calls that finish: today's code leaks 720 bytes (10 × 72). With this change, nothing leaks.
  • An option<u32>, a result<u32, string> and 6 strings: a free before the call reads freed memory and traps. With this change, the calls finish and nothing leaks.
  • A future and 8 strings, calls that the runner cancels while they wait: a free after .await leaks 680 bytes (10 × 68). With this change, nothing leaks.

This fixes only Rust. C, C# and MoonBit need their own changes.

Reproduction

package my:test;

interface i {
  many-arguments: async func(
    a: string, b: string, c: string, d: string, e: string,
    f: string, g: string, h: string, i: string,
  );
}

world test {
  export i;
}

A test component with a counting global allocator shows 72 more live bytes after each call of many-arguments.

Activity

  1. added
    asyncRelated to async/streams in the component model.
    on Oct 27, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    asyncRelated to async/streams in the component model.

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions