under test, not sure no errors

core/distributed_runtime/layerwise_split_engine_ext.cpp

@@ -0,0 +1,70 @@
+/* Copyright 2026 The xLLM Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://github.com/jd-opensource/xllm/blob/main/LICENSE
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Commit: 494f293b5629 · feat · PR #2260  (adapted for Iluvatar BI-V100)
+// Engine-level plumbing:  Both llm_engine and speculative_engine propagate
+// the layerwise layout to workers during initialisation.
+//
+// In the upstream xLLM, this would be edits to llm_engine.cpp (+18 lines)
+// and speculative_engine.cpp (+12 lines).  Here we isolate them in a
+// self-contained compilation unit that the engines call into.
+
+#include "distributed_runtime/layerwise_split_engine_ext.h"
+
+#include <glog/logging.h>
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "common/global_flags.h"
+#include "framework/kv_cache/layerwise_split_layout.h"
+#include "framework/parallel_state/mapping_ilu.h"
+
+// The flag is declared in parallel_config.cpp / global_flags.h (sub-task 7).
+DECLARE_bool(enable_layerwise_split);
+
+namespace xllm {
+
+std::optional<LayerwiseSplitLayout> maybe_compute_layerwise_layout(
+    int64_t num_layers,
+    const std::vector<int64_t>& per_layer_kv_heads,
+    int32_t world_size) {
+  if (!FLAGS_enable_layerwise_split) {
+    return std::nullopt;
+  }
+
+  LOG(INFO) << "[LayerwiseSplit] Computing layout for " << num_layers
+            << " layers, world_size=" << world_size;
+
+#if defined(USE_ILU)
+  // Iluvatar BI-V100: verified 4-card flat PIX topology (ixsmi topo -m).
+  // All pairs connected via single PCIe bridge, equal bandwidth.
+  return compute_ilu_layerwise_layout(
+      num_layers, per_layer_kv_heads, world_size,
+      IluTopoKind::kFlatPIX);
+#elif defined(USE_NPU)
+  // Ascend NPU: would use mapping_npu.cpp (not this adaptation).
+  LOG(WARNING) << "[LayerwiseSplit] NPU path not compiled in this build.";
+  return std::nullopt;
+#else
+  // Generic CUDA fallback: flat topology (all ranks equidistant).
+  return compute_ilu_layerwise_layout(
+      num_layers, per_layer_kv_heads, world_size,
+      IluTopoKind::kFlatPIX);
+#endif
+}
+
+}  // namespace xllm

core/distributed_runtime/layerwise_split_engine_ext.h

@@ -0,0 +1,34 @@
+/* Copyright 2026 The xLLM Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://github.com/jd-opensource/xllm/blob/main/LICENSE
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+#include "framework/kv_cache/layerwise_split_layout.h"
+
+namespace xllm {
+
+/// Called by llm_engine / speculative_engine at startup.
+/// Returns a LayerwiseSplitLayout if the feature is enabled, otherwise
+/// std::nullopt (fallback to uniform allocation).
+std::optional<LayerwiseSplitLayout> maybe_compute_layerwise_layout(
+    int64_t num_layers,
+    const std::vector<int64_t>& per_layer_kv_heads,
+    int32_t world_size);
+
+}  // namespace xllm

core/distributed_runtime/layerwise_split_master.cpp

@@ -0,0 +1,77 @@
+/* Copyright 2026 The xLLM Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://github.com/jd-opensource/xllm/blob/main/LICENSE
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// Commit: 494f293b5629 · feat · PR #2260  (adapted for Iluvatar BI-V100)
+// Master-side orchestration: at startup the master reads model_args to
+// extract per-layer KV head counts, computes the layout, and stores it
+// for distribution to workers.
+
+#include "distributed_runtime/layerwise_split_master.h"
+
+#include <glog/logging.h>
+
+#include <optional>
+#include <vector>
+
+#include "distributed_runtime/layerwise_split_engine_ext.h"
+#include "framework/kv_cache/kv_cache_estimation_layerwise.h"
+#include "framework/kv_cache/layerwise_split_layout.h"
+
+DECLARE_bool(enable_layerwise_split);
+
+namespace xllm {
+
+std::optional<LayerwiseSplitLayout> master_compute_layerwise_layout(
+    int64_t num_layers,
+    int64_t dense_kv_heads,
+    int64_t moe_kv_heads,
+    int64_t first_moe_layer,
+    int32_t world_size,
+    int64_t n_blocks,
+    int64_t block_size,
+    int64_t head_dim,
+    int64_t max_tokens,
+    int dtype_enum) {
+  if (!FLAGS_enable_layerwise_split) {
+    LOG(INFO) << "[LayerwiseSplit] Disabled; using uniform KV sharding.";
+    return std::nullopt;
+  }
+
+  // Build per-layer KV head count vector.
+  // Layers [0, first_moe_layer) are dense attention; the rest are MoE.
+  std::vector<int64_t> per_layer_heads(num_layers);
+  for (int64_t i = 0; i < num_layers; ++i) {
+    per_layer_heads[i] = (i < first_moe_layer) ? dense_kv_heads : moe_kv_heads;
+  }
+
+  auto layout = maybe_compute_layerwise_layout(
+      num_layers, per_layer_heads, world_size);
+
+  if (layout.has_value()) {
+    // Run estimation for logging / capacity planning.
+    auto est = estimate_layerwise_kv_memory(
+        *layout, n_blocks, block_size, head_dim, max_tokens,
+        dtype_enum, world_size);
+
+    LOG(INFO) << "[LayerwiseSplit] Peak per-rank KV: "
+              << (est.peak_per_rank_bytes >> 20) << " MiB  (uniform would be "
+              << (est.uniform_per_rank_bytes >> 20) << " MiB, saving "
+              << est.savings_vs_uniform_pct << "%)";
+  }
+
+  return layout;
+}
+
+}  // namespace xllm

core/distributed_runtime/layerwise_split_master.h

@@ -0,0 +1,40 @@
+/* Copyright 2026 The xLLM Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    https://github.com/jd-opensource/xllm/blob/main/LICENSE
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#pragma once
+
+#include <cstdint>
+#include <optional>
+
+#include "framework/kv_cache/layerwise_split_layout.h"
+
+namespace xllm {
+
+/// Master-side entry point: compute and log the layerwise layout.
+/// |first_moe_layer|: index of the first MoE layer (layers before it are
+///                     dense attention with |dense_kv_heads|).
+std::optional<LayerwiseSplitLayout> master_compute_layerwise_layout(
+    int64_t num_layers,
+    int64_t dense_kv_heads,
+    int64_t moe_kv_heads,
+    int64_t first_moe_layer,
+    int32_t world_size,
+    int64_t n_blocks,
+    int64_t block_size,
+    int64_t head_dim,
+    int64_t max_tokens,
+    int dtype_enum);
+
+}  // namespace xllm