OpenI
/
MegEngine
Not watched
1
0
Fork 0
Code
Releases 31 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: f249d387de
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f249d387de'
${ noResults }
MegEngine/dnn/src/fallback/matrix_mul/gi/fp32/strategy_4x12.cpp

951 lines
30 kB
Raw Blame History 

  1. #include "src/fallback/matrix_mul/generic_strategy.h"

  2. #include "src/fallback/matrix_mul/gi/fp32/common.h"

  3. 

  4. using namespace megdnn;

  5. using namespace matmul::fallback;

  6. 

  7. namespace {

  8. 

  9. #pragma GCC diagnostic push

  10. #pragma GCC diagnostic ignored "-Wuninitialized"

  11. 

  12. #ifdef __GNUC__

  13. #ifndef __has_warning

  14. #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

  15. #else

  16. #if __has_warning("-Wmaybe-uninitialized")

  17. #pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

  18. #endif

  19. #endif

  20. #endif

  21. void kern_4x12(

  22.         const float* packA, const float* packB, int K, float* output, int LDC,

  23.         bool is_first_k, int m_remain) {

  24.     const float* a_ptr = packA;

  25.     const float* b_ptr = packB;

  26.     int oddk = (K & 1);

  27.     K = ((K + 1) / 2) - 1;

  28. 

  29.     float* r0 = output;

  30.     float* r1 = r0 + LDC;

  31.     float* r2 = r1 + LDC;

  32.     float* r3 = r2 + LDC;

  33. 

  34.     GI_FLOAT32_t d0d1, d2d3, d4d5, d6d7, d8d9, d10d11, d12d13, d14d15, d16d17, d18d19,

  35.             d20d21, d22d23, d24d25, d26d27, d28d29, d30d31;

  36. 

  37.     if (is_first_k) {

  38.         d8d9 = GiBroadcastFloat32(0.0f);

  39.         d10d11 = GiBroadcastFloat32(0.0f);

  40.         d12d13 = GiBroadcastFloat32(0.0f);

  41.         d14d15 = GiBroadcastFloat32(0.0f);

  42.         d16d17 = GiBroadcastFloat32(0.0f);

  43.         d18d19 = GiBroadcastFloat32(0.0f);

  44.         d20d21 = GiBroadcastFloat32(0.0f);

  45.         d22d23 = GiBroadcastFloat32(0.0f);

  46.         d24d25 = GiBroadcastFloat32(0.0f);

  47.         d26d27 = GiBroadcastFloat32(0.0f);

  48.         d28d29 = GiBroadcastFloat32(0.0f);

  49.         d30d31 = GiBroadcastFloat32(0.0f);

  50.     } else {

  51.         if (m_remain == 4) {

  52.             d8d9 = GiLoadFloat32(r0);

  53.             d10d11 = GiLoadFloat32(r0 + 4);

  54.             d12d13 = GiLoadFloat32(r0 + 8);

  55. 

  56.             d14d15 = GiLoadFloat32(r1);

  57.             d16d17 = GiLoadFloat32(r1 + 4);

  58.             d18d19 = GiLoadFloat32(r1 + 8);

  59. 

  60.             d20d21 = GiLoadFloat32(r2);

  61.             d22d23 = GiLoadFloat32(r2 + 4);

  62.             d24d25 = GiLoadFloat32(r2 + 8);

  63. 

  64.             d26d27 = GiLoadFloat32(r3);

  65.             d28d29 = GiLoadFloat32(r3 + 4);

  66.             d30d31 = GiLoadFloat32(r3 + 8);

  67.         } else if (m_remain == 3) {

  68.             d8d9 = GiLoadFloat32(r0);

  69.             d10d11 = GiLoadFloat32(r0 + 4);

  70.             d12d13 = GiLoadFloat32(r0 + 8);

  71. 

  72.             d14d15 = GiLoadFloat32(r1);

  73.             d16d17 = GiLoadFloat32(r1 + 4);

  74.             d18d19 = GiLoadFloat32(r1 + 8);

  75. 

  76.             d20d21 = GiLoadFloat32(r2);

  77.             d22d23 = GiLoadFloat32(r2 + 4);

  78.             d24d25 = GiLoadFloat32(r2 + 8);

  79.         } else if (m_remain == 2) {

  80.             d8d9 = GiLoadFloat32(r0);

  81.             d10d11 = GiLoadFloat32(r0 + 4);

  82.             d12d13 = GiLoadFloat32(r0 + 8);

  83. 

  84.             d14d15 = GiLoadFloat32(r1);

  85.             d16d17 = GiLoadFloat32(r1 + 4);

  86.             d18d19 = GiLoadFloat32(r1 + 8);

  87.         } else if (m_remain == 1) {

  88.             d8d9 = GiLoadFloat32(r0);

  89.             d10d11 = GiLoadFloat32(r0 + 4);

  90.             d12d13 = GiLoadFloat32(r0 + 8);

  91.         }

  92.     }

  93.     d2d3 = GiLoadFloat32(b_ptr);

  94.     b_ptr = b_ptr + 4;

  95.     d4d5 = GiLoadFloat32(b_ptr);

  96.     b_ptr = b_ptr + 4;

  97.     d6d7 = GiLoadFloat32(b_ptr);

  98.     b_ptr = b_ptr + 4;

  99. 

  100.     for (; K > 0; K--) {

  101.         d0d1 = GiLoadFloat32(a_ptr);

  102.         a_ptr = a_ptr + 4;

  103. 

  104.         d8d9 = GiSimdFmaLane(d8d9, d2d3, d0d1, 0);

  105.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 0);

  106.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d0d1, 0);

  107.         d14d15 = GiSimdFmaLane(d14d15, d2d3, d0d1, 1);

  108.         d16d17 = GiSimdFmaLane(d16d17, d4d5, d0d1, 1);

  109.         d18d19 = GiSimdFmaLane(d18d19, d6d7, d0d1, 1);

  110.         d20d21 = GiSimdFmaLane(d20d21, d2d3, d0d1, 2);

  111.         d22d23 = GiSimdFmaLane(d22d23, d4d5, d0d1, 2);

  112.         d24d25 = GiSimdFmaLane(d24d25, d6d7, d0d1, 2);

  113.         d26d27 = GiSimdFmaLane(d26d27, d2d3, d0d1, 3);

  114.         d28d29 = GiSimdFmaLane(d28d29, d4d5, d0d1, 3);

  115.         d30d31 = GiSimdFmaLane(d30d31, d6d7, d0d1, 3);

  116. 

  117.         d0d1 = GiLoadFloat32(a_ptr);

  118.         a_ptr = a_ptr + 4;

  119.         d2d3 = GiLoadFloat32(b_ptr);

  120.         b_ptr = b_ptr + 4;

  121.         d4d5 = GiLoadFloat32(b_ptr);

  122.         b_ptr = b_ptr + 4;

  123.         d6d7 = GiLoadFloat32(b_ptr);

  124.         b_ptr = b_ptr + 4;

  125. 

  126.         d8d9 = GiSimdFmaLane(d8d9, d2d3, d0d1, 0);

  127.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 0);

  128.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d0d1, 0);

  129.         d14d15 = GiSimdFmaLane(d14d15, d2d3, d0d1, 1);

  130.         d16d17 = GiSimdFmaLane(d16d17, d4d5, d0d1, 1);

  131.         d18d19 = GiSimdFmaLane(d18d19, d6d7, d0d1, 1);

  132.         d20d21 = GiSimdFmaLane(d20d21, d2d3, d0d1, 2);

  133.         d22d23 = GiSimdFmaLane(d22d23, d4d5, d0d1, 2);

  134.         d24d25 = GiSimdFmaLane(d24d25, d6d7, d0d1, 2);

  135.         d26d27 = GiSimdFmaLane(d26d27, d2d3, d0d1, 3);

  136.         d28d29 = GiSimdFmaLane(d28d29, d4d5, d0d1, 3);

  137.         d30d31 = GiSimdFmaLane(d30d31, d6d7, d0d1, 3);

  138. 

  139.         d2d3 = GiLoadFloat32(b_ptr);

  140.         b_ptr = b_ptr + 4;

  141.         d4d5 = GiLoadFloat32(b_ptr);

  142.         b_ptr = b_ptr + 4;

  143.         d6d7 = GiLoadFloat32(b_ptr);

  144.         b_ptr = b_ptr + 4;

  145.     }

  146. 

  147.     if (1 == oddk) {

  148.         d0d1 = GiLoadFloat32(a_ptr);

  149.         a_ptr = a_ptr + 4;

  150. 

  151.         d8d9 = GiSimdFmaLane(d8d9, d2d3, d0d1, 0);

  152.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 0);

  153.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d0d1, 0);

  154.         d14d15 = GiSimdFmaLane(d14d15, d2d3, d0d1, 1);

  155.         d16d17 = GiSimdFmaLane(d16d17, d4d5, d0d1, 1);

  156.         d18d19 = GiSimdFmaLane(d18d19, d6d7, d0d1, 1);

  157.         d20d21 = GiSimdFmaLane(d20d21, d2d3, d0d1, 2);

  158.         d22d23 = GiSimdFmaLane(d22d23, d4d5, d0d1, 2);

  159.         d24d25 = GiSimdFmaLane(d24d25, d6d7, d0d1, 2);

  160.         d26d27 = GiSimdFmaLane(d26d27, d2d3, d0d1, 3);

  161.         d28d29 = GiSimdFmaLane(d28d29, d4d5, d0d1, 3);

  162.         d30d31 = GiSimdFmaLane(d30d31, d6d7, d0d1, 3);

  163. 

  164.     } else {

  165.         d0d1 = GiLoadFloat32(a_ptr);

  166.         a_ptr = a_ptr + 4;

  167. 

  168.         d8d9 = GiSimdFmaLane(d8d9, d2d3, d0d1, 0);

  169.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 0);

  170.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d0d1, 0);

  171.         d14d15 = GiSimdFmaLane(d14d15, d2d3, d0d1, 1);

  172.         d16d17 = GiSimdFmaLane(d16d17, d4d5, d0d1, 1);

  173.         d18d19 = GiSimdFmaLane(d18d19, d6d7, d0d1, 1);

  174.         d20d21 = GiSimdFmaLane(d20d21, d2d3, d0d1, 2);

  175.         d22d23 = GiSimdFmaLane(d22d23, d4d5, d0d1, 2);

  176.         d24d25 = GiSimdFmaLane(d24d25, d6d7, d0d1, 2);

  177.         d26d27 = GiSimdFmaLane(d26d27, d2d3, d0d1, 3);

  178.         d28d29 = GiSimdFmaLane(d28d29, d4d5, d0d1, 3);

  179.         d30d31 = GiSimdFmaLane(d30d31, d6d7, d0d1, 3);

  180. 

  181.         d0d1 = GiLoadFloat32(a_ptr);

  182.         a_ptr = a_ptr + 4;

  183.         d2d3 = GiLoadFloat32(b_ptr);

  184.         b_ptr = b_ptr + 4;

  185.         d4d5 = GiLoadFloat32(b_ptr);

  186.         b_ptr = b_ptr + 4;

  187.         d6d7 = GiLoadFloat32(b_ptr);

  188.         b_ptr = b_ptr + 4;

  189. 

  190.         d8d9 = GiSimdFmaLane(d8d9, d2d3, d0d1, 0);

  191.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 0);

  192.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d0d1, 0);

  193.         d14d15 = GiSimdFmaLane(d14d15, d2d3, d0d1, 1);

  194.         d16d17 = GiSimdFmaLane(d16d17, d4d5, d0d1, 1);

  195.         d18d19 = GiSimdFmaLane(d18d19, d6d7, d0d1, 1);

  196.         d20d21 = GiSimdFmaLane(d20d21, d2d3, d0d1, 2);

  197.         d22d23 = GiSimdFmaLane(d22d23, d4d5, d0d1, 2);

  198.         d24d25 = GiSimdFmaLane(d24d25, d6d7, d0d1, 2);

  199.         d26d27 = GiSimdFmaLane(d26d27, d2d3, d0d1, 3);

  200.         d28d29 = GiSimdFmaLane(d28d29, d4d5, d0d1, 3);

  201.         d30d31 = GiSimdFmaLane(d30d31, d6d7, d0d1, 3);

  202.     }

  203. 

  204.     if (m_remain == 4) {

  205.         GiStoreFloat32(r0, d8d9);

  206.         GiStoreFloat32(r0 + 4, d10d11);

  207.         GiStoreFloat32(r0 + 8, d12d13);

  208. 

  209.         GiStoreFloat32(r1, d14d15);

  210.         GiStoreFloat32(r1 + 4, d16d17);

  211.         GiStoreFloat32(r1 + 8, d18d19);

  212. 

  213.         GiStoreFloat32(r2, d20d21);

  214.         GiStoreFloat32(r2 + 4, d22d23);

  215.         GiStoreFloat32(r2 + 8, d24d25);

  216. 

  217.         GiStoreFloat32(r3, d26d27);

  218.         GiStoreFloat32(r3 + 4, d28d29);

  219.         GiStoreFloat32(r3 + 8, d30d31);

  220.     } else if (m_remain == 3) {

  221.         GiStoreFloat32(r0, d8d9);

  222.         GiStoreFloat32(r0 + 4, d10d11);

  223.         GiStoreFloat32(r0 + 8, d12d13);

  224. 

  225.         GiStoreFloat32(r1, d14d15);

  226.         GiStoreFloat32(r1 + 4, d16d17);

  227.         GiStoreFloat32(r1 + 8, d18d19);

  228. 

  229.         GiStoreFloat32(r2, d20d21);

  230.         GiStoreFloat32(r2 + 4, d22d23);

  231.         GiStoreFloat32(r2 + 8, d24d25);

  232.     } else if (m_remain == 2) {

  233.         GiStoreFloat32(r0, d8d9);

  234.         GiStoreFloat32(r0 + 4, d10d11);

  235.         GiStoreFloat32(r0 + 8, d12d13);

  236. 

  237.         GiStoreFloat32(r1, d14d15);

  238.         GiStoreFloat32(r1 + 4, d16d17);

  239.         GiStoreFloat32(r1 + 8, d18d19);

  240.     } else if (m_remain == 1) {

  241.         GiStoreFloat32(r0, d8d9);

  242.         GiStoreFloat32(r0 + 4, d10d11);

  243.         GiStoreFloat32(r0 + 8, d12d13);

  244.     }

  245. }

  246. 

  247. void kern_4x4(

  248.         const float* packA, const float* packB, int K, float* output, int LDC,

  249.         bool is_first_k, int m_remain, int n_remain) {

  250.     const float* a_ptr = packA;

  251.     const float* b_ptr = packB;

  252.     int oddk = (K & 1);

  253.     K = ((K + 1) / 2) - 1;

  254. 

  255.     float* r0 = output;

  256.     float* r1 = r0 + LDC;

  257.     float* r2 = r1 + LDC;

  258.     float* r3 = r2 + LDC;

  259.     size_t d_size = sizeof(float);

  260. 

  261.     GI_FLOAT32_t d0d1, d2d3, d4d5, d6d7, d8d9, d10d11, d12d13, d14d15;

  262.     float tmp[4];

  263.     if (is_first_k) {

  264.         d8d9 = GiBroadcastFloat32(0.0f);

  265.         d10d11 = GiBroadcastFloat32(0.0f);

  266.         d12d13 = GiBroadcastFloat32(0.0f);

  267.         d14d15 = GiBroadcastFloat32(0.0f);

  268.     } else {

  269.         if (m_remain == 4) {

  270.             if (n_remain == 4) {

  271.                 d8d9 = GiLoadFloat32(r0);

  272.                 d10d11 = GiLoadFloat32(r1);

  273.                 d12d13 = GiLoadFloat32(r2);

  274.                 d14d15 = GiLoadFloat32(r3);

  275.             } else if (n_remain == 3) {

  276.                 memcpy(tmp, r0, d_size * 3);

  277.                 r0 += 3;

  278.                 d8d9 = GiLoadFloat32(tmp);

  279. 

  280.                 memcpy(tmp, r1, d_size * 3);

  281.                 r1 += 3;

  282.                 d10d11 = GiLoadFloat32(tmp);

  283. 

  284.                 memcpy(tmp, r2, d_size * 3);

  285.                 r2 += 3;

  286.                 d12d13 = GiLoadFloat32(tmp);

  287. 

  288.                 memcpy(tmp, r3, d_size * 3);

  289.                 r3 += 3;

  290.                 d14d15 = GiLoadFloat32(tmp);

  291.             } else if (n_remain == 2) {

  292.                 memcpy(tmp, r0, d_size * 2);

  293.                 r0 += 2;

  294.                 d8d9 = GiLoadFloat32(tmp);

  295. 

  296.                 memcpy(tmp, r1, d_size * 2);

  297.                 r1 += 2;

  298.                 d10d11 = GiLoadFloat32(tmp);

  299. 

  300.                 memcpy(tmp, r2, d_size * 2);

  301.                 r2 += 2;

  302.                 d12d13 = GiLoadFloat32(tmp);

  303. 

  304.                 memcpy(tmp, r3, d_size * 2);

  305.                 r3 += 2;

  306.                 d14d15 = GiLoadFloat32(tmp);

  307.             } else if (n_remain == 1) {

  308.                 tmp[0] = *r0;

  309.                 r0++;

  310.                 d8d9 = GiLoadFloat32(tmp);

  311. 

  312.                 tmp[0] = *r1;

  313.                 r1++;

  314.                 d10d11 = GiLoadFloat32(tmp);

  315. 

  316.                 tmp[0] = *r2;

  317.                 r2++;

  318.                 d12d13 = GiLoadFloat32(tmp);

  319. 

  320.                 tmp[0] = *r3;

  321.                 r3++;

  322.                 d14d15 = GiLoadFloat32(tmp);

  323.             }

  324.         } else if (m_remain == 3) {

  325.             if (n_remain == 4) {

  326.                 d8d9 = GiLoadFloat32(r0);

  327.                 d10d11 = GiLoadFloat32(r1);

  328.                 d12d13 = GiLoadFloat32(r2);

  329.             } else if (n_remain == 3) {

  330.                 memcpy(tmp, r0, d_size * 3);

  331.                 r0 += 3;

  332.                 d8d9 = GiLoadFloat32(tmp);

  333. 

  334.                 memcpy(tmp, r1, d_size * 3);

  335.                 r1 += 3;

  336.                 d10d11 = GiLoadFloat32(tmp);

  337. 

  338.                 memcpy(tmp, r2, d_size * 3);

  339.                 r2 += 3;

  340.                 d12d13 = GiLoadFloat32(tmp);

  341.             } else if (n_remain == 2) {

  342.                 memcpy(tmp, r0, d_size * 2);

  343.                 r0 += 2;

  344.                 d8d9 = GiLoadFloat32(tmp);

  345. 

  346.                 memcpy(tmp, r1, d_size * 2);

  347.                 r1 += 2;

  348.                 d10d11 = GiLoadFloat32(tmp);

  349. 

  350.                 memcpy(tmp, r2, d_size * 2);

  351.                 r2 += 2;

  352.                 d12d13 = GiLoadFloat32(tmp);

  353.             } else if (n_remain == 1) {

  354.                 tmp[0] = *r0;

  355.                 r0++;

  356.                 d8d9 = GiLoadFloat32(tmp);

  357. 

  358.                 tmp[0] = *r1;

  359.                 r1++;

  360.                 d10d11 = GiLoadFloat32(tmp);

  361. 

  362.                 tmp[0] = *r2;

  363.                 r2++;

  364.                 d12d13 = GiLoadFloat32(tmp);

  365.             }

  366.         } else if (m_remain == 2) {

  367.             if (n_remain == 4) {

  368.                 d8d9 = GiLoadFloat32(r0);

  369.                 d10d11 = GiLoadFloat32(r1);

  370.             } else if (n_remain == 3) {

  371.                 memcpy(tmp, r0, d_size * 3);

  372.                 r0 += 3;

  373.                 d8d9 = GiLoadFloat32(tmp);

  374. 

  375.                 memcpy(tmp, r1, d_size * 3);

  376.                 r1 += 3;

  377.                 d10d11 = GiLoadFloat32(tmp);

  378.             } else if (n_remain == 2) {

  379.                 memcpy(tmp, r0, d_size * 2);

  380.                 r0 += 2;

  381.                 d8d9 = GiLoadFloat32(tmp);

  382. 

  383.                 memcpy(tmp, r1, d_size * 2);

  384.                 r1 += 2;

  385.                 d10d11 = GiLoadFloat32(tmp);

  386.             } else if (n_remain == 1) {

  387.                 tmp[0] = *r0;

  388.                 r0++;

  389.                 d8d9 = GiLoadFloat32(tmp);

  390. 

  391.                 tmp[0] = *r1;

  392.                 r1++;

  393.                 d10d11 = GiLoadFloat32(tmp);

  394.             }

  395.         } else if (m_remain == 1) {

  396.             if (n_remain == 4) {

  397.                 d8d9 = GiLoadFloat32(r0);

  398.             } else if (n_remain == 3) {

  399.                 memcpy(tmp, r0, d_size * 3);

  400.                 r0 += 3;

  401.                 d8d9 = GiLoadFloat32(tmp);

  402.             } else if (n_remain == 2) {

  403.                 memcpy(tmp, r0, d_size * 2);

  404.                 r0 += 2;

  405.                 d8d9 = GiLoadFloat32(tmp);

  406.             } else if (n_remain == 1) {

  407.                 tmp[0] = *r0;

  408.                 r0++;

  409.                 d8d9 = GiLoadFloat32(tmp);

  410.             }

  411.         }

  412.     }

  413. 

  414.     d0d1 = GiLoadFloat32(a_ptr);

  415.     a_ptr = a_ptr + 4;

  416.     d4d5 = GiLoadFloat32(b_ptr);

  417.     b_ptr = b_ptr + 4;

  418. 

  419.     for (; K > 0; K--) {

  420.         d2d3 = GiLoadFloat32(a_ptr);

  421.         a_ptr = a_ptr + 4;

  422.         d6d7 = GiLoadFloat32(b_ptr);

  423.         b_ptr = b_ptr + 4;

  424. 

  425.         d8d9 = GiSimdFmaLane(d8d9, d4d5, d0d1, 0);

  426.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 1);

  427.         d12d13 = GiSimdFmaLane(d12d13, d4d5, d0d1, 2);

  428.         d14d15 = GiSimdFmaLane(d14d15, d4d5, d0d1, 3);

  429. 

  430.         d0d1 = GiLoadFloat32(a_ptr);

  431.         a_ptr = a_ptr + 4;

  432.         d4d5 = GiLoadFloat32(b_ptr);

  433.         b_ptr = b_ptr + 4;

  434. 

  435.         d8d9 = GiSimdFmaLane(d8d9, d6d7, d2d3, 0);

  436.         d10d11 = GiSimdFmaLane(d10d11, d6d7, d2d3, 1);

  437.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d2d3, 2);

  438.         d14d15 = GiSimdFmaLane(d14d15, d6d7, d2d3, 3);

  439.     }

  440. 

  441.     if (1 == oddk) {

  442.         d8d9 = GiSimdFmaLane(d8d9, d4d5, d0d1, 0);

  443.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 1);

  444.         d12d13 = GiSimdFmaLane(d12d13, d4d5, d0d1, 2);

  445.         d14d15 = GiSimdFmaLane(d14d15, d4d5, d0d1, 3);

  446. 

  447.     } else {

  448.         d2d3 = GiLoadFloat32(a_ptr);

  449.         a_ptr = a_ptr + 4;

  450.         d6d7 = GiLoadFloat32(b_ptr);

  451.         b_ptr = b_ptr + 4;

  452. 

  453.         d8d9 = GiSimdFmaLane(d8d9, d4d5, d0d1, 0);

  454.         d10d11 = GiSimdFmaLane(d10d11, d4d5, d0d1, 1);

  455.         d12d13 = GiSimdFmaLane(d12d13, d4d5, d0d1, 2);

  456.         d14d15 = GiSimdFmaLane(d14d15, d4d5, d0d1, 3);

  457. 

  458.         d8d9 = GiSimdFmaLane(d8d9, d6d7, d2d3, 0);

  459.         d10d11 = GiSimdFmaLane(d10d11, d6d7, d2d3, 1);

  460.         d12d13 = GiSimdFmaLane(d12d13, d6d7, d2d3, 2);

  461.         d14d15 = GiSimdFmaLane(d14d15, d6d7, d2d3, 3);

  462.     }

  463. 

  464.     if (m_remain == 4) {

  465.         if (n_remain == 4) {

  466.             GiStoreFloat32(r0, d8d9);

  467.             r0 = r0 + 4;

  468.             GiStoreFloat32(r1, d10d11);

  469.             r1 = r1 + 4;

  470.             GiStoreFloat32(r2, d12d13);

  471.             r2 = r2 + 4;

  472.             GiStoreFloat32(r3, d14d15);

  473.             r3 = r3 + 4;

  474.         } else if (n_remain == 3) {

  475.             GiStoreFloat32(tmp, d8d9);

  476.             memcpy(r0, tmp, d_size * 3);

  477.             r0 += 3;

  478. 

  479.             GiStoreFloat32(tmp, d10d11);

  480.             memcpy(r1, tmp, d_size * 3);

  481.             r1 += 3;

  482. 

  483.             GiStoreFloat32(tmp, d12d13);

  484.             memcpy(r2, tmp, d_size * 3);

  485.             r2 += 3;

  486. 

  487.             GiStoreFloat32(tmp, d14d15);

  488.             memcpy(r3, tmp, d_size * 3);

  489.             r3 += 3;

  490.         } else if (n_remain == 2) {

  491.             GiStoreFloat32(tmp, d8d9);

  492.             memcpy(r0, tmp, d_size * 2);

  493.             r0 += 2;

  494. 

  495.             GiStoreFloat32(tmp, d10d11);

  496.             memcpy(r1, tmp, d_size * 2);

  497.             r1 += 2;

  498. 

  499.             GiStoreFloat32(tmp, d12d13);

  500.             memcpy(r2, tmp, d_size * 2);

  501.             r2 += 2;

  502. 

  503.             GiStoreFloat32(tmp, d14d15);

  504.             memcpy(r3, tmp, d_size * 2);

  505.             r3 += 2;

  506.         } else if (n_remain == 1) {

  507.             GiStoreFloat32(tmp, d8d9);

  508.             *r0 = tmp[0];

  509.             r0++;

  510. 

  511.             GiStoreFloat32(tmp, d10d11);

  512.             *r1 = tmp[0];

  513.             r1++;

  514. 

  515.             GiStoreFloat32(tmp, d12d13);

  516.             *r2 = tmp[0];

  517.             r2++;

  518. 

  519.             GiStoreFloat32(tmp, d14d15);

  520.             *r3 = tmp[0];

  521.             r3++;

  522.         }

  523.     } else if (m_remain == 3) {

  524.         if (n_remain == 4) {

  525.             GiStoreFloat32(r0, d8d9);

  526.             r0 = r0 + 4;

  527.             GiStoreFloat32(r1, d10d11);

  528.             r1 = r1 + 4;

  529.             GiStoreFloat32(r2, d12d13);

  530.             r2 = r2 + 4;

  531.         } else if (n_remain == 3) {

  532.             GiStoreFloat32(tmp, d8d9);

  533.             memcpy(r0, tmp, d_size * 3);

  534.             r0 += 3;

  535. 

  536.             GiStoreFloat32(tmp, d10d11);

  537.             memcpy(r1, tmp, d_size * 3);

  538.             r1 += 3;

  539. 

  540.             GiStoreFloat32(tmp, d12d13);

  541.             memcpy(r2, tmp, d_size * 3);

  542.             r2 += 3;

  543.         } else if (n_remain == 2) {

  544.             GiStoreFloat32(tmp, d8d9);

  545.             memcpy(r0, tmp, d_size * 2);

  546.             r0 += 2;

  547. 

  548.             GiStoreFloat32(tmp, d10d11);

  549.             memcpy(r1, tmp, d_size * 2);

  550.             r1 += 2;

  551. 

  552.             GiStoreFloat32(tmp, d12d13);

  553.             memcpy(r2, tmp, d_size * 2);

  554.             r2 += 2;

  555.         } else if (n_remain == 1) {

  556.             GiStoreFloat32(tmp, d8d9);

  557.             *r0 = tmp[0];

  558.             r0++;

  559. 

  560.             GiStoreFloat32(tmp, d10d11);

  561.             *r1 = tmp[0];

  562.             r1++;

  563. 

  564.             GiStoreFloat32(tmp, d12d13);

  565.             *r2 = tmp[0];

  566.             r2++;

  567.         }

  568.     } else if (m_remain == 2) {

  569.         if (n_remain == 4) {

  570.             GiStoreFloat32(r0, d8d9);

  571.             r0 = r0 + 4;

  572.             GiStoreFloat32(r1, d10d11);

  573.             r1 = r1 + 4;

  574.         } else if (n_remain == 3) {

  575.             GiStoreFloat32(tmp, d8d9);

  576.             memcpy(r0, tmp, d_size * 3);

  577.             r0 += 3;

  578. 

  579.             GiStoreFloat32(tmp, d10d11);

  580.             memcpy(r1, tmp, d_size * 3);

  581.             r1 += 3;

  582.         } else if (n_remain == 2) {

  583.             GiStoreFloat32(tmp, d8d9);

  584.             memcpy(r0, tmp, d_size * 2);

  585.             r0 += 2;

  586. 

  587.             GiStoreFloat32(tmp, d10d11);

  588.             memcpy(r1, tmp, d_size * 2);

  589.             r1 += 2;

  590.         } else if (n_remain == 1) {

  591.             GiStoreFloat32(tmp, d8d9);

  592.             *r0 = tmp[0];

  593.             r0++;

  594. 

  595.             GiStoreFloat32(tmp, d10d11);

  596.             *r1 = tmp[0];

  597.             r1++;

  598.         }

  599.     } else if (m_remain == 1) {

  600.         if (n_remain == 4) {

  601.             GiStoreFloat32(r0, d8d9);

  602.             r0 = r0 + 4;

  603.         } else if (n_remain == 3) {

  604.             GiStoreFloat32(tmp, d8d9);

  605.             memcpy(r0, tmp, d_size * 3);

  606.             r0 += 3;

  607.         } else if (n_remain == 2) {

  608.             GiStoreFloat32(tmp, d8d9);

  609.             memcpy(r0, tmp, d_size * 2);

  610.             r0 += 2;

  611.         } else if (n_remain == 1) {

  612.             GiStoreFloat32(tmp, d8d9);

  613.             *r0 = tmp[0];

  614.             r0++;

  615.         }

  616.     }

  617. }

  618. #pragma GCC diagnostic pop

  619. 

  620. void gi_sgemm_4x12_pack_A_n(

  621.         float* outptr, const float* inptr, int ldin, int y0, int ymax, int k0,

  622.         int kmax) {

  623.     float zerobuff[4];

  624.     std::memset(zerobuff, 0, sizeof(float) * 4);

  625. 

  626.     int y = y0;

  627.     for (; y + 3 < ymax; y += 4) {

  628.         const float* inptr0 = inptr + y * ldin + k0;

  629.         const float* inptr1 = inptr0 + ldin;

  630.         const float* inptr2 = inptr1 + ldin;

  631.         const float* inptr3 = inptr2 + ldin;

  632. 

  633.         int K = (kmax - k0);

  634.         for (; K > 3; K -= 4) {

  635.             transpose_4x4_1_s(inptr0, inptr1, inptr2, inptr3, outptr);

  636.         }

  637. 

  638.         interleave_4(inptr0, inptr1, inptr2, inptr3, outptr, 1, K);

  639.     }

  640. 

  641.     for (; y < ymax; y += 4) {

  642.         const float* inptr0 = inptr + y * ldin + k0;

  643.         const float* inptr1 = inptr0 + ldin;

  644.         const float* inptr2 = inptr1 + ldin;

  645.         const float* inptr3 = inptr2 + ldin;

  646. 

  647.         int K = (kmax - k0);

  648.         for (; K > 3; K -= 4) {

  649.             if ((y + 3) >= ymax) {

  650.                 switch ((y + 3) - ymax) {

  651.                     /* Everything falls through in here */

  652.                     case 2:

  653.                         inptr1 = zerobuff;

  654.                         MEGDNN_FALLTHRU

  655.                     case 1:

  656.                         inptr2 = zerobuff;

  657.                         MEGDNN_FALLTHRU

  658.                     case 0:

  659.                         inptr3 = zerobuff;

  660.                         break;

  661.                     default:

  662.                         megdnn_assert(0);

  663.                 }

  664.             }

  665. 

  666.             transpose_4x4_1_s(inptr0, inptr1, inptr2, inptr3, outptr);

  667.         }

  668. 

  669.         if (K > 0) {

  670.             if ((y + 3) >= ymax) {

  671.                 switch ((y + 3) - ymax) {

  672.                     /* Everything falls through in here */

  673.                     case 2:

  674.                         inptr1 = zerobuff;

  675.                         MEGDNN_FALLTHRU

  676.                     case 1:

  677.                         inptr2 = zerobuff;

  678.                         MEGDNN_FALLTHRU

  679.                     case 0:

  680.                         inptr3 = zerobuff;

  681.                         break;

  682.                     default:

  683.                         megdnn_assert(0);

  684.                 }

  685.             }

  686.             interleave_4(inptr0, inptr1, inptr2, inptr3, outptr, 1, K);

  687.         }

  688.     }

  689. }

  690. 

  691. void gi_sgemm_4x12_pack_A_t(

  692.         float* out, const float* in, int ldin, int x0, int xmax, int k0, int kmax) {

  693.     int ksize = kmax - k0;

  694.     int ksize4 = (ksize << 2);

  695.     float* outptr_base = out;

  696. 

  697.     int k = k0;

  698.     for (; k + 3 < kmax; k += 4) {

  699.         const float* inptr = in + k * ldin + x0;

  700.         const float* inptr1 = inptr + ldin;

  701.         const float* inptr2 = inptr1 + ldin;

  702.         const float* inptr3 = inptr2 + ldin;

  703. 

  704.         int x = x0;

  705.         auto outptr = outptr_base;

  706.         for (; x + 4 <= xmax; x += 4) {

  707.             auto outptr_interleave = outptr;

  708.             interleave_4x4_1_s(inptr, inptr1, inptr2, inptr3, outptr_interleave);

  709.             outptr += ksize4;

  710.         }

  711. 

  712.         if (x < xmax) {

  713.             interleave_4(inptr, inptr1, inptr2, inptr3, outptr, 4, xmax - x);

  714.         }

  715. 

  716.         outptr_base += 4 * 4;

  717.     }

  718. 

  719.     for (; k < kmax; k++) {

  720.         const float* inptr = in + k * ldin + x0;

  721.         int x = x0;

  722.         auto outptr = outptr_base;

  723.         for (; x + 4 <= xmax; x += 4) {

  724.             auto outptr_interleave = outptr;

  725.             interleave_1x4_1_s(inptr, outptr_interleave);

  726.             outptr += ksize4;

  727.         }

  728. 

  729.         if (x < xmax) {

  730.             interleave_1(inptr, outptr, 4, xmax - x);

  731.         }

  732. 

  733.         outptr_base += 4;

  734.     }

  735. }

  736. 

  737. void gi_sgemm_4x12_pack_B_n(

  738.         float* out, const float* in, int ldin, int x0, int xmax, int k0, int kmax) {

  739.     int ksize = kmax - k0;

  740.     int ksize12 = ksize * 12;

  741.     int ksize4 = (ksize << 2);

  742.     float* outptr_base = out;

  743.     float* outptr_base4 = outptr_base + (xmax - x0) / 12 * ksize12;

  744. 

  745.     int k = k0;

  746.     for (; k + 3 < kmax; k += 4) {

  747.         const float* inptr = in + k * ldin + x0;

  748.         const float* inptr1 = inptr + ldin;

  749.         const float* inptr2 = inptr1 + ldin;

  750.         const float* inptr3 = inptr2 + ldin;

  751. 

  752.         int x = x0;

  753.         auto outptr = outptr_base;

  754.         for (; x + 12 <= xmax; x += 12) {

  755.             auto outptr_interleave = outptr;

  756.             interleave_4x12_1_s(inptr, inptr1, inptr2, inptr3, outptr_interleave);

  757.             outptr += ksize12;

  758.         }

  759.         outptr = outptr_base4;

  760.         for (; x + 4 <= xmax; x += 4) {

  761.             auto outptr_interleave = outptr;

  762.             interleave_4x4_1_s(inptr, inptr1, inptr2, inptr3, outptr_interleave);

  763.             outptr += ksize4;

  764.         }

  765. 

  766.         if (x < xmax) {

  767.             interleave_4(inptr, inptr1, inptr2, inptr3, outptr, 4, xmax - x);

  768.         }

  769. 

  770.         outptr_base += 12 * 4;

  771.         outptr_base4 += 4 * 4;

  772.     }

  773. 

  774.     for (; k < kmax; k++) {

  775.         const float* inptr = in + k * ldin + x0;

  776.         int x = x0;

  777.         auto outptr = outptr_base;

  778.         for (; x + 12 <= xmax; x += 12) {

  779.             auto outptr_interleave = outptr;

  780.             interleave_1x12_1_s(inptr, outptr_interleave);

  781.             outptr += ksize12;

  782.         }

  783.         outptr = outptr_base4;

  784.         for (; x + 4 <= xmax; x += 4) {

  785.             auto outptr_interleave = outptr;

  786.             interleave_1x4_1_s(inptr, outptr_interleave);

  787.             outptr += ksize4;

  788.         }

  789. 

  790.         if (x < xmax) {

  791.             interleave_1(inptr, outptr, 4, xmax - x);

  792.         }

  793. 

  794.         outptr_base += 12;

  795.         outptr_base4 += 4;

  796.     }

  797. }

  798. 

  799. void gi_sgemm_4x12_pack_B_t(

  800.         float* out, const float* in, int ldin, int y0, int ymax, int k0, int kmax) {

  801.     float* outptr = out;

  802.     const float* inptr = in;

  803.     float zerobuff[4];

  804.     std::memset(zerobuff, 0, sizeof(float) * 4);

  805.     int K12 = 12 * (kmax - k0);

  806. 

  807.     int y = y0;

  808. 

  809.     for (; y + 12 <= ymax; y += 12) {

  810.         int yi = y;

  811.         for (; yi < y + 12; yi += 4) {

  812.             const float* inptr0 = inptr + yi * ldin + k0;

  813.             const float* inptr1 = inptr0 + ldin;

  814.             const float* inptr2 = inptr1 + ldin;

  815.             const float* inptr3 = inptr2 + ldin;

  816.             float* outptr_inner = outptr + yi - y;

  817. 

  818.             int x = (kmax - k0);

  819.             for (; x > 3; x -= 4) {

  820.                 transpose_4x4_1_s(inptr0, inptr1, inptr2, inptr3, outptr_inner, 48);

  821.             }

  822.             for (; x > 0; x--) {

  823.                 *outptr_inner++ = *inptr0++;

  824.                 *outptr_inner++ = *inptr1++;

  825.                 *outptr_inner++ = *inptr2++;

  826.                 *outptr_inner++ = *inptr3++;

  827.                 outptr_inner += 8;

  828.             }

  829.         }

  830.         outptr += K12;

  831.     }

  832. 

  833.     for (; y < ymax; y += 4) {

  834.         const float* inptr0 = inptr + y * ldin + k0;

  835.         const float* inptr1 = inptr0 + ldin;

  836.         const float* inptr2 = inptr1 + ldin;

  837.         const float* inptr3 = inptr2 + ldin;

  838. 

  839.         /* Cope with ragged cases by copying from a buffer of zeroes instead

  840.          */

  841.         int x = (kmax - k0);

  842.         for (; x > 3; x -= 4) {

  843.             if ((y + 3) >= ymax) {

  844.                 switch ((y + 3) - ymax) {

  845.                     /* Everything falls through in here */

  846.                     case 2:

  847.                         inptr1 = zerobuff;

  848.                         MEGDNN_FALLTHRU

  849.                     case 1:

  850.                         inptr2 = zerobuff;

  851.                         MEGDNN_FALLTHRU

  852.                     case 0:

  853.                         inptr3 = zerobuff;

  854.                         break;

  855.                     default:

  856.                         megdnn_assert(0);

  857.                 }

  858.             }

  859. 

  860.             transpose_4x4_1_s(inptr0, inptr1, inptr2, inptr3, outptr);

  861.         }

  862. 

  863.         if (x > 0) {

  864.             if ((y + 3) >= ymax) {

  865.                 switch ((y + 3) - ymax) {

  866.                     /* Everything falls through in here */

  867.                     case 2:

  868.                         inptr1 = zerobuff;

  869.                         MEGDNN_FALLTHRU

  870.                     case 1:

  871.                         inptr2 = zerobuff;

  872.                         MEGDNN_FALLTHRU

  873.                     case 0:

  874.                         inptr3 = zerobuff;

  875.                         break;

  876.                     default:

  877.                         megdnn_assert(0);

  878.                 }

  879.             }

  880.             interleave_4(inptr0, inptr1, inptr2, inptr3, outptr, 1, x);

  881.         }

  882.     }

  883. }

  884. 

  885. }  // namespace

  886. 

  887. MEGDNN_REG_GEMM_STRATEGY_IMPL(gi_sgemm_4x12);

  888. 

  889. void gi_sgemm_4x12::pack_A(

  890.         float* out, const float* in, int ldin, int y0, int ymax, int k0, int kmax,

  891.         bool transpose_A) const {

  892.     if (transpose_A) {

  893.         gi_sgemm_4x12_pack_A_t(out, in, ldin, y0, ymax, k0, kmax);

  894.     } else {

  895.         gi_sgemm_4x12_pack_A_n(out, in, ldin, y0, ymax, k0, kmax);

  896.     }

  897. }

  898. 

  899. void gi_sgemm_4x12::pack_B(

  900.         float* out, const float* in, int ldin, int x0, int xmax, int k0, int kmax,

  901.         bool transpose_B) const {

  902.     if (transpose_B) {

  903.         gi_sgemm_4x12_pack_B_t(out, in, ldin, x0, xmax, k0, kmax);

  904.     } else {

  905.         gi_sgemm_4x12_pack_B_n(out, in, ldin, x0, xmax, k0, kmax);

  906.     }

  907. }

  908. 

  909. void gi_sgemm_4x12::kern(

  910.         const float* packA, const float* packB, size_t M, size_t N, size_t K, float* C,

  911.         size_t LDC, bool is_first_k, const float*, float*) const {

  912.     megdnn_assert(

  913.             A_dtype.enumv() == B_dtype.enumv() && A_dtype.enumv() == C_dtype.enumv() &&

  914.             A_dtype.enumv() == DTypeEnum::Float32);

  915.     MEGDNN_MARK_USED_VAR(A_dtype);

  916.     MEGDNN_MARK_USED_VAR(B_dtype);

  917.     MEGDNN_MARK_USED_VAR(C_dtype);

  918. 

  919.     constexpr size_t A_INTERLEAVE = 4;

  920.     constexpr size_t B_INTERLEAVE = 12;

  921.     const int K12 = K * 12;

  922.     const int K4 = K * 4;

  923. 

  924.     size_t m = 0;

  925.     for (; m < M; m += A_INTERLEAVE) {

  926.         float* output = C + (m * LDC);

  927. 

  928.         size_t n = 0;

  929.         const float* cur_packB = packB;

  930.         for (; n + B_INTERLEAVE - 1 < N; n += B_INTERLEAVE) {

  931.             kern_4x12(

  932.                     packA, cur_packB, K, output, LDC, is_first_k,

  933.                     std::min<size_t>(M - m, 4));

  934.             output += B_INTERLEAVE;

  935.             cur_packB += K12;

  936.         }

  937. 

  938.         for (; n < N; n += 4) {

  939.             kern_4x4(

  940.                     packA, cur_packB, K, output, LDC, is_first_k,

  941.                     std::min<size_t>(M - m, 4), std::min<size_t>(N - n, 4));

  942.             output += 4;

  943.             cur_packB += K4;

  944.         }

  945. 

  946.         packA += K4;

  947.     }

  948. }

  949. 

  950. // vim: syntax=cpp.doxygen