Встроенная сборка вызывает ошибку сегментации (ядро сброшено) - PullRequest
Новая
       44

Встроенная сборка вызывает ошибку сегментации (ядро сброшено)

0 голосов
/ 15 марта 2019

Я пытаюсь преобразовать встроенные функции Intel в встроенную сборку.

Код будет рассчитывать матрицу 4x4. Размеры A и B равны 4 x kc и kc x 4 соответственно.

Вот полная функция: 

 #define MR 4
 #define NR 4
 // compute C := beta * C + alpha * AB
 static void  dgemm_micro_kernel(int kc,
               double alpha, const double *A, const double *B,
               double beta,
               double *C, int incRowC, int incColC)
{ 
    double AB[MR*NR] __attribute__ ((aligned (32)));

    int i, j, p;
    register __m256d ab_00_10_20_30, ab_01_11_21_31, ab_02_12_22_32, ab_03_13_23_33;
    register __m256d a_0123, b_0000, b_1111, b_2222, b_3333;


    ab_00_10_20_30 = _mm256_setzero_pd();
    ab_01_11_21_31 = _mm256_setzero_pd();
    ab_02_12_22_32 = _mm256_setzero_pd();
    ab_03_13_23_33 = _mm256_setzero_pd();

    for (p = 0; p < kc; p++)
    {
        a_0123 = _mm256_load_pd(A);
        b_0000 = _mm256_broadcast_sd(B);
        b_1111 = _mm256_broadcast_sd(B + 1);
        b_2222 = _mm256_broadcast_sd(B + 2);
        b_3333 = _mm256_broadcast_sd(B + 3);

        // Col 1
        ab_00_10_20_30 = _mm256_fmadd_pd(a_0123, b_0000, ab_00_10_20_30);
        // Col 2
        ab_01_11_21_31 = _mm256_fmadd_pd(a_0123, b_1111, ab_01_11_21_31);
        // Col 3
        ab_02_12_22_32 = _mm256_fmadd_pd(a_0123, b_2222, ab_02_12_22_32);
        // Col 4
        ab_03_13_23_33 = _mm256_fmadd_pd(a_0123, b_3333, ab_03_13_23_33);

        A += MR;
        B += NR;
  }
    _mm256_store_pd(AB +  0, ab_00_10_20_30);
    _mm256_store_pd(AB +  4, ab_01_11_21_31);
    _mm256_store_pd(AB +  8, ab_02_12_22_32);
    _mm256_store_pd(AB + 12, ab_03_13_23_33);

    // Updata C := beta * C
    if (beta == 0.0)
   {
        // C == 0
        for (j = 0; j < NR; j++)
        {
            for (i = 0; i < MR; i++)
           {
                C[i * incRowC + j * incColC] = 0.0;
          }
      }
    }
    else if (beta != 1.0)
    {
        // C := beta * C
        for (j = 0; j < NR; j++)
        {
            for (i = 0; i < MR; i++)
            {
                C[i * incRowC + j * incColC] *= beta;
            }
        }
    }

    // Updata C := C + alpha * AB
    if (alpha == 1.0)
    {
        for (j = 0; j < NR; j++)
        {
            for (i = 0; i < MR; i++)
            {
                C[i * incRowC + j * incColC] += AB[j * MR + i];
            }
        }
    }
    else
    {
        for (j = 0; j < NR; j++)
        {
            for (i = 0; i < MR; i++)
            {
                C[i * incRowC + j * incColC] += alpha * AB[j * MR + i];
            }
        }
    }
}

Вот моя встроенная сборка (просто опубликуйте соответствующую часть): 

