@@ -47,10 +47,12 @@ runtime or input storage and later execution may overwrite that storage.
 A CUDA output that fills memory the bindings allocated for it is returned
 without a copy when `clone_outputs=True`. The result keeps that memory, so a
 method writes its next execution into a second buffer, and the two take turns;
-a module allocates new memory each call. Reading the outputs again before the
-next execution returns the same object, so an in-place change to one read
-shows in the other. In torch output mode such a result is a view of memory
-torch does not own, so it cannot grow with `resize_()`.
+a module allocates new memory each call. Within one execution, reading the
+outputs again with `clone_outputs=True` returns the same object, so an in-place
+change to one read shows in the other; a `clone_outputs=False` read is a
+separate borrowed view. In torch output mode such a result is a view of memory
+torch does not own, so it cannot grow with `resize_()` and cannot be shared
+through `torch.multiprocessing`. Call `.clone()` for a normal torch tensor.
 
 `dtype_name` names a result's dtype, including dtypes NumPy lacks, such as
 `"bfloat16"`.
@@ -103,11 +105,13 @@ CUDA DLPack inputs and `ExecuTorchResult` outputs require CUDA-enabled bindings.
 Torch CUDA inputs and outputs synchronize through Python Torch, including in
 CPU builds of the bindings. Execution is synchronous at the Python boundary:
 a call returns after its device work has finished, so its outputs are ready on
-any stream. Each call waits for the device once, rather than once per tensor.
-Before running, it also waits once if an input may still be written on another
-library's stream: a torch CUDA tensor, a DLPack input from another library, or
-an `ExecuTorchResult` whose memory was handed out through `__dlpack__`. The
-synchronization has no C++ ATen dependency.
+any stream. Each call waits for the device once after it runs, rather than once
+per output. Before running, it waits once per device for any CUDA input that
+another library may still be writing: a torch CUDA tensor, a CUDA DLPack input,
+or a result of these bindings passed back in, since that result can share memory
+a caller handed to another library. Reading a CUDA result through `__dlpack__`
+or `to_host()` waits once as well. The synchronization has no C++ ATen
+dependency.
 
 For bfloat16 inputs, raw byte buffers use the shape declared by the exported
 method. Bfloat16 results expose flat bytes through the buffer protocol because
 
