数据混乱问题

Stubborn

在测试batch_process_avx2函数中发现，数据发生混乱，测试案例落了两个黑子，所有的白子数据正常都应该为0才对，但是在函数中发生了混乱。
我想知道为什么会发生数据混乱的问题，大致方向，我好进行排查
在打印案例中第一轮在未处理签，白子所有数据均为0，正常。处理后第4，第五有异常，变成了一，期望值应该是0。在白棋内部打印并未触发，索引也已经打印

1. this line 147 Running test_get_move function ...
   
2. [DEBUG] GET_SORT_MOVES line 483 data number is :16 success !
   
3. 
   
4. +++++ [debug] batch_process_avx2 line 252 simd_white[1,2,5]++++++:
   
5. :572 :0 :0 :0 :0 :0
   
6. :572 :0 :0 :0 :0 :0
   
7. :572 :0 :0 :0 :0 :0
   
8. :572 :0 :0 :0 :0 :0
   
9. :572 :0 :0 :0 :0 :0
   
10. :572 :0 :0 :0 :0 :0
    
11. :572 :0 :0 :0 :0 :0
    
12. :572 :0 :0 :0 :0 :0
    
13. |-|-|-|-| [debug] batch_process_avx2 line 250 player= 1 and  BLACK_PLAYER= 1 <k:j> <1:0> | <1:1> | <1:2> | <1:3> | <1:4> | <1:5> | <1:6> | <1:7> |
    
14. --- [debug] batch_process_avx2 line 252 simd_white[1,2,5]++++++:
    
15. :572 :0 :0 :0 :1 :0
    
16. :572 :0 :0 :0 :1 :0
    
17. :572 :0 :0 :0 :1 :0
    
18. :572 :0 :0 :0 :0 :0
    
19. :572 :0 :0 :0 :0 :0
    
20. :572 :0 :0 :0 :0 :0
    
21. :572 :0 :0 :0 :0 :0
    
22. :572 :0 :0 :0 :0 :1
    
23. [DEBUG] batch 0 Rating: -632 -632 -632 368 368 368 368 -9632
    
24. 
    
25. +++++ [debug] batch_process_avx2 line 252 simd_white[1,2,5]++++++:
    
26. :572 :0 :0 :0 :0 :0
    
27. :572 :0 :0 :0 :0 :0
    
28. :572 :0 :0 :0 :0 :0
    
29. :572 :0 :0 :0 :0 :0
    
30. :572 :0 :0 :0 :0 :0
    
31. :572 :0 :0 :0 :0 :0
    
32. :572 :0 :0 :0 :0 :0
    
33. :572 :0 :0 :0 :0 :0
    
34. |-|-|-|-| [debug] batch_process_avx2 line 250 player= 1 and  BLACK_PLAYER= 1 <k:j> <2:0> | <5:1> | <5:2> | <1:3> | <1:4> | <5:5> | <5:6> | <2:7> |
    
35. --- [debug] batch_process_avx2 line 252 simd_white[1,2,5]++++++:
    
36. :572 :0 :0 :0 :0 :0
    
37. :572 :0 :0 :0 :0 :0
    
38. :572 :0 :0 :0 :0 :0
    
39. :572 :0 :0 :0 :0 :0
    
40. :572 :0 :0 :0 :0 :0
    
41. :572 :0 :0 :0 :0 :0
    
42. :572 :0 :0 :0 :0 :0
    
43. :572 :0 :0 :0 :0 :0
    
44. [DEBUG] batch 8 Rating: 377 10367 10367 368 368 10367 10367 377
    
45. this line 147-174 Running function test_get_move... success Passed!

复制代码

GET_SORT_MOVES函数

