From a86dadae0e00b9b3cb41afc31142407e35b9bad8 Mon Sep 17 00:00:00 2001
From: yanghaoran29 <yanghaoran29@huawei.com>
Date: Mon, 17 Aug 2026 01:53:16 -0700
Subject: [PATCH 1/2] Perf: reuse private per-slot staging for HBG bind.args

Keep DeviceRunner retained_temp empty so HBG depth-two ST stays green.
Avoid per-round device_malloc/device_free and skip H2D when the host
layout fingerprint matches a prior populate.
---
 .../host_build_graph/host/runtime_maker.cpp   | 358 +++++++++++++++---
 .../host_build_graph/runtime/runtime.h        |   6 +
 src/common/platform/include/common/host_api.h |   5 +
 3 files changed, 306 insertions(+), 63 deletions(-)

diff --git a/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp b/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp
index 572d3828a1..8d9e7af304 100644
--- a/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp
+++ b/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp
@@ -45,10 +45,12 @@
 #include <cstring>
 #include <limits>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 #include "../common/pto_runtime_status.h"
@@ -67,6 +69,7 @@
 #include "../../../../common/worker/pto_runtime_c_api.h"
 #include "callable.h"
 #include "common/platform_config.h"
+#include "common/strace.h"
 #include "common/unified_log.h"
 #include "utils/device_arena.h"
 #include "prepare_callable_common.h"
@@ -299,6 +302,161 @@ static int32_t pto2_read_runtime_status(Runtime *runtime, const HostApi *api, PT
     return runtime_status_from_error_codes(orch_error_code, sched_error_code);
 }
 
