review: address feedback on RuntimeCacheHandle pickle changes

- ``RuntimeCacheHandle::serialize``: switch the pending-bytes copy from
  ``std::memcpy`` to ``std::copy`` (with free-function ``std::cbegin``
  / ``std::cend``), and use free-function ``std::empty`` for the
  empty-vector check. Idiomatic C++17 in a hot path that didn't need
  the C-string-style API.
- Drop the explanatory comment block above the pending-bytes branch.
- Trim the wrapper ``__getstate__`` docstring: the rationale that named
  specific picklability hazards (``weakref``, ``threading.Lock``) is
  implementation noise that doesn't belong in the wrapper's contract.
- Drop the cpp-rt skip on
  ``test_python_handle_pickle_preserves_pending_warm_bytes``. The test
  instantiates ``_RuntimeCacheHandle`` directly rather than going
  through ``RuntimeCache._handle`` selection, so the python class is
  exercisable regardless of which runtime is active. Updated docstring
  notes the directness.

Behavior is unchanged. Addresses review comments on
core/runtime/RuntimeSettings.cpp:131, :136 and
tests/py/dynamo/runtime/test_000_runtime_cache.py:341.

Author: tp5uiuc

core/runtime/RuntimeSettings.cpp

@@ -1,5 +1,6 @@
 #include "core/runtime/RuntimeSettings.h"
 
+#include <algorithm>
 #include <array>
 #include <cstring>
 #include <iterator>
@@ -124,16 +125,12 @@ at::Tensor RuntimeCacheHandle::serialize() const {
 #ifdef TRT_MAJOR_RTX
   std::lock_guard<std::mutex> lock(state_mu_);
   if (!trt_handle_) {
-    // Pre-materialize: forward any ``pending_warm_bytes_`` so that the
-    // handle's persistable state survives ``save_to_stream`` and pickle
-    // even before any engine has triggered ``ensure_materialized``.
-    // ``save_to_stream`` / ``def_pickle`` round-trip then matches the
-    // python facade's behavior (it reads ``_pending_warm_bytes`` directly).
-    if (pending_warm_bytes_.empty()) {
+    if (std::empty(pending_warm_bytes_)) {
       return empty();
     }
     auto tensor = at::empty({static_cast<int64_t>(pending_warm_bytes_.size())}, opts);
-    std::memcpy(tensor.data_ptr(), pending_warm_bytes_.data(), pending_warm_bytes_.size());
+    std::copy(
+        std::cbegin(pending_warm_bytes_), std::cend(pending_warm_bytes_), static_cast<uint8_t*>(tensor.data_ptr()));
     return tensor;
   }
   auto host_mem = make_trt(trt_handle_->serialize());

py/torch_tensorrt/dynamo/runtime/_TorchTensorRTModule.py

@@ -541,10 +541,7 @@ def __getstate__(self) -> dict[str, Any]:
         cpp-side exclusion (engine bytes never carry these fields).
 
         ``_implicit_cache_handle`` is dropped alongside ``_runtime_settings``
-        because it aliases the same ``RuntimeCache`` instance and would
-        otherwise drag a ``weakref`` (via the handle's ``atexit`` closure)
-        and a Python-only ``threading.Lock`` (when the python-runtime path
-        is active) into pickle -- neither is picklable.
+        because it aliases the same ``RuntimeCache`` instance.
         """
         get_state = getattr(super(), "__getstate__", None)
         state = (get_state() if get_state else self.__dict__).copy()

tests/py/dynamo/runtime/test_000_runtime_cache.py

@@ -334,15 +334,15 @@ def test_user_built_handle_no_autosave_by_default(self):
                 "User-built handle with autosave_on_del=False should not save on GC",
             )
 
-    @unittest.skipIf(
-        ENABLED_FEATURES.torch_tensorrt_runtime,
-        "exercises the python ``_RuntimeCacheHandle`` directly; cpp-rt "
-        "path is covered by ``register_jit_hooks.cpp`` ``def_pickle``",
-    )
     def test_python_handle_pickle_preserves_pending_warm_bytes(self):
         """A python ``_RuntimeCacheHandle`` that has bytes loaded but
         hasn't materialized them yet must round-trip those bytes through
         pickle. Matches the cpp ``def_pickle`` contract (path + bytes).
+
+        The test instantiates ``_RuntimeCacheHandle`` directly rather than
+        going through ``RuntimeCache`` (which would pick the torchbind
+        backing on cpp rt), so the python class is exercisable regardless
+        of which runtime is active.
         """
         import pickle