1.     CORE_API void GET_SORT_MOVES(AlignedSIMDContext* ctx, int player, int top_n) noexcept {
   
2.         if (!ctx || ctx->undo_top >= 255) {
   
3.             ctx->num_sorted_moves = 0;
   
4.             return;
   
5.         }
   
6. 
   
7.         // 生成候选着法
   
8.         std::vector<std::pair<int, int>> history;
   
9.         history.reserve(ctx->undo_top);
   
10.         for (int i = 0; i < ctx->undo_top; ++i) {
    
11.             history.emplace_back(ctx->undo_stack[i].x, ctx->undo_stack[i].y);
    
12.         }
    
13.         auto candidates = generate_candidates(history);
    
14.         ctx->num_sorted_moves = 0;
    
15.         if (candidates.empty()) return;
    
16. 
    
17.         std::vector<SIMDContext> thread_ctxs(omp_get_max_threads());
    
18.         std::vector<int> scores(candidates.size());
    
19.         std::vector<Move> temp_moves;
    
20.         std::cout << "[DEBUG] GET_SORT_MOVES line 483 data number is :" << candidates.size() << " success ! \n ";
    
21. 
    
22. 
    
23. #pragma omp parallel
    
24.         {
    
25.             const int tid = omp_get_thread_num();
    
26. 
    
27. #pragma omp for schedule(static, 64)
    
28.             for (int i = 0; i < candidates.size(); i += SIMD_BATCH_SIZE) {
    
29.                 copy_core_data(&thread_ctxs[tid], ctx);
    
30.                 const int batch = std::min(SIMD_BATCH_SIZE, int(candidates.size() - i));
    
31.                 batch_process_avx2(
    
32.                     &thread_ctxs[tid],
    
33.                     {candidates.begin() + i, candidates.begin() + i + batch},
    
34.                     player,
    
35.                     scores.data() + i
    
36.                 );
    
37.                 std::cout << "\n[DEBUG] batch " << i << " Rating: ";
    
38.                 for (int j = 0; j < batch; ++j) {
    
39.                     std::cout << scores[i + j] << " ";
    
40.                 }
    
41.                 std::cout << std::endl << std::flush;
    
42.             }
    
43.         }
    
44. 
    
45. 
    
46.         // 主线程处理排序
    
47.         temp_moves.reserve(candidates.size());
    
48.         for (size_t i = 0; i < candidates.size(); ++i) {
    
49.             temp_moves.push_back({ scores[i], { candidates[i].first, candidates[i].second } });
    
50.         }
    
51. 
    
52.         const int partial_sort_size = std::min(static_cast<int>(temp_moves.size()), top_n * 2);
    
53.         std::partial_sort(
    
54.             temp_moves.begin(),
    
55.             temp_moves.begin() + partial_sort_size,
    
56.             temp_moves.end(),
    
57.             [](const Move& a, const Move& b) { return a.score > b.score; }
    
58.         );
    
59. 
    
60.         ctx->num_sorted_moves = std::min(top_n, static_cast<int>(temp_moves.size()));
    
61.         for (int i = 0; i < ctx->num_sorted_moves; ++i) {
    
62.             if (i >= MAX_SORTED_MOVES) break;
    
63.             ctx->sorted_moves[i] = temp_moves[i];
    
64.         }
    
65.     }
    
66. 
    
67. }

复制代码

copy_core_data函数

1.     inline void copy_core_data(
   
2.         SIMDContext* dst,
   
3.         const AlignedSIMDContext* src
   
4.     ) {
   
5.         static_assert(sizeof(dst->vec_states) == sizeof(src->vec_states),
   
6.                      "VectorState 大小不匹配");
   
7.         memcpy(dst->vec_states, src->vec_states, sizeof(VectorState)*MAX_VECTORS);
   
8. 
   
9.         for (int k = 0; k < 6; ++k) {
   
10.             for (int j = 0; j < SIMD_WIDTH; ++j) {
    
11.                 dst->simd_black[k][j] = src->black_counts[k];
    
12.                 dst->simd_white[k][j] = src->white_counts[k];
    
13.             }
    
14.         }
    
15.     }
    

复制代码

batch_process_avx2函数

1. void batch_process_avx2(
   
2.     SIMDContext* ctx,
   
3.     const std::vector<std::pair<int, int>>& moves,
   
4.     int player,
   
5.     int* scores)
   
