bugfix: correct DSpark block_size sourcing and native SWA index build.

Three DeepSeek-V4 DSpark defects surfaced by the test suite:

- The model loader copied dspark_block_size into the shared target args,
  arming non-causal DSpark attention on the target model. Leave it unset in
  the loader; the draft worker now defaults it from the checkpoint's
  block_size (overridable by --num_speculative_tokens) via read_block_size().

- build_dspark_swa_indices used true division for the block-column index,
  yielding a float tensor that torch::gather rejects. Use torch::floor_divide.

- The WrapAroundRingBuffer test hard-coded start_pos = kv - window, dropping
  the q_len term; correct the expected slots to (kv - q_len) - window.

Author: ustcfy

tests/core/layers/npu_torch/deepseek_v4_indexer_tests.cpp

@@ -228,9 +228,9 @@ TEST_F(DeepseekV4IndexerTest, DSparkNativeSwaIndicesAreSharedByQueryRows) {
 
 TEST_F(DeepseekV4IndexerTest, DSparkNativeSwaIndicesWrapAroundRingBuffer) {
   // Two-block ring buffer with kv_len=10 forces the SWA window to span both
-  // ring entries and to wrap. Positions 6..9 fall into block_column 1, and
-  // position 8..9 wrap back to block_column 0 once the ring rotates once
-  // (positions / block_size = {1,1,2,2}, then % ring_size(2) = {1,1,0,0}).
+  // ring entries and to wrap. Visible positions 5..9 map through
+  // block_column = pos/2 % ring_size(2) -> {0,1,1,0,0}, wrapping back to
+  // block_column 0 once the ring rotates.
   const torch::Tensor block_table = torch::tensor({{20, 21}}, torch::kInt32);
   const torch::Tensor query_cu_seq_lens = torch::tensor({0, 1}, torch::kInt32);
   const torch::Tensor seq_lens = torch::tensor({10}, torch::kInt32);
@@ -246,11 +246,12 @@ TEST_F(DeepseekV4IndexerTest, DSparkNativeSwaIndicesWrapAroundRingBuffer) {
   ASSERT_EQ(indices.dim(), 3);
   ASSERT_EQ(indices.size(0), 1);
   ASSERT_EQ(indices.size(1), 1);
-  // start_pos = max(kv-window, 0) = 6, so the visible window is positions
-  // 6,7,8,9. block_column = pos/2 % 2 -> {1,1,0,0}; slot = block_id * 2 +
-  // pos%2 -> {21*2+0, 21*2+1, 20*2+0, 20*2+1} = {42, 43, 40, 41}.
+  // start_pos = max((kv - q_len) - window, 0) = (10-1)-4 = 5, so the visible
+  // window is positions 5,6,7,8,9. block_column = pos/2 % 2 -> {0,1,1,0,0};
+  // slot = block_id*2 + pos%2 -> {20*2+1, 21*2+0, 21*2+1, 20*2+0, 20*2+1} =
+  // {41, 42, 43, 40, 41}.
   const torch::Tensor expected_prefix =
-      torch::tensor({42, 43, 40, 41, -1}, torch::kInt32);
+      torch::tensor({41, 42, 43, 40, 41}, torch::kInt32);
   EXPECT_TRUE(torch::equal(indices[0][0].slice(0, 0, 5), expected_prefix));
 }
 

xllm/core/layers/npu_torch/deepseek_sparse_attention.cpp

@@ -529,8 +529,8 @@ torch::Tensor build_dspark_swa_indices(const torch::Tensor& block_table,
       index_width, torch::TensorOptions().dtype(torch::kLong).device(device));
   torch::Tensor valid = columns.unsqueeze(0) < visible_lens.unsqueeze(1);
   torch::Tensor positions = start_pos.unsqueeze(1) + columns.unsqueeze(0);
-  torch::Tensor block_columns =
-      (positions / cache_block_size).remainder(block_table.size(1));
+  torch::Tensor block_columns = torch::floor_divide(positions, cache_block_size)
+                                    .remainder(block_table.size(1));
   torch::Tensor block_ids = block_table.gather(/*dim=*/1, block_columns);
   torch::Tensor slot_ids =
       block_ids * cache_block_size + positions.remainder(cache_block_size);

xllm/core/runtime/worker_impl.cpp

@@ -168,24 +168,30 @@ std::vector<int32_t> read_capture_layer_ids(
 }
 
 #if defined(USE_NPU)
+int32_t read_block_size(const std::string& model_weights_path) {
+  JsonReader reader;
+  const std::string config_path = model_weights_path + "/config.json";
+  CHECK(reader.parse(config_path))
+      << "Failed to parse DSpark draft config: " << config_path;
+  return reader.value_or<int32_t>("dspark_block_size", 0);
+}
+
 void configure_deepseek_v4_dspark_args(ModelArgs& args,
                                        const runtime::Options& options) {
   CHECK_GT(args.dspark_num_layers(), 0)
       << "DeepSeek-V4 DSpark requires at least one draft layer.";
   args.n_layers(args.dspark_num_layers());
   args.n_hash_layers(0);
 
-  // --num_speculative_tokens overrides the checkpoint's dspark_block_size.
-  const int32_t ckpt_block_size = args.dspark_block_size();
+  // Default to the checkpoint's block_size; --num_speculative_tokens overrides.
+  const int32_t ckpt_block_size = read_block_size(options.model_path());
   const int32_t user_num_spec = options.num_speculative_tokens();
-  if (user_num_spec > 0) {
-    if (user_num_spec != ckpt_block_size) {
-      LOG(WARNING) << "--num_speculative_tokens=" << user_num_spec
-                   << " overrides DSpark checkpoint dspark_block_size="
-                   << ckpt_block_size << ".";
-    }
-    args.dspark_block_size(user_num_spec);
+  if (user_num_spec > 0 && user_num_spec != ckpt_block_size) {
+    LOG(WARNING) << "--num_speculative_tokens=" << user_num_spec
+                 << " overrides DSpark checkpoint dspark_block_size="
+                 << ckpt_block_size << ".";
   }
+  args.dspark_block_size(user_num_spec > 0 ? user_num_spec : ckpt_block_size);
 
   // DSpark stages are all standard SWA layers. Their stage ids are not target
   // model layer ids, so target compress_ratios[0..N) must not be reused.

xllm/models/llm/deepseek_v4.h

@@ -2088,7 +2088,8 @@ inline void load_deepseek_v4_model_args(const JsonReader& json,
       json.value_or<std::vector<int32_t>>("dspark_target_layer_ids",
                                           std::vector<int32_t>{})
           .size());
-  LOAD_ARG_OR(dspark_block_size, "dspark_block_size", 0);
+  // Don't arm dspark_block_size on the shared target (enables non-causal DSpark
+  // attention there); the draft worker sets it from the checkpoint.
 
   // Token ids
   LOAD_ARG_OR(bos_token_id, "bos_token_id", 0);