@@ -313,11 +313,7 @@ class BufferTensor final {
         info_(buffer_.request()) {
     check_rank();
     const auto input_meta = method_meta.input_tensor_meta(input_index);
-    THROW_IF_ERROR(
-        input_meta.error(),
-        "Input %zu of method '%s' is not a tensor input",
-        input_index,
-        method_meta.name());
+    THROW_IF_ERROR(input_meta.error(), "is not a tensor input");
     const bool raw_bfloat16 =
         input_meta->scalar_type() == executorch::aten::ScalarType::BFloat16 &&
         info_.ndim == 1 &&
@@ -329,8 +325,8 @@ class BufferTensor final {
       }
       if (static_cast<size_t>(info_.size) != input_meta->nbytes()) {
         throw py::value_error(
-            "Raw bfloat16 input " + std::to_string(input_index) + " has " +
-            std::to_string(info_.size) + " bytes, but the method expects " +
+            "raw bfloat16 input has " + std::to_string(info_.size) +
+            " bytes, but the method expects " +
             std::to_string(input_meta->nbytes()));
       }
       scalar_type_ = executorch::aten::ScalarType::BFloat16;
@@ -658,24 +654,29 @@ bool is_torch_tensor(const py::handle& value) {
   return result == 1;
 }
 
-// Runs `read`, which builds one input from a Python object, and starts the
-// message of any error it raises with the input and its method, which the
-// readers cannot see. The error keeps its Python type.
+// Runs `read`, which builds one input from a Python object, and names the
+// input and its method in any error it raises, which the readers cannot see.
 template <typename Read>
 auto read_input(const MethodMeta& method_meta, size_t index, Read&& read) {
-  const auto named = [&](const char* message) {
-    return "Input " + std::to_string(index) + " of method '" +
-        method_meta.name() + "': " + message;
+  const std::string prefix = "Input " + std::to_string(index) + " of method '" +
+      method_meta.name() + "'";
+  const auto named = [&prefix](const char* message) {
+    return prefix + ": " + message;
   };
   try {
     return read();
   } catch (py::error_already_set& error) {
-    // Chained to the original, so its traceback stays available.
-    const auto type = error.type();
-    const auto message =
-        named(py::str(error.value()).cast<std::string>().c_str());
-    py::raise_from(error, type.ptr(), message.c_str());
-    throw py::error_already_set();
+    // Keep the exact exception and its attributes, adding the input name as a
+    // note (Python 3.11+). Rebuilding it as type(message) would fail for any
+    // exception whose constructor is not a single string.
+    if (error.value()) {
+      try {
+        error.value().attr("add_note")(prefix);
+      } catch (...) {
+        // add_note is best effort; never hide the original error.
+      }
+    }
+    throw;
   } catch (const py::buffer_error& error) {
     throw py::buffer_error(named(error.what()));
   } catch (const py::value_error& error) {
@@ -684,9 +685,9 @@ auto read_input(const MethodMeta& method_meta, size_t index, Read&& read) {
     throw py::type_error(named(error.what()));
   } catch (const std::invalid_argument& error) {
     throw py::value_error(named(error.what()));
-  } catch (const std::exception& error) {
-    throw std::runtime_error(named(error.what()));
   }
+  // Any other C++ exception passes through so pybind11 maps it to the right
+  // Python type (std::bad_alloc to MemoryError, and so on).
 }
 
 void validate_tensor_input(
@@ -872,7 +873,8 @@ class TorchTensorView final {
                                : "cuda:" + std::to_string(device.index());
       };
       throw py::value_error(
-          "Input " + std::to_string(index) + " is on device " + name(device_) +
+          "Input " + std::to_string(index) + " of method '" +
+          method.method_meta().name() + "' is on device " + name(device_) +
           ", but the method expects " + name(expected));
     }
   }
@@ -995,16 +997,11 @@ class DLPackTensorView final {
         advertised_device_(
             owner_.attr("__dlpack_device__")().cast<std::pair<int, int>>()) {
     validate_advertised_device();
-    // A result of these bindings is written either by an execution, which
-    // finished before it returned, or by a copy on the legacy default stream,
-    // which the delegates' streams wait for. So it needs no wait unless it
-    // was handed to another library. Anything else may still be written on
-    // its producer's streams until the call waits for it.
+    // A result of these bindings exposes its memory directly, since the call
+    // that made it already waited for the device. Any other producer may
+    // still be writing on its own stream, so the call waits before it runs.
     if (py::isinstance<PyExecuTorchResult>(owner_)) {
-      own_result_ = owner_.cast<std::shared_ptr<PyExecuTorchResult>>();
-    }
-    if (own_result_) {
-      capsule_ = own_result_->capsule();
+      capsule_ = owner_.cast<std::shared_ptr<PyExecuTorchResult>>()->capsule();
     } else {
       capsule_ = advertised_device_.first == dlpack::CUDA
           ? cuda_dlpack_capsule(owner_, advertised_device_.second)
@@ -1061,14 +1058,6 @@ class DLPackTensorView final {
     return nbytes_;
   }
 
-  // Whether the producer may still be writing the tensor on its own streams.
-  // Asked when the call runs, since a result set as an input can be handed to
-  // another library before that.
-  bool may_have_pending_writes() const {
-    return advertised_device_.first == dlpack::CUDA &&
-        !(own_result_ && !own_result_->handed_out());
-  }
-
   // Describes the tensor in the exported dimension order. A CPU tensor dense
   // in another order is copied into that order, since reading it with the
   // exported strides would permute its values. A device tensor would need a
@@ -1103,8 +1092,9 @@ class DLPackTensorView final {
     if (nbytes_ != 0 &&
         device_ != method.get_input(index).toTensor().device()) {
       throw py::value_error(
-          "DLPack input " + std::to_string(index) +
-          " device does not match the method input device");
+          "Input " + std::to_string(index) + " of method '" +
+          method.method_meta().name() +
+          "': DLPack input device does not match the method input device");
     }
   }
 
@@ -1298,7 +1288,6 @@ class DLPackTensorView final {
 
   py::object owner_;
   std::pair<int, int> advertised_device_;
-  std::shared_ptr<PyExecuTorchResult> own_result_;
   size_t nbytes_ = 0;
   py::object capsule_;
   dlpack::ManagedTensor* managed_ = nullptr;
@@ -1496,6 +1485,13 @@ bool prefer_dlpack_input(const py::handle& value) {
   if (!PyObject_CheckBuffer(value.ptr())) {
     return true;
   }
+  // A result of these bindings always takes the DLPack path, so its real
+  // dtype and strides come through. Its buffer export is flat bytes, which the
+  // buffer path would read with the method's layout and scramble a result in
+  // another dim order, bfloat16 included.
+  if (py::isinstance<PyExecuTorchResult>(value)) {
+    return true;
+  }
   // NumPy and other host buffers keep the buffer path, including its
   // read-only copy behavior. CUDA results expose only their DLPack storage.
   if (py::hasattr(value, "__dlpack_device__")) {
@@ -1566,9 +1562,10 @@ void synchronize_device_outputs(const Method& method) {
 }
 
 // Device inputs from another library may still be written on that library's
-// streams, torch tensors included. One wait per call covers every such input,
-// instead of one per input. An ExecuTorchResult these bindings returned needs
-// no wait unless its memory was handed to another library since.
+// streams, torch tensors and DLPack producers alike. One wait per device
+// covers every such input. A result these bindings returned is included too:
+// it can share memory a caller gave to another library, and a borrowed result
+// cannot tell, so the call waits for its device rather than trusting a flag.
 void synchronize_device_inputs(
     const std::vector<std::shared_ptr<DLPackTensorView>>& dlpack_inputs,
     const std::vector<std::shared_ptr<TorchTensorView>>& torch_inputs) {
@@ -1581,7 +1578,8 @@ void synchronize_device_inputs(
     }
   };
   for (const auto& input : dlpack_inputs) {
-    if (input->nbytes() != 0 && input->may_have_pending_writes()) {
+    if (input->nbytes() != 0 &&
+        input->device().type() == executorch::aten::DeviceType::CUDA) {
       add(input->device());
     }
   }
@@ -2558,7 +2556,8 @@ struct PyModule final {
 #endif
       } else {
         throw std::runtime_error(
-            "Unsupported python type " + type_str +
+            "Input " + std::to_string(i) + " of method '" + method_meta.name() +
+            "': unsupported python type " + type_str +
             ". Ensure that inputs are passed as a flat list of tensors.");
       }
     }
@@ -3388,7 +3387,9 @@ struct PyMethod final {
 #endif
       } else {
         throw std::runtime_error(
-            "Unsupported python type " + type_str +
+            "Input " + std::to_string(i) + " of method '" +
+            storage_->method->method_meta().name() +
+            "': unsupported python type " + type_str +
             ". Ensure that inputs are passed as a flat list of tensors.");
       }
     }
@@ -3598,21 +3599,13 @@ struct PyMethod final {
   std::vector<py::object> handed_outputs_;
   // Per device output buffer, alive while such a result still uses it.
   std::vector<std::weak_ptr<void>> handed_buffers_;
-  // Per device output buffer, whether a result was handed it since the last
-  // execution.
-  std::vector<bool> handed_slots_;
   // Per device output, the buffer a still-alive earlier result uses, kept so
   // it can be reused once that result is dropped.
   struct SpareDeviceOutput final {
     std::shared_ptr<DeviceMemoryBuffer> buffer;
     std::weak_ptr<void> handed;
-    std::shared_ptr<bool> handed_out;
   };
   std::vector<SpareDeviceOutput> spare_device_outputs_;
-  // Per device output buffer, whether another library may have read it, so
-  // reusing it must wait for that library's queued work. Torch outputs always
-  // may; an ExecuTorchResult only once exported through DLPack.
-  std::vector<std::shared_ptr<bool>> handed_out_;
 #ifndef USE_ATEN_LIB
 
   struct BorrowedOutputOwner final {
@@ -3690,10 +3683,7 @@ struct PyMethod final {
         std::make_shared<std::shared_ptr<DeviceMemoryBuffer>>(buffer);
     const std::shared_ptr<void> memory(holder, buffer->data());
     py::object result;
-    const auto torch_output =
-        portable_tensor_output() == PortableTensorOutput::Torch;
-    handed_out_[*slot] = std::make_shared<bool>(torch_output);
-    if (torch_output) {
+    if (portable_tensor_output() == PortableTensorOutput::Torch) {
       auto* retained = new std::shared_ptr<void>(memory);
       result = portable_tensor_result(
           tensor,
@@ -3702,11 +3692,9 @@ struct PyMethod final {
             delete static_cast<std::shared_ptr<void>*>(pointer);
           }));
     } else {
-      result = py::cast(
-          PyExecuTorchResult::hand_over(tensor, memory, handed_out_[*slot]));
+      result = py::cast(PyExecuTorchResult::hand_over(tensor, memory));
     }
     handed_buffers_[*slot] = holder;
-    handed_slots_[*slot] = true;
     handed_outputs_.resize(storage_->method->outputs_size());
     handed_outputs_[index] = result;
     return result;
@@ -3853,59 +3841,38 @@ struct PyMethod final {
     storage_->output_storages = std::move(output_storages);
     storage_->device_output_storages = std::move(device_output_storages);
     handed_buffers_.assign(num_outputs, std::weak_ptr<void>());
-    handed_slots_.assign(num_outputs, false);
     spare_device_outputs_.assign(num_outputs, SpareDeviceOutput());
-    handed_out_.assign(num_outputs, nullptr);
   }
 
-  // A handed-over result still uses its buffer, so the method writes into
-  // its spare instead, and the two take turns. Borrowed results keep their
-  // buffer alive themselves, as they always could see the next execution's
-  // values.
+  // A handed-over result still uses its buffer, so the method writes into its
+  // spare instead, and the two take turns. Borrowed results keep their buffer
+  // alive themselves, as they always could see the next execution's values.
   void replace_held_device_outputs() {
 #ifndef USE_ATEN_LIB
     for (size_t i = 0; i < storage_->device_output_storages.size(); ++i) {
       auto& buffer = storage_->device_output_storages[i];
-      if (!buffer || !handed_slots_[i]) {
+      if (!buffer || handed_buffers_[i].expired()) {
         continue;
       }
+      // The buffer this slot points at is still held by a live result, so the
+      // next run must not write into it. Take the spare if a dropped result
+      // freed it, otherwise allocate a fresh one. Allocate into a local first,
+      // so a failed allocation leaves the slot and the spare untouched.
       const auto device = storage_->method->get_output(i).toTensor().device();
-      if (!handed_buffers_[i].expired()) {
-        // In a loop such as `out = method(x)[0]` the previous result is still
-        // alive here, so its buffer and this one take turns instead of a new
-        // allocation each call.
-        auto& spare = spare_device_outputs_[i];
-        if (spare.buffer && spare.handed.expired()) {
-          std::swap(buffer, spare.buffer);
-          std::swap(handed_buffers_[i], spare.handed);
-          std::swap(handed_out_[i], spare.handed_out);
-          wait_for_other_readers(i, device);
-        } else {
-          spare = {buffer, handed_buffers_[i], handed_out_[i]};
-          buffer = allocate_device_output(i, buffer->size(), device);
-        }
+      auto& spare = spare_device_outputs_[i];
+      if (spare.buffer && spare.handed.expired()) {
+        std::swap(buffer, spare.buffer);
+        std::swap(handed_buffers_[i], spare.handed);
       } else {
-        wait_for_other_readers(i, device);
+        auto fresh = allocate_device_output(i, buffer->size(), device);
+        spare = {std::move(buffer), handed_buffers_[i]};
+        buffer = std::move(fresh);
+        handed_buffers_[i].reset();
       }
-      handed_buffers_[i].reset();
-      handed_out_[i].reset();
-      handed_slots_[i] = false;
     }
 #endif
   }
 
-#ifndef USE_ATEN_LIB
-  // A dropped result's memory may still be read by work another library
-  // queued on its own streams. Freeing it would have waited for that work, so
-  // reusing it waits too. Work these bindings queued has already finished,
-  // since every execution waits for its device before it returns.
-  void wait_for_other_readers(size_t index, executorch::aten::Device device) {
-    if (handed_out_[index] && *handed_out_[index]) {
-      synchronize_device(device.index());
-    }
-  }
-#endif
-
   py::list get_outputs_as_py_list(
       const std::vector<EValue>& outputs,
       bool clone_outputs = true) {
@@ -3933,7 +3900,11 @@ struct PyMethod final {
           list[i] = py::cast(v.toTensor());
         }
 #else
-        if (i < handed_outputs_.size() && handed_outputs_[i]) {
+        // Within one execution, repeated default reads return the same handed
+        // over object, so a caller sees stable identity and the buffer is not
+        // handed over twice. A clone_outputs=False read is a separate borrowed
+        // view and never returns that cached object.
+        if (clone_outputs && i < handed_outputs_.size() && handed_outputs_[i]) {
           list[i] = handed_outputs_[i];
           continue;
         }