jax-ml/jax · error · ValueError

Attempting to get contents of allocation with key `{key}` th

Error message

Attempting to get contents of allocation with key `{key}` that is not a `Buffer`.

What it means

get_buffer_content looked up a memory key whose stored object is not a Buffer (e.g. it is a Semaphore). Reads with clock/race tracking require a Buffer with logical shape and dtype.

Source

Thrown at jax/_src/pallas/mosaic/interpret/shared_memory.py:537

      thread: The thread reading the buffer.
      increment_clock: Whether to increment the given thread's vector clock
      logging_info: Information about the source of the read.

    Returns:
      - The contents of the read range of the buffer, or None if reading
        entirely out of bounds.
      - The shape and dtype of the full content array of the buffer.
      - The incremented vector clock for the given thread.
        None if race detection is not enabled or if `increment_clock` is False.
    """
    clock = None
    with self.lock:
      if self.detect_races and increment_clock and thread is not None:
        clock = self.incr_clock(thread, take_lock=False)

      buff = self.mem[key]
      if not isinstance(buff, Buffer):
        raise ValueError(
            f"Attempting to get contents of allocation with key `{key}` that is"
            " not a `Buffer`."
        )
      shape_and_dtype = ShapeAndDtype(buff.logical_shape, buff.dtype)

      try:
        result = buff[rnge].copy()
      except IndexError:
        # `buf` was accessed with `rnge` entirely out of bounds.
        result = None

      if self.enable_logging and logging_info is not None:
        self._log(
            logging_info.format(
                f"{key=}, {rnge=},"
                f" in_bounds={result is not None}.\n"
                f"logical_shape={buff.logical_shape},"
                f" content_shape={buff.shape},"

View on GitHub (pinned to 1e1c6a8fc0)

Solutions

1. Check the key was obtained from allocate_buffer, not get_semaphore/fixed-ID semaphores
2. Fix key generation so buffers and semaphores cannot collide
3. Reproduce single-threaded to rule out allocation/access races in the interpreter harness

def is_buffer_key(mgr, key):
    with mgr.lock:
        return isinstance(mgr.mem.get(key), Buffer)

try:
    val = mgr.get(key, ...)
except ValueError as e:
    if 'not a `Buffer`' in str(e):
        raise KeyError(f'{key} is not a buffer allocation') from e
    raise

When it happens

Trigger: Calling SharedMemManager.get (or ops routed through it, like wgmma or deref helpers) with a key that maps to a semaphore or other non-Buffer allocation.

Common situations: Semaphore IDs colliding with buffer memory keys; passing the wrong MemKey to a load op; races between allocation and access in multi-threaded interpret simulation.

Related errors

• Attempting to deallocate allocation with key `{key}` that is
• Attempting to store into allocation with key `{key}` that is
• Logical shape {self.logical_shape} cannot be bigger than con
• Attempting to swap into allocation with `key` {key} that is
• Vector clock size ({self.vector_clock_size}) must be greater

AI-assisted analysis of jax-ml/jax@1e1c6a8fc0 (2026-08-27). Data as JSON: /api/errors/ca2395aba6e22282. Report an issue: GitHub.