double AB[16] __attribute__ ((aligned(32)));
__asm__ volatile
(
    "movl           %0,         %%esi               \n\t"   // kc
    "movq           %1,         %%rax               \n\t"   // A
    "movq           %2,         %%rbx               \n\t"   // B
    "movq           %3,         %%rcx               \n\t"   // AB
    "                                               \n\t"
    "vxorpd         %%ymm0,     %%ymm0,     %%ymm0  \n\t"   // SET ZERO
    "vxorpd         %%ymm1,     %%ymm1,     %%ymm1  \n\t"
    "vxorpd         %%ymm2,     %%ymm2,     %%ymm2  \n\t"
    "vxorpd         %%ymm3,     %%ymm3,     %%ymm3  \n\t"
    "                                               \n\t"
    "testl           %%esi,      %%esi               \n\t"   // CHECK
    "je             .DWRITEAB                       \n\t"
    "                                               \n\t"
    ".DLOOP:                                        \n\t"   // LOOP
    "vmovapd        (%%rax),    %%ymm4              \n\t"   // load a_0123
    "vbroadcastsd   (%%rbx),    %%ymm5              \n\t"   // load b_0000
    "vbroadcastsd   8(%%rbx),   %%ymm6              \n\t"   // load b_1111
    "vbroadcastsd   16(%%rbx),  %%ymm7              \n\t"   // load b_2222
    "vbroadcastsd   24(%%rbx),  %%ymm8              \n\t"   // load b_3333
    "                                               \n\t"
    "vfmadd132pd    %%ymm4,     %%ymm5,     %%ymm0  \n\t"   // Col 1
    "vfmadd132pd    %%ymm4,     %%ymm6,     %%ymm1  \n\t"   // Col 2
    "vfmadd132pd    %%ymm4,     %%ymm7,     %%ymm2  \n\t"   // Col 3
    "vfmadd132pd    %%ymm4,     %%ymm8,     %%ymm3  \n\t"   // Col 4
    "                                               \n\t"
    "addq           $32,        %%rax               \n\t"
    "addq           $32,        %%rbx               \n\t"
    "                                               \n\t"
    "decl           %%esi                           \n\t"
    "jne            .DLOOP                          \n\t"
    "                                               \n\t"
    ".DWRITEAB:                                     \n\t"
    "vmovapd        %%ymm0,     (%%rcx)             \n\t"
    "vmovapd        %%ymm1,     32(%%rcx)           \n\t"
    "vmovapd        %%ymm2,     64(%%rcx)           \n\t"
    "vmovapd        %%ymm3,     96(%%rcx)           \n\t"
    "                                               \n\t"
    : // output
    : // input
        "m" (kc), // 0
        "m" (A),  // 1
        "m" (B),  // 2
        "m" (AB) // 3
    : // clober list
        "rax", "rbx", "rcx", "esi",
        "xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
        "xmm5", "xmm6", "xmm7", "xmm8", "memory"
);

Затем я компилирую и запускаю его, вывод показывает Segmentation fault (core dumped). Тем не менее, встроенная версия работает хорошо. Что не так с моим встроенным кодом сборки?

1 Ответ

2 голосов
/ 15 марта 2019

AB - это массив, но вы используете его как указатель.Кроме того, это выход, но он указан как вход.

Самое простое изменение, чтобы это исправить - использовать lea вместо mov для загрузки адреса AB в rcx,Также укажите "=m"(AB) в качестве выходных данных.

Лучшее решение - позволить компилятору зарегистрировать распределение и удалить клобберы для eax, ebx, ecx и esi.Используя ограничение "r", компилятор преобразует массив в указатель на его первый элемент и помещает указатель в регистр.Вы можете избежать сгустка памяти, перечислив операнды массива дважды.

ПРЕДУПРЕЖДЕНИЕ, это не совсем верно, потому что это неправильно указывает, что код сборки изменяет свои входные регистры.Поскольку вы не показали всю функцию, я не могу сказать, вызовет ли это проблему (но это определенно неправильно). 

asm ("..."
    : // output
      "=m"(AB)
    : // input
      "r"(kc), "r"(A), "r"(B), "r"(AB),
      "m"(*(double (*)[4*kc])A), "m"(*(double (*)[4*kc])B)
    : // clobber list
      "xmm0", "xmm1", "xmm2", "xmm3", "xmm4",
      "xmm5", "xmm6", "xmm7", "xmm8"
);

Это требует изменения всех ссылок на параметры в коде сборкииспользовать %1, %2, %3 и %4.

...