+// Per-run bump over a private per-(DeviceRunner, pipeline_slot) staging buffer.
+// Intentionally does NOT use DeviceRunner retained_temp (HBG ST asserts that
+// slot stays empty). Avoids device_malloc/device_free of multi-GiB arg staging
+// every round; when the host layout fingerprint matches a prior populate,
+// IN/INOUT H2D is skipped.
+class RetainedTempBump {
+public:
+    static constexpr size_t kAlignment = 1024;
+
+    static size_t align_up(size_t v) { return (v + (kAlignment - 1)) & ~(kAlignment - 1); }
+
+    bool begin(const HostApi *api, const ChipStorageTaskArgs *orch_args) {
+        api_ = api;
+        offset_ = 0;
+        grew_ = false;
+        size_t required = 0;
+        for (int i = 0; i < orch_args->tensor_count(); i++) {
+            ChipTensor t = orch_args->tensor(i);
+            if (t.is_device_memory() || t.nbytes() == 0) {
+                continue;
+            }
+            required += align_up(static_cast<size_t>(t.nbytes()));
+        }
+
+        void *old_to_forget = nullptr;
+        {
+            std::lock_guard<std::mutex> lock(pool_mu());
+            SlotBuf &slot = slot_pool()[slot_key(api)];
+            if (required > slot.bytes) {
+                if (slot.ptr != nullptr) {
+                    api->device_free(slot.ptr);
+                    old_to_forget = slot.ptr;
+                    slot.ptr = nullptr;
+                    slot.bytes = 0;
+                }
+                void *addr = required != 0 ? api->device_malloc(required) : nullptr;
+                if (required != 0 && addr == nullptr) {
+                    base_ = nullptr;
+                    capacity_ = 0;
+                    LOG_ERROR("HBG arg staging buffer grow failed: required bytes %zu", required);
+                    // Fall through to forget old meta after unlock.
+                } else {
+                    slot.ptr = addr;
+                    slot.bytes = required;
+                    grew_ = true;
+                }
+            }
+            base_ = slot.ptr;
+            capacity_ = slot.bytes;
+        }
+        if (old_to_forget != nullptr) {
+            forget_staging_meta(old_to_forget);
+        }
+        if (required != 0 && base_ == nullptr) {
+            return false;
+        }
+        return true;
+    }
+
+    bool grew() const { return grew_; }
+    void *base() const { return base_; }
+
+    void *acquire(size_t bytes) {
+        size_t aligned = align_up(offset_);
+        if (base_ == nullptr || aligned + bytes > capacity_) {
+            LOG_ERROR("Retained temp buffer slice miss: bytes=%zu offset=%zu capacity=%zu", bytes, aligned, capacity_);
+            return nullptr;
+        }
+        void *ptr = static_cast<char *>(base_) + aligned;
+        offset_ = aligned + bytes;
+        return ptr;
+    }
+
+    using Layout = std::vector<std::pair<uintptr_t, size_t>>;
+
+    static Layout build_layout(const ChipStorageTaskArgs *orch_args) {
+        Layout layout;
+        layout.reserve(static_cast<size_t>(orch_args->tensor_count()));
+        for (int i = 0; i < orch_args->tensor_count(); i++) {
+            ChipTensor t = orch_args->tensor(i);
+            if (t.is_device_memory()) {
+                layout.emplace_back(0, 0);
+                continue;
+            }
+            layout.emplace_back(static_cast<uintptr_t>(t.buffer.addr), static_cast<size_t>(t.nbytes()));
+        }
+        return layout;
+    }
+
+    static bool staging_populated_for(void *base, const Layout &layout) {
+        if (base == nullptr) {
+            return false;
+        }
+        std::lock_guard<std::mutex> lock(staging_mu());
+        auto it = staging_meta().find(base);
+        return it != staging_meta().end() && it->second.populated && it->second.layout == layout;
+    }
+
+    static void mark_staging_populated(void *base, Layout layout) {
+        if (base == nullptr) {
+            return;
+        }
+        std::lock_guard<std::mutex> lock(staging_mu());
+        staging_meta()[base] = StagingMeta{std::move(layout), true};
+    }
+
+    static void forget_staging_meta(void *base) {
+        if (base == nullptr) {
+            return;
+        }
+        std::lock_guard<std::mutex> lock(staging_mu());
+        staging_meta().erase(base);
+    }
+
+private:
+    struct SlotBuf {
+        void *ptr = nullptr;
+        size_t bytes = 0;
+    };
+    struct StagingMeta {
+        Layout layout;
+        bool populated = false;
+    };
+
+    static uint64_t slot_key(const HostApi *api) {
+        // Isolate depth>1 pipeline slots on the same DeviceRunner.
+        return (static_cast<uint64_t>(reinterpret_cast<uintptr_t>(api->runner_ctx())) << 8) |
+               static_cast<uint64_t>(api->pipeline_slot());
+    }
+
+    static std::mutex &pool_mu() {
+        static std::mutex mu;
+        return mu;
+    }
+    static std::unordered_map<uint64_t, SlotBuf> &slot_pool() {
+        static std::unordered_map<uint64_t, SlotBuf> pool;
+        return pool;
+    }
+
+    static std::mutex &staging_mu() {
+        static std::mutex mu;
+        return mu;
+    }
+    static std::unordered_map<void *, StagingMeta> &staging_meta() {
+        static std::unordered_map<void *, StagingMeta> meta;
+        return meta;
+    }
+
+    const HostApi *api_ = nullptr;
+    void *base_ = nullptr;
+    size_t capacity_ = 0;
+    size_t offset_ = 0;
+    bool grew_ = false;
+};
+
 namespace {
 
 // host_build_graph is host-orchestration-first: the HOST dlopens the
@@ -402,6 +560,35 @@ static bool relocate_host_orch_image(
 }
 
 bool upload_graph_submissions(Runtime *runtime, const HostApi *api, GraphHostState &graph_state) {
+    // Reuse per-(graph_key, occurrence) device POD buffers across runs so steady
+    // rounds pay H2D only — not device_malloc/device_free for every layer.
+    struct RetainedSubmission {
+        void *ptr = nullptr;
+        size_t bytes = 0;
+    };
+    static std::mutex sub_mu;
+    static std::unordered_map<uint64_t, RetainedSubmission> retained_subs;
+
+    auto acquire_submission = [&](uint64_t graph_key, uint32_t occurrence, size_t bytes) -> void * {
+        const uint64_t key = (graph_key << 32) ^ static_cast<uint64_t>(occurrence);
+        std::lock_guard<std::mutex> lock(sub_mu);
+        RetainedSubmission &slot = retained_subs[key];
+        if (slot.ptr != nullptr && slot.bytes == bytes) {
+            return slot.ptr;
+        }
+        if (slot.ptr != nullptr) {
+            api->device_free(slot.ptr);
+            slot.ptr = nullptr;
+            slot.bytes = 0;
+        }
+        slot.ptr = api->device_malloc(bytes);
+        if (slot.ptr == nullptr) {
+            return nullptr;
+        }
+        slot.bytes = bytes;
+        return slot.ptr;
+    };
+
     std::unordered_map<uint64_t, uint32_t> occurrences;
     const size_t count = graph_host_upload_count(graph_state);
     for (size_t index = 0; index < count; ++index) {
@@ -444,18 +631,20 @@ bool upload_graph_submissions(Runtime *runtime, const HostApi *api, GraphHostSta
         submission->local_execution = 0;
         submission->activation_gate = 0;
 
-        void *device_submission = api->device_malloc(upload->bytes);
+        void *device_submission = acquire_submission(submission->graph_key, occurrence, upload->bytes);
         if (device_submission == nullptr) {
             LOG_ERROR("host-orch: failed to allocate %zu bytes for Graph submission", upload->bytes);
             return false;
         }
         if (api->copy_to_device(device_submission, upload->data, upload->bytes) != 0) {
             LOG_ERROR("host-orch: failed to upload Graph submission POD image");
-            api->device_free(device_submission);
             return false;
         }
         upload->outer_slot->graph_context = device_submission;
-        runtime->tensor_pairs_.push_back({nullptr, device_submission, upload->bytes, false});
+        // Buffer lives in retained_subs until Worker finalize frees the allocator.
+        runtime->tensor_pairs_.push_back(
+            {nullptr, device_submission, upload->bytes, false, TensorReleaseKind::BufferNoop}
+        );
     }
     return true;
 }
@@ -484,8 +673,20 @@ int32_t run_host_orchestration(
     // orch::prepare_task and shipped bounded to total_tasks below.
     const pto2_sm_layout::PTO2RingSegmentOffsets sm_segs =
         pto2_sm_layout::ring_segment_offsets(eff_task_window_sizes[0]);
-    std::unique_ptr<uint8_t[]> host_sm_buf(new uint8_t[sm_size]);
-    void *host_sm = host_sm_buf.get();
+    // Retain the host SM mirror across runs — steady rounds only need a header
+    // memset, not a fresh multi‑MB allocation each bind.
+    static std::mutex host_sm_mu;
+    static std::unique_ptr<uint8_t[]> retained_host_sm;
+    static size_t retained_host_sm_bytes = 0;
+    void *host_sm = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(host_sm_mu);
+        if (retained_host_sm_bytes < sm_size) {
+            retained_host_sm.reset(new uint8_t[sm_size]);
+            retained_host_sm_bytes = sm_size;
+        }
+        host_sm = retained_host_sm.get();
+    }
     std::memset(host_sm, 0, sm_segs.descriptors);
 
     // Re-point the orchestrator half at the host SM (scheduler keeps device SM).
@@ -749,71 +950,89 @@ extern "C" int bind_callable_to_runtime_impl(
     // the point at which a task could make it stale.
     HostTensorAccessor tensor_access(api);
 
+    RetainedTempBump bump;
+    if (!bump.begin(api, orch_args)) {
+        return -1;
+    }
+    const RetainedTempBump::Layout args_layout = RetainedTempBump::build_layout(orch_args);
+    const bool skip_h2d = !bump.grew() && RetainedTempBump::staging_populated_for(bump.base(), args_layout);
+
     int64_t t_args_start = _now_ms();
-    for (int i = 0; i < tensor_count; i++) {
-        ChipTensor t = orch_args->tensor(i);
+    {
+        STRACE_A("simpler_run.bind.args", skip_h2d ? "reuse=1" : "reuse=0");
+        for (int i = 0; i < tensor_count; i++) {
+            ChipTensor t = orch_args->tensor(i);
 
-        if (t.is_device_memory()) {
-            LOG_DEBUG("  ChipTensor %d: child memory, pass-through (0x%" PRIx64 ")", i, t.buffer.addr);
-            device_args.add_tensor(t);
-            continue;
-        }
+            if (t.is_device_memory()) {
+                LOG_DEBUG("  ChipTensor %d: child memory, pass-through (0x%" PRIx64 ")", i, t.buffer.addr);
+                device_args.add_tensor(t);
+                continue;
+            }
 
-        void *host_ptr = reinterpret_cast<void *>(static_cast<uintptr_t>(t.buffer.addr));
-        size_t size = static_cast<size_t>(t.nbytes());
+            void *host_ptr = reinterpret_cast<void *>(static_cast<uintptr_t>(t.buffer.addr));
+            size_t size = static_cast<size_t>(t.nbytes());
+            if (size == 0) {
+                t.buffer.addr = 0;
+                device_args.add_tensor(t);
+                continue;
+            }
 
-        void *dev_ptr = api->device_malloc(size);
-        if (dev_ptr == nullptr) {
-            LOG_ERROR("Failed to allocate device memory for tensor %d", i);
-            return -1;
-        }
+            void *dev_ptr = bump.acquire(size);
+            if (dev_ptr == nullptr) {
+                LOG_ERROR("Failed to acquire retained staging for tensor %d", i);
+                return -1;
+            }
 
-        // Pure write-only OUTPUT buffers are never read by the kernel and hold
-        // no meaningful host content, so they need no device staging — the
-        // kernel defines what it writes and any unwritten bytes are undefined.
-        // IN / INOUT (read-before-write) are staged H2D.
-        bool is_pure_output = (signature != nullptr && i < sig_count && signature[i] == ArgDirection::OUT);
-        if (!is_pure_output) {
-            int rc = api->copy_to_device(dev_ptr, host_ptr, size);
-            if (rc != 0) {
-                LOG_ERROR("Failed to stage tensor %d to device", i);
-                api->device_free(dev_ptr);
+            // Pure write-only OUTPUT buffers are never read by the kernel and hold
+            // no meaningful host content, so they need no device staging — the
+            // kernel defines what it writes and any unwritten bytes are undefined.
+            // IN / INOUT (read-before-write) are staged H2D unless the retained
+            // buffer already holds this exact host layout from a prior run.
+            bool is_pure_output = (signature != nullptr && i < sig_count && signature[i] == ArgDirection::OUT);
+            if (!is_pure_output && !skip_h2d) {
+                int rc = api->copy_to_device(dev_ptr, host_ptr, size);
+                if (rc != 0) {
+                    LOG_ERROR("Failed to stage tensor %d to device", i);
+                    return -1;
+                }
+            }
+            // Read-only INPUT tensors are never written by the kernel, so there is
+            // no point copying them back D2H at the end. Index the signature
+            // by the orch tensor index `i` (device-space tensors are skipped above
+            // but do not consume a separate signature slot — scalars follow the
+            // tensor entries). Anything not provably IN keeps the safe default of
+            // copying back.
+            bool needs_copy_back = !(signature != nullptr && i < sig_count && signature[i] == ArgDirection::IN);
+            runtime->tensor_pairs_.push_back({host_ptr, dev_ptr, size, needs_copy_back, TensorReleaseKind::BufferNoop});
+            LOG_DEBUG("  ChipTensor %d: %zu bytes at %p (h2d=%s)", i, size, dev_ptr, skip_h2d ? "skip" : "copy");
+
+            // host_build_graph runs the orchestrator on the host, which may read
+            // control tensors (e.g. paged_attention's context_lens/block_table) via
+            // get_tensor_data to shape the graph. Give it a host view of this
+            // buffer: the device buffer itself where the platform can map it into
+            // the host address space (released in validate_runtime_impl before
+            // device_free), otherwise the staging copy, which holds the same bytes
+            // for the whole orchestration window and whose writes are pushed back
+            // to the device. A tensor with neither is not host-accessible, so the
+            // prepare fails here rather than the orchestrator dereferencing a
+            // device address.
+            if (!tensor_access.add(reinterpret_cast<uint64_t>(dev_ptr), size, host_ptr)) {
+                LOG_ERROR("host-orch: no host view for tensor %d (dev_ptr %p, %zu bytes)", i, dev_ptr, size);
                 return -1;
             }
+
+            t.buffer.addr = reinterpret_cast<uint64_t>(dev_ptr);
+            device_args.add_tensor(t);
         }
-        // Read-only INPUT tensors are never written by the kernel, so there is
-        // no point copying them back D2H at the end. Index the signature
-        // by the orch tensor index `i` (device-space tensors are skipped above
-        // but do not consume a separate signature slot — scalars follow the
-        // tensor entries). Anything not provably IN keeps the safe default of
-        // copying back.
-        bool needs_copy_back = !(signature != nullptr && i < sig_count && signature[i] == ArgDirection::IN);
-        runtime->tensor_pairs_.push_back({host_ptr, dev_ptr, size, needs_copy_back});
-        LOG_DEBUG("  ChipTensor %d: %zu bytes at %p", i, size, dev_ptr);
-
-        // host_build_graph runs the orchestrator on the host, which may read
-        // control tensors (e.g. paged_attention's context_lens/block_table) via
-        // get_tensor_data to shape the graph. Give it a host view of this
-        // buffer: the device buffer itself where the platform can map it into
-        // the host address space (released in validate_runtime_impl before
-        // device_free), otherwise the staging copy, which holds the same bytes
-        // for the whole orchestration window and whose writes are pushed back
-        // to the device. A tensor with neither is not host-accessible, so the
-        // prepare fails here rather than the orchestrator dereferencing a
-        // device address.
-        if (!tensor_access.add(reinterpret_cast<uint64_t>(dev_ptr), size, host_ptr)) {
-            LOG_ERROR("host-orch: no host view for tensor %d (dev_ptr %p, %zu bytes)", i, dev_ptr, size);
-            return -1;
+        for (int i = 0; i < scalar_count; i++) {
+            device_args.add_scalar(orch_args->scalar(i));
+        }
+        if (!skip_h2d) {
+            RetainedTempBump::mark_staging_populated(bump.base(), args_layout);
         }
-
-        t.buffer.addr = reinterpret_cast<uint64_t>(dev_ptr);
-        device_args.add_tensor(t);
-    }
-    for (int i = 0; i < scalar_count; i++) {
-        device_args.add_scalar(orch_args->scalar(i));
     }
     int64_t t_args_end = _now_ms();
-
+    LOG_INFO("TIMING: args_malloc_copy = %" PRId64 "ms (skip_h2d=%d)", t_args_end - t_args_start, skip_h2d ? 1 : 0);
     // Lay out the per-Worker static device arena. GM heap, PTO2 shared memory,
     // and the prebuilt runtime arena use three independent pooled device
     // allocations committed together by setup_static_arena.
@@ -1006,6 +1225,11 @@ extern "C" int validate_runtime_impl(Runtime *runtime, const HostApi *api, int e
 
     if (skip_tensor_copy_back) {
         LOG_WARN("Skipping tensor copy-back because execution failed");
+    } else if (const char *skip = std::getenv("SIMPLER_SKIP_TENSOR_COPY_BACK");
+               skip != nullptr && skip[0] != '\0' && skip[0] != '0') {
+        // Perf / multi-round timing: INOUT D2H of multi‑GiB KV dominates Host wall
+        // and is unused when golden compare is off.
+        LOG_INFO("Skipping tensor copy-back (SIMPLER_SKIP_TENSOR_COPY_BACK)");
     } else {
         for (int i = 0; i < tensor_pair_count; i++) {
             const TensorPair &pair = tensor_pairs[i];
@@ -1040,14 +1264,22 @@ extern "C" int validate_runtime_impl(Runtime *runtime, const HostApi *api, int e
         }
     }
 
-    // Cleanup device tensors
+    // Cleanup device tensors that this run owns. Retained-temp slices
+    // (BufferNoop) stay alive for the next bind — DeviceRunner frees them at
+    // finalize.
     LOG_INFO("=== Cleaning Up ===");
+    int freed = 0;
     for (int i = 0; i < tensor_pair_count; i++) {
-        if (tensor_pairs[i].dev_ptr != nullptr) {
-            api->device_free(tensor_pairs[i].dev_ptr);
+        if (tensor_pairs[i].dev_ptr == nullptr) {
+            continue;
+        }
+        if (tensor_pairs[i].release_kind == TensorReleaseKind::BufferNoop) {
+            continue;
         }
+        api->device_free(tensor_pairs[i].dev_ptr);
+        ++freed;
     }
-    LOG_INFO("Freed %d device allocations", tensor_pair_count);
+    LOG_INFO("Freed %d device allocations (%d retained-temp slices kept)", freed, tensor_pair_count - freed);
 
     // Clear the per-run dispatch-table entries staged by register_callable_impl.
     // The underlying chip-callable device buffer is pool-managed by
diff --git a/src/a2a3/runtime/host_build_graph/runtime/runtime.h b/src/a2a3/runtime/host_build_graph/runtime/runtime.h
index 91bbff4cf6..07594f2676 100644
--- a/src/a2a3/runtime/host_build_graph/runtime/runtime.h
+++ b/src/a2a3/runtime/host_build_graph/runtime/runtime.h
@@ -106,6 +106,11 @@ struct Handshake {
  * ChipTensor pair for tracking host-device memory mappings.
  * Used for copy-back during finalize.
  */
+enum class TensorReleaseKind {
+    Free,        // device_malloc'd for this run — free in validate
+    BufferNoop,  // slice of HBG private per-slot staging — live across runs
+};
+
 struct TensorPair {
     void *host_ptr;
     void *dev_ptr;
@@ -114,6 +119,7 @@ struct TensorPair {
     // so the end-of-run D2H copy-back is skipped. OUTPUT/INOUT/unknown
     // keep the safe default of copying back.
     bool needs_copy_back = true;
+    TensorReleaseKind release_kind = TensorReleaseKind::Free;
 };
 
 /**
diff --git a/src/common/platform/include/common/host_api.h b/src/common/platform/include/common/host_api.h
index e081132e7b..c41cfc5bfc 100644
--- a/src/common/platform/include/common/host_api.h
+++ b/src/common/platform/include/common/host_api.h
@@ -184,6 +184,11 @@ struct HostApi {
         return ops_->upload_chip_callable_buffer(runner_ctx_, callable);
     }
 
+    // Identity of this run's DeviceRunner + pipeline slot (for host-side caches
+    // that must not share state across depth>1 slots).
+    void *runner_ctx() const { return runner_ctx_; }
+    uint32_t pipeline_slot() const { return pipeline_slot_; }
+
 private:
     void *runner_ctx_{nullptr};
     uint32_t pipeline_slot_{0};

From 95891f6c71fca66e8b648c19d823d94edd6a7b89 Mon Sep 17 00:00:00 2001
From: yanghaoran29 <yanghaoran29@huawei.com>
Date: Mon, 17 Aug 2026 23:23:26 -0700
Subject: [PATCH 2/2] Perf: pin Graph PODs and H2D each layer synchronously

Write each Graph layer into a retained pinned host arena and copy_to_device
as soon as the POD is ready, so bind skips a later gather of unpinned images.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 simpler_setup/tools/strace_timing.py          | 222 ++++++++-
 .../host_build_graph/host/runtime_maker.cpp   | 450 +++++++++++-------
 .../orchestrator_core/pto_orchestrator.cpp    | 166 ++++++-
 .../host_build_graph/graph_host_state.h       |  15 +
 tests/ut/py/test_strace_timing.py             |  55 +++
 5 files changed, 700 insertions(+), 208 deletions(-)

diff --git a/simpler_setup/tools/strace_timing.py b/simpler_setup/tools/strace_timing.py
index 1f6669792e..1ce57e2856 100644
--- a/simpler_setup/tools/strace_timing.py
+++ b/simpler_setup/tools/strace_timing.py
@@ -279,22 +279,116 @@ def print_tpot_table(buckets, label_for_hid=None, stream=sys.stdout):
     "device": "simpler_run.runner_run.device_wall",
     "orch": "simpler_run.runner_run.device_wall.orch",
     "sched": "simpler_run.runner_run.device_wall.sched",
+    # HBG host-bind stages (a2a3 host_build_graph). Distinct from TMR device Orch.
+    "args": "simpler_run.bind.args",
+    "prebuilt": "simpler_run.bind.prebuilt",
+    "host_orch": "simpler_run.bind.host_orch",
+    "relocate": "simpler_run.bind.relocate",
+    "h2d_image": "simpler_run.bind.h2d_image",
+    "h2d_graph": "simpler_run.bind.h2d_graph",
+    "h2d_sm": "simpler_run.bind.h2d_sm",
+    "h2d_arena": "simpler_run.bind.h2d_arena",
 }
 
 # Per-round table columns, in print order. "Effective" is the orch∪sched merged
 # window (the old device-log "Total"), recomputed here purely from the orch/sched
 # markers' device-domain ts+dur — no device log needed. label is the column
-# header / "Avg <label>".
-_ROUNDS_TABLE_COLUMNS = ("Host", "Device", "Effective", "Orch", "Sched")
+# header / "Avg <label>". HBG bind columns appear only when those spans exist.
+_ROUNDS_TABLE_COLUMNS = (
+    "Host",
+    "Device",
+    "Effective",
+    "Orch",
+    "Sched",
+    "Args",
+    "Prebuilt",
+    "HostOrch",
+    "Relocate",
+    "H2dImage",
+    "H2dGraph",
+    "H2dSm",
+    "H2dArena",
+)
+
+# Bind-stage keys used for the HBG share table (document gate = HostOrch + H2dImage).
+_BIND_SHARE_KEYS = ("args", "prebuilt", "host_orch", "relocate", "h2d_image")
+_BIND_SHARE_LABELS = {
+    "args": "Args",
+    "prebuilt": "Prebuilt",
+    "host_orch": "HostOrch",
+    "relocate": "Relocate",
+    "h2d_image": "H2dImage",
+}
+
+
+def _span_contained(inner, outer):
+    """True if ``inner``'s [ts, ts+dur] lies inside ``outer`` (and is not ``outer``)."""
+    if inner is outer:
+        return False
+    inner_end = inner.ts + inner.dur
+    outer_end = outer.ts + outer.dur
+    return inner.ts >= outer.ts and inner_end <= outer_end
+
+
+def _sum_top_level_named_ns(inv, name):
+    """Sum spans named ``name`` that are not nested inside another span of the same name."""
+    named = [s for s in inv.spans if s.name == name]
+    return sum(s.dur for s in named if not any(_span_contained(s, other) for other in named))
+
+
+def _sum_span_dur_us(inv, name):
+    """Sum every span with ``name`` in this invocation (µs).
+
+    HBG may emit several image-upload pieces. Exact-name matches are summed;
+    for ``simpler_run.bind.h2d_image`` we also fold the split children
+    ``h2d_graph`` / ``h2d_sm`` / ``h2d_arena`` so the Gate column stays one number.
+
+    Eager per-layer H2D emits ``h2d_graph`` *inside* ``host_orch.entry``. Those
+    nested copies belong to H2dGraph: HostOrch is exclusive of them, and
+    nested ``h2d_graph`` children of a leftover ``h2d_graph`` parent are not
+    double-counted.
+    """
+    if name == "simpler_run.bind.h2d_image":
+        total_ns = _sum_top_level_named_ns(inv, "simpler_run.bind.h2d_graph")
+        total_ns += sum(s.dur for s in inv.spans if s.name == "simpler_run.bind.h2d_sm")
+        total_ns += sum(s.dur for s in inv.spans if s.name == "simpler_run.bind.h2d_arena")
+        total_ns += sum(s.dur for s in inv.spans if s.name == name)
+    elif name == "simpler_run.bind.h2d_graph":
+        total_ns = _sum_top_level_named_ns(inv, name)
+    elif name == "simpler_run.bind.host_orch":
+        parents = [s for s in inv.spans if s.name == name]
+        parent = sum(s.dur for s in parents)
+        if parent > 0:
+            nested_h2d = sum(
+                s.dur
+                for s in inv.spans
+                if s.name == "simpler_run.bind.h2d_graph" and any(_span_contained(s, p) for p in parents)
+            )
+            total_ns = parent - nested_h2d
+        else:
+            total_ns = sum(
+                s.dur
+                for s in inv.spans
+                if s.name
+                in (
+                    "simpler_run.bind.host_orch.setup",
+                    "simpler_run.bind.host_orch.entry",
+                )
+            )
+    elif name == "simpler_run.bind.orch_h2d_pipe":
+        total_ns = sum(s.dur for s in inv.spans if s.name == name)
+    else:
+        total_ns = sum(s.dur for s in inv.spans if s.name == name)
+    return total_ns / 1000.0
 
 
 def _round_metrics(inv):
-    """Return one round's (Host, Device, Effective, Orch, Sched) in µs from spans.
+    """Return one round's metrics in µs; column order matches ``_ROUNDS_TABLE_COLUMNS``.
 
-    Host/Device/Orch/Sched are span durations; Effective =
+    Host/Device/Orch/Sched are single-span durations; Effective =
     ``max(orch_end, sched_end) - min(orch_start, sched_start)`` from the orch/sched
-    spans' device-domain ``ts``/``dur`` (0 when neither is present). All values in
-    µs. Column order matches ``_ROUNDS_TABLE_COLUMNS``.
+    spans' device-domain ``ts``/``dur`` (0 when neither is present). HBG bind
+    columns sum same-name spans (h2d_image may be multi-piece).
     """
     names = inv.by_name()
 
@@ -312,22 +406,38 @@ def _dur(key):
     else:
         effective = 0.0
 
-    return (_dur("host"), _dur("device"), effective, _dur("orch"), _dur("sched"))
+    return (
+        _dur("host"),
+        _dur("device"),
+        effective,
+        _dur("orch"),
+        _dur("sched"),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["args"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["prebuilt"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["host_orch"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["relocate"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["h2d_image"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["h2d_graph"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["h2d_sm"]),
+        _sum_span_dur_us(inv, _ROUNDS_TABLE_NAMES["h2d_arena"]),
+    )
 
 
 def print_rounds_table(buckets, stream=sys.stdout):
-    """Print a per-round Host/Device/Effective/Orch/Sched table (µs) for the busiest hid.
+    """Print a per-round Host/Device/Effective/Orch/Sched (+ HBG bind) table (µs).
 
     This renders the per-round benchmark table that ``scene_test`` used to print
     inline. The most-invoked hid bucket is treated as the rounds (one row per
     invocation, ordered by ``inv``); each row's metrics come from
     :func:`_round_metrics`. A column is hidden when every row read 0 (e.g.
     device/orch/sched/effective are 0 when their marker is absent; for example,
-    HBG emits device wall but has no device-side orch/sched windows).
+    HBG emits device wall but has no device-side orch/sched windows). When HBG
+    bind children are present, a bind-share summary (µs + % of bind stages, plus
+    document-gate HostOrch+H2dImage) is printed after the averages.
 
     The output format is consumed by ``tools/benchmark_rounds.sh``'s
     framework-table parser (header ``Round  Host (us) …``, ``Avg Host:``
-    terminator).
+    terminator). Extra trailing columns are ignored by that parser.
     """
     if not buckets:
         print("No [STRACE] markers found.", file=stream)
@@ -389,6 +499,98 @@ def _avg(idx):
         msg += f"  (dropped {trim} low + {trim} high, {tc} rounds used)"
         print(msg, file=stream)
 
+    # HBG bind-share: only when at least one bind-stage column was present.
+    bind_col_idxs = {
+        key: _ROUNDS_TABLE_COLUMNS.index(_BIND_SHARE_LABELS[key]) for key in _BIND_SHARE_KEYS
+    }
+    if any(bind_col_idxs[k] in nz for k in _BIND_SHARE_KEYS):
+        print_bind_share_table(rows, stream=stream)
+        if n >= 2:
+            print_bind_share_warmup_vs_steady(rows, stream=stream)
+
+
+def _bind_stage_means(rows):
+    """Per-stage mean µs over rows (zeros excluded per stage)."""
+    means = {}
+    for key in _BIND_SHARE_KEYS:
+        idx = _ROUNDS_TABLE_COLUMNS.index(_BIND_SHARE_LABELS[key])
+        vals = [r[idx] for r in rows if r[idx] > 0.0]
+        means[key] = (sum(vals) / len(vals)) if vals else 0.0
+    return means
+
+
+def _print_bind_share_block(title, means, stream):
+    total = sum(means.values())
+    print(file=stream)
+    print(f"  {title}:", file=stream)
+    if total <= 0.0:
+        print("    (no bind-stage spans)", file=stream)
+        return
+    # Rank by µs so the hotspot is obvious when warmup ≠ steady.
+    ranked = sorted(means.items(), key=lambda kv: kv[1], reverse=True)
+    top = ranked[0][0] if ranked and ranked[0][1] > 0 else None
+    for key in _BIND_SHARE_KEYS:
+        us = means[key]
+        pct = 100.0 * us / total if total > 0 else 0.0
+        mark = "  <-- top" if key == top else ""
+        print(f"    {_BIND_SHARE_LABELS[key]:<10} {us:10.1f} us  ({pct:5.1f}%){mark}", file=stream)
+    gate = means["host_orch"] + means["h2d_image"]
+    print(
+        f"    Gate(HostOrch+H2dImage) {gate:10.1f} us  (target <= 1000 us)",
+        file=stream,
+    )
+
+
+def print_bind_share_table(rows, stream=sys.stdout):
+    """Print mean µs and % share of HBG bind stages across all rounds."""
+    if not rows:
+        return
+    _print_bind_share_block(
+        "HBG bind share (all rounds, mean over rounds with each stage > 0)",
+        _bind_stage_means(rows),
+        stream,
+    )
+
+
+def print_bind_share_warmup_vs_steady(rows, stream=sys.stdout):
+    """Compare round-0 (warmup) bind share vs rounds 1..N-1 (steady).
+
+    First-run costs (cold malloc, Graph Definition record, pool first acquire)
+    often dominate round 0; optimization decisions for the 1ms gate should follow
+    the **steady** ranking unless round 0 itself is the product path.
+    """
+    if len(rows) < 2:
+        return
+    warm = _bind_stage_means(rows[:1])
+    steady = _bind_stage_means(rows[1:])
+    _print_bind_share_block("HBG bind share — round 0 (warmup)", warm, stream)
+    _print_bind_share_block(
+        f"HBG bind share — rounds 1..{len(rows) - 1} (steady, n={len(rows) - 1})",
+        steady,
+        stream,
+    )
+    # Call out ranking flips so analysis does not optimize the wrong phase.
+    def _top_key(means):
+        ranked = sorted(means.items(), key=lambda kv: kv[1], reverse=True)
+        return ranked[0][0] if ranked and ranked[0][1] > 0 else None
+
+    tw, ts = _top_key(warm), _top_key(steady)
+    print(file=stream)
+    if tw is None or ts is None:
+        print("  Warmup vs steady: insufficient bind-stage data to compare tops.", file=stream)
+    elif tw != ts:
+        print(
+            f"  Warmup vs steady: TOP DIFFERS — warmup top={_BIND_SHARE_LABELS[tw]}, "
+            f"steady top={_BIND_SHARE_LABELS[ts]} (optimize for steady unless gate is first-token).",
+            file=stream,
+        )
+    else:
+        print(
+            f"  Warmup vs steady: same top stage ({_BIND_SHARE_LABELS[tw]}); "
+            f"still compare per-stage µs above — magnitudes often differ.",
+            file=stream,
+        )
+
 
 def _bucket_label(buckets, hid):
     """Short human label for an hid: 'decode' (busiest bucket) / 'prefill' (once) / hid prefix."""
diff --git a/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp b/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp
index 8d9e7af304..90fb4e4965 100644
--- a/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp
+++ b/src/a2a3/runtime/host_build_graph/host/runtime_maker.cpp
@@ -39,7 +39,6 @@
 #include <cinttypes>
 #include <cstddef>
 #include <cstdint>
-#include <cstdio>
 #include <cctype>
 #include <cstdlib>
 #include <cstring>
@@ -70,6 +69,7 @@
 #include "callable.h"
 #include "common/platform_config.h"
 #include "common/strace.h"
+#include "acl/acl_rt.h"
 #include "common/unified_log.h"
 #include "utils/device_arena.h"
 #include "prepare_callable_common.h"
@@ -559,20 +559,62 @@ static bool relocate_host_orch_image(
     return ok;
 }
 
-bool upload_graph_submissions(Runtime *runtime, const HostApi *api, GraphHostState &graph_state) {
-    // Reuse per-(graph_key, occurrence) device POD buffers across runs so steady
-    // rounds pay H2D only — not device_malloc/device_free for every layer.
+// Retained pinned bump arena for Graph POD images. Orch writes each layer
+// in place; upload_one synchronously H2Ds that POD (source is already pinned).
+struct GraphPinnedPack {
+    void *host = nullptr;
+    size_t cap = 0;
+};
+
+static GraphPinnedPack g_graph_pack;
+static std::mutex g_graph_pack_mu;
+constexpr size_t kGraphPinnedArenaBytes = 16ull * 1024ull * 1024ull;
+
+static bool ensure_graph_pinned_pack(size_t cap) {
+    std::lock_guard<std::mutex> lock(g_graph_pack_mu);
+    if (g_graph_pack.cap >= cap && g_graph_pack.host != nullptr) {
+        return true;
+    }
+    if (g_graph_pack.host != nullptr) {
+        (void)aclrtFreeHost(g_graph_pack.host);
+        g_graph_pack.host = nullptr;
+    }
+    g_graph_pack.cap = 0;
+    void *host = nullptr;
+    const aclError mrc = aclrtMallocHost(&host, cap);
+    if (mrc != ACL_SUCCESS || host == nullptr) {
+        LOG_ERROR("host-orch: aclrtMallocHost(%zu) failed rc=%d", cap, static_cast<int>(mrc));
+        return false;
+    }
+    std::memset(host, 0, cap);
+    g_graph_pack.host = host;
+    g_graph_pack.cap = cap;
+    return true;
+}
+
+struct GraphPodH2d {
+    Runtime *runtime = nullptr;
+    const HostApi *api = nullptr;
+    std::unordered_map<uint64_t, uint32_t> occurrences;
+
     struct RetainedSubmission {
         void *ptr = nullptr;
         size_t bytes = 0;
     };
-    static std::mutex sub_mu;
-    static std::unordered_map<uint64_t, RetainedSubmission> retained_subs;
 
-    auto acquire_submission = [&](uint64_t graph_key, uint32_t occurrence, size_t bytes) -> void * {
+    static std::mutex &subs_mu() {
+        static std::mutex mu;
+        return mu;
+    }
+    static std::unordered_map<uint64_t, RetainedSubmission> &retained_subs() {
+        static std::unordered_map<uint64_t, RetainedSubmission> m;
+        return m;
+    }
+
+    void *acquire_submission(uint64_t graph_key, uint32_t occurrence, size_t bytes) {
         const uint64_t key = (graph_key << 32) ^ static_cast<uint64_t>(occurrence);
-        std::lock_guard<std::mutex> lock(sub_mu);
-        RetainedSubmission &slot = retained_subs[key];
+        std::lock_guard<std::mutex> lock(subs_mu());
+        RetainedSubmission &slot = retained_subs()[key];
         if (slot.ptr != nullptr && slot.bytes == bytes) {
             return slot.ptr;
         }
@@ -587,11 +629,13 @@ bool upload_graph_submissions(Runtime *runtime, const HostApi *api, GraphHostSta
         }
         slot.bytes = bytes;
         return slot.ptr;
-    };
+    }
 
-    std::unordered_map<uint64_t, uint32_t> occurrences;
-    const size_t count = graph_host_upload_count(graph_state);
-    for (size_t index = 0; index < count; ++index) {
+    bool upload_one(GraphHostState &graph_state, size_t index) {
+        if (graph_host_upload_h2d_done(graph_state, index)) {
+            return true;
+        }
+        STRACE("simpler_run.bind.h2d_graph");
         std::optional<GraphHostUpload> upload = graph_host_upload(graph_state, index);
         if (!upload.has_value() || upload->outer_slot == nullptr || upload->data == nullptr ||
             upload->bytes < sizeof(GraphSubmission) || upload->outer_slot->task_kind != TaskKind::GRAPH ||
@@ -620,10 +664,7 @@ bool upload_graph_submissions(Runtime *runtime, const HostApi *api, GraphHostSta
             submission->graph_key, occurrence, execution_bytes, alignof(GraphNodeStorage)
         );
         if (execution_storage == nullptr) {
-            LOG_ERROR(
-                "host-orch: failed to retain %zu bytes for Graph execution key=%#llx occurrence=%u", execution_bytes,
-                static_cast<unsigned long long>(submission->graph_key), occurrence
-            );
+            LOG_ERROR("host-orch: failed to retain Graph execution storage");
             return false;
         }
         submission->execution_storage = reinterpret_cast<uint64_t>(execution_storage);
@@ -633,18 +674,36 @@ bool upload_graph_submissions(Runtime *runtime, const HostApi *api, GraphHostSta
 
         void *device_submission = acquire_submission(submission->graph_key, occurrence, upload->bytes);
         if (device_submission == nullptr) {
-            LOG_ERROR("host-orch: failed to allocate %zu bytes for Graph submission", upload->bytes);
+            LOG_ERROR("host-orch: failed to allocate Graph submission");
             return false;
         }
         if (api->copy_to_device(device_submission, upload->data, upload->bytes) != 0) {
             LOG_ERROR("host-orch: failed to upload Graph submission POD image");
             return false;
         }
+
         upload->outer_slot->graph_context = device_submission;
-        // Buffer lives in retained_subs until Worker finalize frees the allocator.
         runtime->tensor_pairs_.push_back(
             {nullptr, device_submission, upload->bytes, false, TensorReleaseKind::BufferNoop}
         );
+        graph_host_mark_upload_h2d_done(graph_state, index);
+        return true;
+    }
+
+    static bool eager_cb(void *ctx, GraphHostState &state, size_t index) {
+        return static_cast<GraphPodH2d *>(ctx)->upload_one(state, index);
+    }
+};
+
+static bool upload_leftover_graph_submissions(GraphPodH2d &h2d, GraphHostState &graph_state) {
+    const size_t count = graph_host_upload_count(graph_state);
+    for (size_t index = 0; index < count; ++index) {
+        if (graph_host_upload_h2d_done(graph_state, index)) {
+            continue;
+        }
+        if (!h2d.upload_one(graph_state, index)) {
+            return false;
+        }
     }
     return true;
 }
@@ -665,12 +724,8 @@ int32_t run_host_orchestration(
     const uint64_t eff_heap_sizes[PTO2_MAX_RING_DEPTH], const uint64_t eff_task_window_sizes[PTO2_MAX_RING_DEPTH],
     void *host_orch_func_ptr, const ChipTaskArgs &orch_l2
 ) {
-    dep_gen_host_graph_begin_capture();
-
-    // Init-on-write: descriptors, payloads, slot_states and completion_flags are
-    // each written per task at submit and read only for [0, total_tasks). Zero
-    // only the fixed-size header here; the per-slot segments are initialized in
-    // orch::prepare_task and shipped bounded to total_tasks below.
+    // Lightweight [STRACE] bind children (ns): host_orch / relocate / h2d_*.
+    // Document gate = HostOrch + H2dImage (h2d_graph + h2d_sm + h2d_arena).
     const pto2_sm_layout::PTO2RingSegmentOffsets sm_segs =
         pto2_sm_layout::ring_segment_offsets(eff_task_window_sizes[0]);
     // Retain the host SM mirror across runs — steady rounds only need a header
@@ -687,62 +742,95 @@ int32_t run_host_orchestration(
         }
         host_sm = retained_host_sm.get();
     }
-    std::memset(host_sm, 0, sm_segs.descriptors);
-
-    // Re-point the orchestrator half at the host SM (scheduler keeps device SM).
-    // init_data_from_layout resets the orchestrator state, so this is safe.
-    if (!rt->orchestrator.init_data_from_layout(
-            layout.orch, host_arena, host_sm, gm_heap, eff_heap_sizes[0], eff_task_window_sizes[0]
-        )) {
-        LOG_ERROR("host-orch: orchestrator re-init against host SM failed");
-        return -1;
-    }
-    rt->orchestrator.wire_arena_pointers(layout.orch, host_arena, &rt->scheduler);
-
     PTO2SharedMemoryHandle host_sm_handle;
-    if (!host_sm_handle.init_per_ring(host_sm, sm_size, eff_task_window_sizes, eff_heap_sizes)) {
-        LOG_ERROR("host-orch: host SM init_per_ring failed");
-        return -1;
+    GraphHostStatePtr graph_state;
+    int32_t total_tasks = -1;
+
+    GraphPodH2d graph_h2d;
+    graph_h2d.runtime = runtime;
+    graph_h2d.api = api;
+    struct PinnedArenaClear {
+        ~PinnedArenaClear() { graph_host_clear_pinned_arena(); }
+    } pinned_arena_clear;
+    if (ensure_graph_pinned_pack(kGraphPinnedArenaBytes)) {
+        graph_host_set_pinned_arena(static_cast<std::byte *>(g_graph_pack.host), g_graph_pack.cap);
+    } else {
+        LOG_WARN("host-orch: pinned Graph arena unavailable; POD H2D may stage");
     }
 
-    GraphHostStatePtr graph_state = make_graph_host_state();
-    if (!graph_state) {
-        LOG_ERROR("host-orch: failed to allocate Graph host state");
-        return -1;
-    }
-    GraphHostStateBinding graph_binding(rt->orchestrator, graph_state.get());
+    {
+        STRACE("simpler_run.bind.orch_h2d_pipe");
+        {
+            STRACE("simpler_run.bind.host_orch");
+            dep_gen_host_graph_begin_capture();
 
-    const int32_t block_dim = runtime->get_worker_count() / PLATFORM_CORES_PER_BLOCKDIM;
-    if (block_dim < 1) {
-        LOG_ERROR("host-orch: worker_count %d yields no clusters", runtime->get_worker_count());
-        return -1;
-    }
-    runtime_finalize_after_wire(
-        rt, block_dim * PLATFORM_AIC_CORES_PER_BLOCKDIM, block_dim * PLATFORM_AIV_CORES_PER_BLOCKDIM
-    );
-    rt->mode = PTO2_MODE_EXECUTE;
+            {
+                STRACE("simpler_run.bind.host_orch.setup");
+                std::memset(host_sm, 0, sm_segs.descriptors);
 
-    const auto *entry_points = reinterpret_cast<const HostOrchEntryPoints *>(host_orch_func_ptr);
-    if (entry_points->bind == nullptr) {
-        LOG_ERROR("host-orch: orch .so framework_bind_runtime was not resolved");
-        return -1;
-    }
-    rt->active_callable_hash = reinterpret_cast<uint64_t>(entry_points->entry);
-    rt->tensor_access = &tensor_access;
-    // Binds the orchestration .so's own framework_current_runtime, which its
-    // inline rt_submit_* read. The host library links a same-named copy from
-    // orchestration/common.cpp, but nothing outside the .so includes
-    // pto_orchestration_api.h, so nothing reads that one — rt_scope_* and
-    // rt_orchestration_done take the runtime as an argument.
-    entry_points->bind(rt);
+                if (!rt->orchestrator.init_data_from_layout(
+                        layout.orch, host_arena, host_sm, gm_heap, eff_heap_sizes[0], eff_task_window_sizes[0]
+                    )) {
+                    LOG_ERROR("host-orch: orchestrator re-init against host SM failed");
+                    return -1;
+                }
+                rt->orchestrator.wire_arena_pointers(layout.orch, host_arena, &rt->scheduler);
+
+                if (!host_sm_handle.init_per_ring(host_sm, sm_size, eff_task_window_sizes, eff_heap_sizes)) {
+                    LOG_ERROR("host-orch: host SM init_per_ring failed");
+                    return -1;
+                }
 
-    rt_scope_begin(rt);
-    entry_points->entry(orch_l2);
-    rt_scope_end(rt);
-    rt_orchestration_done(rt);
+                graph_state = make_graph_host_state();
+                if (!graph_state) {
+                    LOG_ERROR("host-orch: failed to allocate Graph host state");
+                    return -1;
+                }
+
+                const int32_t block_dim = runtime->get_worker_count() / PLATFORM_CORES_PER_BLOCKDIM;
+                if (block_dim < 1) {
+                    LOG_ERROR("host-orch: worker_count %d yields no clusters", runtime->get_worker_count());
+                    return -1;
+                }
+                runtime_finalize_after_wire(
+                    rt, block_dim * PLATFORM_AIC_CORES_PER_BLOCKDIM, block_dim * PLATFORM_AIV_CORES_PER_BLOCKDIM
+                );
+                rt->mode = PTO2_MODE_EXECUTE;
+
+                const auto *entry_points = reinterpret_cast<const HostOrchEntryPoints *>(host_orch_func_ptr);
+                if (entry_points->bind == nullptr) {
+                    LOG_ERROR("host-orch: orch .so framework_bind_runtime was not resolved");
+                    return -1;
+                }
+                rt->active_callable_hash = reinterpret_cast<uint64_t>(entry_points->entry);
+                rt->tensor_access = &tensor_access;
+                entry_points->bind(rt);
+            }
+
+            GraphHostStateBinding graph_binding(rt->orchestrator, graph_state.get());
+            graph_host_set_eager_upload(&GraphPodH2d::eager_cb, &graph_h2d);
+
+            {
+                STRACE("simpler_run.bind.host_orch.entry");
+                const auto *entry_points = reinterpret_cast<const HostOrchEntryPoints *>(host_orch_func_ptr);
+                rt_scope_begin(rt);
+                entry_points->entry(orch_l2);
+                rt_scope_end(rt);
+                rt_orchestration_done(rt);
+
+                total_tasks = pto2_sm_layout::ring_current_task_index_addr(host_sm)->load(std::memory_order_acquire);
+            }
+            graph_host_set_eager_upload(nullptr, nullptr);
+            // graph_state outlives this scope; GraphHostStateBinding clears orch ptr.
+        }
 
-    const int32_t total_tasks = pto2_sm_layout::ring_current_task_index_addr(host_sm)->load(std::memory_order_acquire);
-    if (!upload_graph_submissions(runtime, api, *graph_state)) return -1;
+        {
+            STRACE("simpler_run.bind.h2d_graph");
+            if (!upload_leftover_graph_submissions(graph_h2d, *graph_state)) {
+                return -1;
+            }
+        }
+    }
 
     // total_tasks sizes the bounded per-segment H2D copies below; a value outside
     // [0, task_window] would make those copies read/write out of bounds.
@@ -751,42 +839,50 @@ int32_t run_host_orchestration(
         return -1;
     }
 
-    // Relocate the host-DDR cross-task pointers to their final DEVICE addresses
-    // on the host, before the SM and arena leave for the device. Pointers into
-    // the SM shift by sm_delta; pointers into the arena (fanout adjacency, wiring
-    // queue) shift by arena_delta. After this both the SM and arena carry device
-    // addresses, so the device boots scheduler-only.
-    const int64_t sm_delta = static_cast<int64_t>(reinterpret_cast<uint64_t>(device_sm)) -
-                             static_cast<int64_t>(reinterpret_cast<uint64_t>(host_sm));
-    const int64_t arena_delta = static_cast<int64_t>(reinterpret_cast<uint64_t>(device_arena)) -
-                                static_cast<int64_t>(reinterpret_cast<uint64_t>(host_arena.base()));
-    if (!relocate_host_orch_image(
-            host_sm_handle, reinterpret_cast<uint64_t>(host_sm), sm_size, sm_delta,
-            reinterpret_cast<uint64_t>(host_arena.base()), layout.arena_size, arena_delta
-        )) {
-        LOG_ERROR("host-orch: relocation failed; refusing to H2D an image with unrelocated host pointers");
-        return -1;
+    {
+        STRACE("simpler_run.bind.relocate");
+        // Relocate the host-DDR cross-task pointers to their final DEVICE addresses
+        // on the host, before the SM and arena leave for the device. Pointers into
+        // the SM shift by sm_delta; pointers into the arena (fanout adjacency, wiring
+        // queue) shift by arena_delta. After this both the SM and arena carry device
+        // addresses, so the device boots scheduler-only.
+        const int64_t sm_delta = static_cast<int64_t>(reinterpret_cast<uint64_t>(device_sm)) -
+                                 static_cast<int64_t>(reinterpret_cast<uint64_t>(host_sm));
+        const int64_t arena_delta = static_cast<int64_t>(reinterpret_cast<uint64_t>(device_arena)) -
+                                    static_cast<int64_t>(reinterpret_cast<uint64_t>(host_arena.base()));
+        if (!relocate_host_orch_image(
+                host_sm_handle, reinterpret_cast<uint64_t>(host_sm), sm_size, sm_delta,
+                reinterpret_cast<uint64_t>(host_arena.base()), layout.arena_size, arena_delta
+            )) {
+            LOG_ERROR("host-orch: relocation failed; refusing to H2D an image with unrelocated host pointers");
+            return -1;
+        }
     }
 
-    // Ship only the live prefix of each segment: the device reads no slot past
-    // total_tasks, so upload header + descriptors[0,N), payloads[0,N),
-    // slot_states[0,N) and completion_flags[0,N) — never the ring-sized tails.
-    // header + descriptors[0,N) are contiguous, so that is a single copy.
-    const uint64_t nt = static_cast<uint64_t>(total_tasks);
-    const uint64_t hdr_desc_bytes = sm_segs.descriptors + nt * sizeof(PTO2TaskDescriptor);
-    char *host_base = static_cast<char *>(host_sm);
-    char *dev_base = static_cast<char *>(device_sm);
-    if (api->copy_to_device(dev_base, host_base, hdr_desc_bytes) != 0 ||
-        api->copy_to_device(dev_base + sm_segs.payloads, host_base + sm_segs.payloads, nt * sizeof(PTO2TaskPayload)) !=
-            0 ||
-        api->copy_to_device(
-            dev_base + sm_segs.slot_states, host_base + sm_segs.slot_states, nt * sizeof(PTO2TaskSlotState)
-        ) != 0 ||
-        api->copy_to_device(
-            dev_base + sm_segs.completion_flags, host_base + sm_segs.completion_flags, nt * sizeof(std::atomic<uint8_t>)
-        ) != 0) {
-        LOG_ERROR("host-orch: H2D of populated SM failed");
-        return -1;
+    {
+        STRACE("simpler_run.bind.h2d_sm");
+        // Ship only the live prefix of each segment: the device reads no slot past
+        // total_tasks, so upload header + descriptors[0,N), payloads[0,N),
+        // slot_states[0,N) and completion_flags[0,N) — never the ring-sized tails.
+        // header + descriptors[0,N) are contiguous, so that is a single copy.
+        const uint64_t nt = static_cast<uint64_t>(total_tasks);
+        const uint64_t hdr_desc_bytes = sm_segs.descriptors + nt * sizeof(PTO2TaskDescriptor);
+        char *host_base = static_cast<char *>(host_sm);
+        char *dev_base = static_cast<char *>(device_sm);
+        if (api->copy_to_device(dev_base, host_base, hdr_desc_bytes) != 0 ||
+            api->copy_to_device(
+                dev_base + sm_segs.payloads, host_base + sm_segs.payloads, nt * sizeof(PTO2TaskPayload)
+            ) != 0 ||
+            api->copy_to_device(
+                dev_base + sm_segs.slot_states, host_base + sm_segs.slot_states, nt * sizeof(PTO2TaskSlotState)
+            ) != 0 ||
+            api->copy_to_device(
+                dev_base + sm_segs.completion_flags, host_base + sm_segs.completion_flags,
+                nt * sizeof(std::atomic<uint8_t>)
+            ) != 0) {
+            LOG_ERROR("host-orch: H2D of populated SM failed");
+            return -1;
+        }
     }
     return total_tasks;
 }
@@ -1051,63 +1147,65 @@ extern "C" int bind_callable_to_runtime_impl(
 
     int64_t t_prebuilt_start = _now_ms();
     DeviceArena host_arena;
-    PTO2RuntimeArenaLayout layout = runtime_reserve_layout(host_arena, eff_task_window_sizes, eff_heap_sizes);
-    if (host_arena.commit(DeviceArena::kDefaultBaseAlign) == nullptr) {
-        LOG_ERROR("Failed to commit host arena for prebuilt runtime image");
-        return -1;
-    }
+    PTO2RuntimeArenaLayout layout{};
+    void *gm_heap = nullptr;
+    void *sm_ptr = nullptr;
+    void *runtime_arena_dev = nullptr;
+    PTO2Runtime *rt = nullptr;
+    {
+        STRACE("simpler_run.bind.prebuilt");
+        layout = runtime_reserve_layout(host_arena, eff_task_window_sizes, eff_heap_sizes);
+        if (host_arena.commit(DeviceArena::kDefaultBaseAlign) == nullptr) {
+            LOG_ERROR("Failed to commit host arena for prebuilt runtime image");
+            return -1;
+        }
 
-    int64_t t_setup_start = _now_ms();
-    if (api->setup_static_arena(total_heap_size, sm_size, layout.arena_size) != 0) {
-        LOG_ERROR("Failed to setup pooled static arena");
-        return -1;
-    }
-    int64_t t_setup_end = _now_ms();
+        if (api->setup_static_arena(total_heap_size, sm_size, layout.arena_size) != 0) {
+            LOG_ERROR("Failed to setup pooled static arena");
+            return -1;
+        }
 
-    int64_t t_heap_start = _now_ms();
-    void *gm_heap = api->acquire_pooled_gm_heap();
-    int64_t t_heap_end = _now_ms();
-    if (gm_heap == nullptr) {
-        LOG_ERROR("Failed to acquire pooled GM heap");
-        return -1;
-    }
-    runtime->set_gm_heap(gm_heap);
+        gm_heap = api->acquire_pooled_gm_heap();
+        if (gm_heap == nullptr) {
+            LOG_ERROR("Failed to acquire pooled GM heap");
+            return -1;
+        }
+        runtime->set_gm_heap(gm_heap);
 
-    int64_t t_sm_start = _now_ms();
-    void *sm_ptr = api->acquire_pooled_gm_sm();
-    int64_t t_sm_end = _now_ms();
-    if (sm_ptr == nullptr) {
-        LOG_ERROR("Failed to acquire pooled PTO2 shared memory");
-        return -1;
-    }
-    runtime->set_gm_sm_ptr(sm_ptr);
+        sm_ptr = api->acquire_pooled_gm_sm();
+        if (sm_ptr == nullptr) {
+            LOG_ERROR("Failed to acquire pooled PTO2 shared memory");
+            return -1;
+        }
+        runtime->set_gm_sm_ptr(sm_ptr);
 
-    void *runtime_arena_dev = api->acquire_pooled_runtime_arena();
-    if (runtime_arena_dev == nullptr) {
-        LOG_ERROR("Failed to acquire pooled runtime arena");
-        return -1;
-    }
+        runtime_arena_dev = api->acquire_pooled_runtime_arena();
+        if (runtime_arena_dev == nullptr) {
+            LOG_ERROR("Failed to acquire pooled runtime arena");
+            return -1;
+        }
 
-    // Set up orchestration state (consumed by the host orchestrator below)
-    runtime->set_orch_args(device_args);
-
-    // -------------------------------------------------------------------------
-    // Build the prebuilt runtime-arena image on host.
-    //
-    // We pre-compute every byte the AICPU's runtime arena would otherwise have
-    // to write at boot: layout offsets, sub-structure init data, and pointers
-    // back to the SM / GM heap. Then we rtMemcpy the image into the pooled
-    // runtime-arena region that DeviceRunner keeps alive across runs. AICPU
-    // boot becomes attach + wire (cheap pointer fixup) + sm_handle->init (SM
-    // reset) + a handful of device-only field fixups.
-    // -------------------------------------------------------------------------
-    PTO2Runtime *rt =
-        runtime_init_data_from_layout(host_arena, layout, PTO2_MODE_EXECUTE, sm_ptr, sm_size, gm_heap, eff_heap_sizes);
-    if (rt == nullptr) {
-        LOG_ERROR("runtime_init_data_from_layout failed");
-        return -1;
+        // Set up orchestration state (consumed by the host orchestrator below)
+        runtime->set_orch_args(device_args);
+
+        // -------------------------------------------------------------------------
+        // Build the prebuilt runtime-arena image on host.
+        //
+        // We pre-compute every byte the AICPU's runtime arena would otherwise have
+        // to write at boot: layout offsets, sub-structure init data, and pointers
+        // back to the SM / GM heap. Then we rtMemcpy the image into the pooled
+        // runtime-arena region that DeviceRunner keeps alive across runs. AICPU
+        // boot becomes attach + wire (cheap pointer fixup) + sm_handle->init (SM
+        // reset) + a handful of device-only field fixups.
+        // -------------------------------------------------------------------------
+        rt =
+            runtime_init_data_from_layout(host_arena, layout, PTO2_MODE_EXECUTE, sm_ptr, sm_size, gm_heap, eff_heap_sizes);
+        if (rt == nullptr) {
+            LOG_ERROR("runtime_init_data_from_layout failed");
+            return -1;
+        }
+        runtime_wire_arena_pointers(host_arena, layout, rt);
     }
-    runtime_wire_arena_pointers(host_arena, layout, rt);
 
     if (host_orch_func_ptr == nullptr) {
         LOG_ERROR("host-orch: orchestration entry points were not resolved");
@@ -1146,19 +1244,24 @@ extern "C" int bind_callable_to_runtime_impl(
     // reservations (runtime_reserve_layout order: sm_handle -> orch -> sched); the
     // ready queues ship in full because graph execution expands a GRAPH task into
     // on-device nodes that push past the host task count.
-    const auto &sq = layout.sched;
-    const size_t orch_start = layout.orch.off_fanin_seen_epoch;
-    const size_t orch_end = sq.off_ready_queue_slots[0];
-    always_assert(orch_start <= orch_end);
-    char *arena_host = static_cast<char *>(host_arena.base());
-    char *arena_dev = static_cast<char *>(runtime_arena_dev);
-    int rc_upload = api->copy_to_device(arena_dev, arena_host, orch_start);
-    if (rc_upload == 0) {
-        rc_upload = api->copy_to_device(arena_dev + orch_end, arena_host + orch_end, layout.arena_size - orch_end);
-    }
-    if (rc_upload != 0) {
-        LOG_ERROR("Failed to rtMemcpy prebuilt runtime arena to device (rc=%d)", rc_upload);
-        return -1;
+    {
+        STRACE("simpler_run.bind.h2d_arena");
+        const auto &sq = layout.sched;
+        const size_t orch_start = layout.orch.off_fanin_seen_epoch;
+        const size_t orch_end = sq.off_ready_queue_slots[0];
+        always_assert(orch_start <= orch_end);
+        char *arena_host = static_cast<char *>(host_arena.base());
+        char *arena_dev = static_cast<char *>(runtime_arena_dev);
+        // Prefix fingerprint-skip was measured: orch_start hashing added cost and
+        // the ready-queue suffix must always ship, so net Gate win was ~0 / negative.
+        int rc_upload = api->copy_to_device(arena_dev, arena_host, orch_start);
+        if (rc_upload == 0) {
+            rc_upload = api->copy_to_device(arena_dev + orch_end, arena_host + orch_end, layout.arena_size - orch_end);
+        }
+        if (rc_upload != 0) {
+            LOG_ERROR("Failed to rtMemcpy prebuilt runtime arena to device (rc=%d)", rc_upload);
+            return -1;
+        }
     }
     runtime->set_prebuilt_arena(runtime_arena_dev, layout.off_runtime);
     int64_t t_prebuilt_end = _now_ms();
@@ -1167,9 +1270,6 @@ extern "C" int bind_callable_to_runtime_impl(
 
     int64_t t_total_end = _now_ms();
     LOG_INFO("TIMING: args_malloc_copy = %" PRId64 "ms", t_args_end - t_args_start);
-    LOG_INFO("TIMING: static_arena_setup = %" PRId64 "ms", t_setup_end - t_setup_start);
-    LOG_INFO("TIMING: gm_heap_acquire = %" PRId64 "ms", t_heap_end - t_heap_start);
-    LOG_INFO("TIMING: shared_mem_acquire = %" PRId64 "ms", t_sm_end - t_sm_start);
     LOG_INFO("TIMING: prebuilt_runtime_arena = %" PRId64 "ms", t_prebuilt_end - t_prebuilt_start);
     LOG_INFO("TIMING: total_init_runtime_impl = %" PRId64 "ms", t_total_end - t_total_start);
 
diff --git a/src/a2a3/runtime/host_build_graph/runtime/orchestrator_core/pto_orchestrator.cpp b/src/a2a3/runtime/host_build_graph/runtime/orchestrator_core/pto_orchestrator.cpp
index 54fc335dab..3ca783b04f 100644
--- a/src/a2a3/runtime/host_build_graph/runtime/orchestrator_core/pto_orchestrator.cpp
+++ b/src/a2a3/runtime/host_build_graph/runtime/orchestrator_core/pto_orchestrator.cpp
@@ -26,6 +26,7 @@
 #include <stdarg.h>
 #include <stdlib.h>
 #include <string.h>
+#include <cstring>
 #include <time.h>
 
 #include <algorithm>
@@ -326,6 +327,9 @@ struct GraphRecording {
 struct GraphPendingUpload {
     PTO2TaskSlotState *outer_slot{nullptr};
     std::vector<std::byte> image;
+    std::byte *pinned{nullptr};
+    size_t bytes{0};
+    bool h2d_done{false};
 };
 
 struct GraphHostState {
@@ -334,6 +338,40 @@ struct GraphHostState {
     std::vector<GraphPendingUpload> pending_uploads;
 };
 
+static GraphHostEagerUploadFn g_eager_upload_fn = nullptr;
+static void *g_eager_upload_ctx = nullptr;
+
+namespace {
+std::byte *g_pin_base = nullptr;
+size_t g_pin_cap = 0;
+size_t g_pin_used = 0;
+constexpr size_t kPinnedBumpAlign = 64;
+
+std::byte *graph_host_pinned_bump(size_t bytes) {
+    if (g_pin_base == nullptr || bytes == 0) return nullptr;
+    const size_t off = (g_pin_used + kPinnedBumpAlign - 1) & ~(kPinnedBumpAlign - 1);
+    if (off + bytes > g_pin_cap) return nullptr;
+    g_pin_used = off + bytes;
+    return g_pin_base + off;
+}
+}  // namespace
+
+void graph_host_set_pinned_arena(std::byte *base, size_t cap) {
+    g_pin_base = base;
+    g_pin_cap = cap;
+    g_pin_used = 0;
+}
+
+void graph_host_clear_pinned_arena() {
+    g_pin_base = nullptr;
+    g_pin_cap = 0;
+    g_pin_used = 0;
+}
+
+std::byte *graph_host_pinned_base() { return g_pin_base; }
+
+size_t graph_host_pinned_used() { return g_pin_used; }
+
 namespace {
 
 GraphHostState *graph_state_from(PTO2OrchestratorState *orch) {
@@ -671,10 +709,27 @@ size_t graph_host_upload_count(const GraphHostState &state) { return state.pendi
 std::optional<GraphHostUpload> graph_host_upload(GraphHostState &state, size_t index) {
     if (index >= state.pending_uploads.size()) return std::nullopt;
     GraphPendingUpload &upload = state.pending_uploads[index];
-    if (upload.outer_slot == nullptr || upload.image.empty()) return std::nullopt;
+    if (upload.outer_slot == nullptr) return std::nullopt;
+    if (upload.pinned != nullptr && upload.bytes > 0) {
+        return GraphHostUpload{upload.outer_slot, upload.pinned, upload.bytes};
+    }
+    if (upload.image.empty()) return std::nullopt;
     return GraphHostUpload{upload.outer_slot, upload.image.data(), upload.image.size()};
 }
 
+void graph_host_set_eager_upload(GraphHostEagerUploadFn fn, void *ctx) {
+    g_eager_upload_fn = fn;
+    g_eager_upload_ctx = ctx;
+}
+
+bool graph_host_upload_h2d_done(const GraphHostState &state, size_t index) {
+    return index < state.pending_uploads.size() && state.pending_uploads[index].h2d_done;
+}
+
+void graph_host_mark_upload_h2d_done(GraphHostState &state, size_t index) {
+    if (index < state.pending_uploads.size()) state.pending_uploads[index].h2d_done = true;
+}
+
 static uint32_t next_fanin_seen_epoch(PTO2OrchestratorState *orch) {
     uint32_t next = orch->fanin_seen_current_epoch + 1;
     if (next == 0) {
@@ -1385,49 +1440,87 @@ void graph_reset_outer_payload(PTO2TaskPayload &payload) {
     payload.early_sync_drain_state.store(PTO2_EARLY_SYNC_DRAIN_NONE, std::memory_order_relaxed);
 }
 
-bool graph_build_submission_image(
-    const std::vector<std::byte> &definition_image, const CoreTaskArgs &args, std::vector<std::byte> *submission_image
+static bool graph_submission_layout(
+    const std::vector<std::byte> &definition_image, const CoreTaskArgs &args, size_t *total_bytes,
+    size_t *definition_offset, size_t *tensors_offset, size_t *scalars_offset, size_t *scalar_bytes
 ) {
-    if (submission_image == nullptr || graph_definition(definition_image) == nullptr) return false;
-    const size_t definition_offset = PTO2_ALIGN_UP(sizeof(GraphSubmission), alignof(GraphDefinition));
-    const size_t tensors_offset = PTO2_ALIGN_UP(definition_offset + definition_image.size(), alignof(GraphTensor));
+    if (total_bytes == nullptr || definition_offset == nullptr || tensors_offset == nullptr ||
+        scalars_offset == nullptr || scalar_bytes == nullptr || graph_definition(definition_image) == nullptr) {
+        return false;
+    }
+    *definition_offset = PTO2_ALIGN_UP(sizeof(GraphSubmission), alignof(GraphDefinition));
+    *tensors_offset = PTO2_ALIGN_UP(*definition_offset + definition_image.size(), alignof(GraphTensor));
     const size_t tensor_bytes = static_cast<size_t>(args.tensor_count()) * sizeof(GraphTensor);
-    if (definition_offset > UINT32_MAX || tensors_offset > UINT32_MAX || tensors_offset > UINT32_MAX - tensor_bytes) {
+    if (*definition_offset > UINT32_MAX || *tensors_offset > UINT32_MAX ||
+        *tensors_offset > UINT32_MAX - tensor_bytes) {
         return false;
     }
-    const size_t tensors_end = tensors_offset + tensor_bytes;
-    const size_t scalar_bytes = static_cast<size_t>(args.scalar_count()) * sizeof(uint64_t);
-    const size_t scalars_offset = args.scalar_count() == 0 ? 0 : PTO2_ALIGN_UP(tensors_end, alignof(uint64_t));
-    const size_t total_bytes = args.scalar_count() == 0 ? tensors_end : scalars_offset + scalar_bytes;
-    if ((args.scalar_count() != 0 && (scalars_offset > UINT32_MAX || scalars_offset > UINT32_MAX - scalar_bytes)) ||
-        total_bytes > UINT32_MAX) {
+    const size_t tensors_end = *tensors_offset + tensor_bytes;
+    *scalar_bytes = static_cast<size_t>(args.scalar_count()) * sizeof(uint64_t);
+    *scalars_offset = args.scalar_count() == 0 ? 0 : PTO2_ALIGN_UP(tensors_end, alignof(uint64_t));
+    *total_bytes = args.scalar_count() == 0 ? tensors_end : *scalars_offset + *scalar_bytes;
+    if ((args.scalar_count() != 0 && (*scalars_offset > UINT32_MAX || *scalars_offset > UINT32_MAX - *scalar_bytes)) ||
+        *total_bytes > UINT32_MAX) {
         return false;
     }
-    submission_image->assign(total_bytes, std::byte{0});
-    std::memcpy(submission_image->data() + definition_offset, definition_image.data(), definition_image.size());
-    auto *tensors = reinterpret_cast<GraphTensor *>(submission_image->data() + tensors_offset);
+    return true;
+}
+
+static bool graph_fill_submission_image(
+    const std::vector<std::byte> &definition_image, const CoreTaskArgs &args, std::byte *dst, size_t dst_bytes
+) {
+    size_t total_bytes = 0;
+    size_t definition_offset = 0;
+    size_t tensors_offset = 0;
+    size_t scalars_offset = 0;
+    size_t scalar_bytes = 0;
+    if (dst == nullptr ||
+        !graph_submission_layout(
+            definition_image, args, &total_bytes, &definition_offset, &tensors_offset, &scalars_offset, &scalar_bytes
+        ) ||
+        dst_bytes < total_bytes) {
+        return false;
+    }
+    std::memset(dst, 0, total_bytes);
+    std::memcpy(dst + definition_offset, definition_image.data(), definition_image.size());
+    auto *tensors = reinterpret_cast<GraphTensor *>(dst + tensors_offset);
     for (int32_t i = 0; i < args.tensor_count(); ++i)
         tensors[i] = graph_tensor_pack(args.tensor(i).ref());
     if (args.scalar_count() != 0) {
-        std::memcpy(
-            submission_image->data() + scalars_offset, args.scalar_data(),
-            static_cast<size_t>(args.scalar_count()) * sizeof(uint64_t)
-        );
+        std::memcpy(dst + scalars_offset, args.scalar_data(), scalar_bytes);
     }
 
     const GraphDefinition &definition = *graph_definition(definition_image);
     GraphSubmission submission{};
     submission.graph_key = definition.full_key;
-    submission.total_bytes = static_cast<uint32_t>(submission_image->size());
+    submission.total_bytes = static_cast<uint32_t>(total_bytes);
     submission.definition_offset = static_cast<uint32_t>(definition_offset);
     submission.tensors_offset = static_cast<uint32_t>(tensors_offset);
     submission.tensor_count = static_cast<uint32_t>(args.tensor_count());
     submission.scalars_offset = static_cast<uint32_t>(scalars_offset);
     submission.scalar_count = static_cast<uint32_t>(args.scalar_count());
-    std::memcpy(submission_image->data(), &submission, sizeof(submission));
+    std::memcpy(dst, &submission, sizeof(submission));
     return true;
 }
 
+bool graph_build_submission_image(
+    const std::vector<std::byte> &definition_image, const CoreTaskArgs &args, std::vector<std::byte> *submission_image
+) {
+    size_t total_bytes = 0;
+    size_t definition_offset = 0;
+    size_t tensors_offset = 0;
+    size_t scalars_offset = 0;
+    size_t scalar_bytes = 0;
+    if (submission_image == nullptr ||
+        !graph_submission_layout(
+            definition_image, args, &total_bytes, &definition_offset, &tensors_offset, &scalars_offset, &scalar_bytes
+        )) {
+        return false;
+    }
+    submission_image->assign(total_bytes, std::byte{0});
+    return graph_fill_submission_image(definition_image, args, submission_image->data(), submission_image->size());
+}
+
 bool graph_submit_definition(
     PTO2OrchestratorState *orch, GraphHostState *state, const std::vector<std::byte> &definition_image,
     const CoreTaskArgs &args, PTO2TaskId *submitted_id
@@ -1445,7 +1538,30 @@ bool graph_submit_definition(
     }
 
     GraphPendingUpload pending;
-    if (!graph_build_submission_image(definition_image, args, &pending.image)) return false;
+    size_t total_bytes = 0;
+    size_t definition_offset = 0;
+    size_t tensors_offset = 0;
+    size_t scalars_offset = 0;
+    size_t scalar_bytes = 0;
+    if (!graph_submission_layout(
+            definition_image, args, &total_bytes, &definition_offset, &tensors_offset, &scalars_offset, &scalar_bytes
+        )) {
+        return false;
+    }
+    (void)definition_offset;
+    (void)tensors_offset;
+    (void)scalars_offset;
+    (void)scalar_bytes;
+    std::byte *pinned = graph_host_pinned_bump(total_bytes);
+    if (pinned != nullptr) {
+        if (!graph_fill_submission_image(definition_image, args, pinned, total_bytes)) return false;
+        pending.pinned = pinned;
+        pending.bytes = total_bytes;
+    } else if (!graph_build_submission_image(definition_image, args, &pending.image)) {
+        return false;
+    } else {
+        pending.bytes = pending.image.size();
+    }
 
     DepInputs boundary_inputs{
         args.tensor_count(), args.tensor_data(), args.tag_data(), 0, nullptr,
@@ -1496,6 +1612,10 @@ bool graph_submit_definition(
 
     pending.outer_slot = &slot;
     state->pending_uploads.push_back(std::move(pending));
+    if (g_eager_upload_fn != nullptr) {
+        const size_t index = state->pending_uploads.size() - 1;
+        if (!g_eager_upload_fn(g_eager_upload_ctx, *state, index)) return false;
+    }
     if (submitted_id != nullptr) *submitted_id = task_id;
 #if SIMPLER_DFX
     orch->tasks_submitted++;
diff --git a/src/common/host_build_graph/graph_host_state.h b/src/common/host_build_graph/graph_host_state.h
index 4d869b1c4d..ea586340e3 100644
--- a/src/common/host_build_graph/graph_host_state.h
+++ b/src/common/host_build_graph/graph_host_state.h
@@ -35,3 +35,18 @@ struct GraphHostUpload {
 GraphHostStatePtr make_graph_host_state();
 size_t graph_host_upload_count(const GraphHostState &state);
 std::optional<GraphHostUpload> graph_host_upload(GraphHostState &state, size_t index);
+
+// Optional eager H2D hook: invoked right after each Graph POD image is appended
+// during orch entry (compute-one-layer, copy-that-layer).
+using GraphHostEagerUploadFn = bool (*)(void *ctx, GraphHostState &state, size_t index);
+void graph_host_set_eager_upload(GraphHostEagerUploadFn fn, void *ctx);
+bool graph_host_upload_h2d_done(const GraphHostState &state, size_t index);
+void graph_host_mark_upload_h2d_done(GraphHostState &state, size_t index);
+
+// Optional pinned bump arena for Graph POD images. Set by host runtime before
+// orch entry so graph_submit_definition can write PODs in place. Not set →
+// fallback std::vector images.
+void graph_host_set_pinned_arena(std::byte *base, size_t cap);
+void graph_host_clear_pinned_arena();
+std::byte *graph_host_pinned_base();
+size_t graph_host_pinned_used();
diff --git a/tests/ut/py/test_strace_timing.py b/tests/ut/py/test_strace_timing.py
index 5d1e639274..a5590de3c9 100644
--- a/tests/ut/py/test_strace_timing.py
+++ b/tests/ut/py/test_strace_timing.py
@@ -462,3 +462,58 @@ def test_rounds_table_omits_tmr_only_columns_when_only_host_and_device_exist():
     assert "Sched (us)" not in rendered
     assert "Avg Host: 110.0 us" in rendered
     assert "Avg Device: 22.0 us [2/2]" in rendered
+
+
+def test_rounds_table_counts_eager_h2d_as_h2d_graph_not_host_orch():
+    """Per-layer H2D nested in host_orch.entry is Gate-accounted as H2dGraph."""
+    from simpler_setup.tools.strace_timing import _round_metrics
+
+    lines = [
+        _span_record(pid=1, tid=1, inv=1, name="simpler_run", ts=0, dur=2_000_000),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.host_orch", ts=1_000, dur=1_000_000, depth=3
+        ),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_graph", ts=10_000, dur=100_000, depth=5
+        ),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_graph", ts=200_000, dur=200_000, depth=5
+        ),
+        # Leftover sync after orch: H2dGraph, not subtracted from HostOrch.
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_graph", ts=1_100_000, dur=50_000, depth=3
+        ),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_sm", ts=1_160_000, dur=30_000, depth=2
+        ),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_arena", ts=1_200_000, dur=20_000, depth=2
+        ),
+    ]
+    row = _round_metrics(group_invocations(parse_spans(lines))[0])
+    # Host Device Effective Orch Sched Args Prebuilt HostOrch Relocate H2dImage H2dGraph H2dSm H2dArena
+    assert row[7] == 700.0
+    assert row[9] == 400.0
+    assert row[10] == 350.0
+    assert row[11] == 30.0
+    assert row[12] == 20.0
+
+
+def test_rounds_table_does_not_double_count_h2d_graph_parent_and_children():
+    from simpler_setup.tools.strace_timing import _round_metrics
+
+    lines = [
+        _span_record(pid=1, tid=1, inv=1, name="simpler_run", ts=0, dur=1_000_000),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_graph", ts=10_000, dur=500_000, depth=3
+        ),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_graph", ts=20_000, dur=100_000, depth=4
+        ),
+        _span_record(
+            pid=1, tid=1, inv=1, name="simpler_run.bind.h2d_graph", ts=200_000, dur=100_000, depth=4
+        ),
+    ]
+    row = _round_metrics(group_invocations(parse_spans(lines))[0])
+    assert row[10] == 500.0
+    assert row[9] == 500.0