6. {
   
7. 
   
8.     alignas(32) int indices[SIMD_WIDTH];
   
9. 
   
10.     for (size_t i = 0; i < moves.size(); i += SIMD_WIDTH) {
    
11.         printf("\n+++++ [debug] batch_process_avx2 line 252 simd_white[1,2,5]++++++: ");
    
12.         for (int j = 0; j < 8; ++j) {
    
13.             printf("\n");
    
14.             for (int k = 0; k < 6; ++k) {
    
15.                 printf(" :%d", ctx->simd_white[k][j]);
    
16.             }
    
17. 
    
18.         }
    
19.         const int batch = std::min(SIMD_WIDTH, static_cast<int>(moves.size() - i));
    
20. 
    
21.         // 填充索引数组
    
22.         for (int j = 0; j < batch; ++j) {
    
23.             const auto& [x, y] = moves[i + j];
    
24.             indices[j] = y * BOARD_SIZE + x;
    
25.         }
    
26.         for (int j = batch; j < SIMD_WIDTH; ++j) {
    
27.             indices[j] = 0;
    
28.         }
    
29. 
    
30.         __m256i v_idx = _mm256_load_si256(reinterpret_cast<__m256i*>(indices));
    
31. 
    
32.         // 根据玩家更新计数器
    
33.         __m256i v_counts;
    
34.         alignas(32) int new_counts[SIMD_WIDTH];
    
35.         alignas(32) int stored_indices[SIMD_WIDTH];
    
36.         _mm256_store_si256(reinterpret_cast<__m256i*>(stored_indices), v_idx);
    
37. 
    
38.         if (player == BLACK_PLAYER) {
    
39.             v_counts = _mm256_i32gather_epi32(ctx->black_counts, v_idx, sizeof(int32_t));
    
40.             v_counts = _mm256_add_epi32(v_counts, _mm256_set1_epi32(1));
    
41.             _mm256_store_si256(reinterpret_cast<__m256i*>(new_counts), v_counts);
    
42.             for (int j = 0; j < batch; ++j) {
    
43.                 ctx->black_counts[stored_indices[j]] = new_counts[j];
    
44.             }
    
45.         } else {
    
46.             v_counts = _mm256_i32gather_epi32(ctx->white_counts, v_idx, sizeof(int32_t));
    
47.             v_counts = _mm256_add_epi32(v_counts, _mm256_set1_epi32(1));
    
48.             _mm256_store_si256(reinterpret_cast<__m256i*>(new_counts), v_counts);
    
49.             for (int j = 0; j < batch; ++j) {
    
50.                 ctx->white_counts[stored_indices[j]] = new_counts[j];
    
51.             }
    
52.         }
    
53.         // 更新SIMD计数器
    
54.         printf("\n|-|-|-|-| [debug] batch_process_avx2 line 250 player= %d and  BLACK_PLAYER= %d <k:j> ",player,BLACK_PLAYER);
    
55.         for (int m = 0; m < batch; ++m) {
    
56.             const int k = std::clamp(new_counts[m], 0, 5);
    
57.             printf("<%d:%d> | ",k ,m);
    
58.             if (player == BLACK_PLAYER) {
    
59.                 ctx->simd_black[k][m]++;
    
60.             } else {
    
61.                 printf("<> | <> | <> | <> | <> | <> | <> | <> | <> | <> | <> | <> | ");
    
62.                 ctx->simd_white[k][m]++;
    
63.             }
    
64.         }
    
65. 
    
66.         __m256i v_scores = calculate_scores_avx2(ctx, player);
    
67.         printf("\n--- [debug] batch_process_avx2 line 252 simd_white[1,2,5]++++++: ");
    
68.         for (int j = 0; j < 8; ++j) {
    
69.             printf("\n");
    
70.             for (int k = 0; k < 6; ++k) {
    
71.                 printf(" :%d", ctx->simd_white[k][j]);
    
72.             }
    
73. 
    
74.         }
    
75.         alignas(32) int score_values[SIMD_WIDTH];
    
76.         _mm256_store_si256(reinterpret_cast<__m256i*>(score_values), v_scores);
    
77.         for (int j = 0; j < batch; ++j) {
    
78.             scores[i + j] = score_values[j];
    
79.         }
    
80.     }
    
81. }

复制代码

两个数据体结构

1. struct alignas(64) SIMDContext {
   
2.     VectorState vec_states[MAX_VECTORS];
   
3.     alignas(32) int32_t black_counts[6];
   
4.     alignas(32) int32_t white_counts[6];
   
5.     // 核心状态（32字节对齐）
   
6.     alignas(32) int32_t simd_black[6][8];
   
7.     alignas(32) int32_t simd_white[6][8];
   
8. };
   
9. 
   
10. 
    
11. class CORE_API alignas(SIMD_ALIGNMENT) AlignedSIMDContext {
    
12. public:
    
13. 
    
14.     Vector vectors[MAX_VECTORS];
    
15.     VectorState vec_states[MAX_VECTORS];
    
16.     Move sorted_moves[MAX_CELLS];
    
17.     int32_t num_sorted_moves = 0;
    
18. 
    
19.     alignas(32) int32_t black_counts[6];
    
20.     alignas(32) int32_t white_counts[6];

复制代码

FishC

数据混乱的可能原因有以下几个方向，你可以根据这些方向进行排查：  

1. 线程安全问题  
你的代码可能在多个线程中并行执行，而 `ctx->white_counts` 和 `ctx->black_counts` 可能没有正确同步，导致数据竞争。可以尝试使用 `#pragma omp critical` 或者 `std::atomic<int32_t>` 来确保数据一致性。  

2. SIMD 访问越界  
在 `batch_process_avx2` 函数中，你使用 `_mm256_i32gather_epi32` 进行数据加载，确保 `ctx->white_counts` 和 `ctx->black_counts` 的内存对齐，并且 `indices` 没有超出数组范围。  

3. 变量未正确初始化  
检查 `ctx->white_counts` 和 `ctx->black_counts` 是否在 `SIMDContext` 结构体初始化时被正确赋值，避免未定义行为。  

4. 误修改数据  
在 `batch_process_avx2` 里，你使用 `_mm256_store_si256` 存储 `new_counts`，但 `ctx->white_counts` 可能被错误地更新。可以在 `for` 循环中打印 `indices` 和 `new_counts`，确保它们的值正确。  

5. 结构体对齐问题  
`SIMDContext` 结构体使用 `alignas(32)` 进行对齐，但 `AlignedSIMDContext` 可能没有完全匹配，导致 `ctx->white_counts` 访问异常。可以尝试 `static_assert(alignof(SIMDContext) == 32, "Alignment issue")` 进行检查。  

你可以从这些方向入手，逐步排查问题。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。