OSchip
/
OpenBLAS
Not watched
1
0
Fork 0
Code
Releases 66 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
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: d96daa220d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd96daa220d'
${ noResults }
OpenBLAS/kernel/riscv64/dtrmm_kernel_8x8_zvl256b.c

1069 lines
36 kB
Raw Blame History 

  1. /*

  2. 

  3. AUTOGENERATED KERNEL

  4. Settings:

  5.  LMUL=1

  6.  M=8

  7.  M_tail_scalar_from=2

  8.  N=8

  9.  __riscv_='__riscv_'

  10.  complex=False

  11.  conjugate=False

  12.  cpu='zvl256b'

  13.  force_acc_double=False

  14.  index_type='BLASLONG'

  15.  op='trmm'

  16.  param_precision='double'

  17.  reg_width_bits=256

  18.  tail_policy=''

  19.  trace=False

  20. 

  21. Derived:

  22.  ELEN_ACC=64

  23.  ELEN_PARAM=64

  24.  LMUL_ACC=1

  25.  VFMACC='__riscv_vfmacc_vf_f64m1'

  26.  VFMUL='__riscv_vfmul_vf_f64m1'

  27.  VLEV='__riscv_vle64_v_f64m1'

  28.  VLSEV='__riscv_vlse64_v_f64m1'

  29.  VMACC_TO_ACC='__riscv_vfmacc_vf_f64m1'

  30.  VMUL_TO_ACC='__riscv_vfmul_vf_f64m1'

  31.  VSETVL='__riscv_vsetvl_e64m1'

  32.  VSEV='__riscv_vse64_v_f64m1'

  33.  VSSEV='__riscv_vsse64_v_f64m1'

  34.  acc_vector_t='vfloat64m1_t'

  35.  output='dtrmm_kernel_8x8_zvl256b.c'

  36.  param_scalar_t='double'

  37.  param_vector_t='vfloat64m1_t'

  38. 

  39. */

  40. 

  41. #include "common.h"

  42. 

  43. 

  44. 

  45. #if defined(LEFT) != defined(TRANSA)

  46.     #define BACKWARDS

  47. #endif

  48. 

  49. int CNAME(BLASLONG M, BLASLONG N, BLASLONG K, FLOAT alpha, FLOAT* A, FLOAT* B, FLOAT* C, BLASLONG ldc, BLASLONG offset)

  50. 

  51. {

  52.     BLASLONG gvl = 0;

  53.     BLASLONG m_top = 0;

  54.     BLASLONG n_top = 0;

  55. 

  56. 

  57.     // -- MAIN PASS

  58. 

  59.     for (BLASLONG j=0; j<N/8; j+=1) {

  60.         m_top = 0;

  61.         BLASLONG gvl = __riscv_vsetvl_e64m1(4);

  62. 

  63. 

  64.         for (BLASLONG i=0; i<M/8; i+=1) {

  65.             BLASLONG ai=m_top*K;

  66.             BLASLONG bi=n_top*K;

  67.             BLASLONG pass_K = K;

  68.             #ifdef LEFT

  69.                 BLASLONG off = offset + m_top;

  70.             #else

  71.                 BLASLONG off = -offset + n_top;

  72.             #endif

  73.             #ifdef BACKWARDS

  74.                 ai += off*8;

  75.                 bi += off*8;

  76.                 pass_K -= off;

  77.             #else

  78.                 #ifdef LEFT

  79.                     pass_K = off + 8;

  80.                 #else

  81.                     pass_K = off + 8;

  82.                 #endif

  83.             #endif

  84.             double B0 = B[bi+0];

  85.             double B1 = B[bi+1];

  86.             double B2 = B[bi+2];

  87.             double B3 = B[bi+3];

  88.             double B4 = B[bi+4];

  89.             double B5 = B[bi+5];

  90.             double B6 = B[bi+6];

  91.             double B7 = B[bi+7];

  92.             bi += 8;

  93. 

  94.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  95.             vfloat64m1_t A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  96.             ai += 8;

  97. 

  98.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  99.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A1, B0, gvl);

  100.             vfloat64m1_t result2 = __riscv_vfmul_vf_f64m1( A0, B1, gvl);

  101.             vfloat64m1_t result3 = __riscv_vfmul_vf_f64m1( A1, B1, gvl);

  102.             vfloat64m1_t result4 = __riscv_vfmul_vf_f64m1( A0, B2, gvl);

  103.             vfloat64m1_t result5 = __riscv_vfmul_vf_f64m1( A1, B2, gvl);

  104.             vfloat64m1_t result6 = __riscv_vfmul_vf_f64m1( A0, B3, gvl);

  105.             vfloat64m1_t result7 = __riscv_vfmul_vf_f64m1( A1, B3, gvl);

  106.             vfloat64m1_t result8 = __riscv_vfmul_vf_f64m1( A0, B4, gvl);

  107.             vfloat64m1_t result9 = __riscv_vfmul_vf_f64m1( A1, B4, gvl);

  108.             vfloat64m1_t result10 = __riscv_vfmul_vf_f64m1( A0, B5, gvl);

  109.             vfloat64m1_t result11 = __riscv_vfmul_vf_f64m1( A1, B5, gvl);

  110.             vfloat64m1_t result12 = __riscv_vfmul_vf_f64m1( A0, B6, gvl);

  111.             vfloat64m1_t result13 = __riscv_vfmul_vf_f64m1( A1, B6, gvl);

  112.             vfloat64m1_t result14 = __riscv_vfmul_vf_f64m1( A0, B7, gvl);

  113.             vfloat64m1_t result15 = __riscv_vfmul_vf_f64m1( A1, B7, gvl);

  114. 

  115.             for(BLASLONG k=1; k<pass_K; k++) {

  116.                 B0 = B[bi+0];

  117.                 B1 = B[bi+1];

  118.                 B2 = B[bi+2];

  119.                 B3 = B[bi+3];

  120.                 B4 = B[bi+4];

  121.                 B5 = B[bi+5];

  122.                 B6 = B[bi+6];

  123.                 B7 = B[bi+7];

  124.                 bi += 8;

  125. 

  126.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  127.                 A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  128.                 ai += 8;

  129. 

  130.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  131.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B0, A1, gvl);

  132.                 result2 = __riscv_vfmacc_vf_f64m1( result2, B1, A0, gvl);

  133.                 result3 = __riscv_vfmacc_vf_f64m1( result3, B1, A1, gvl);

  134.                 result4 = __riscv_vfmacc_vf_f64m1( result4, B2, A0, gvl);

  135.                 result5 = __riscv_vfmacc_vf_f64m1( result5, B2, A1, gvl);

  136.                 result6 = __riscv_vfmacc_vf_f64m1( result6, B3, A0, gvl);

  137.                 result7 = __riscv_vfmacc_vf_f64m1( result7, B3, A1, gvl);

  138.                 result8 = __riscv_vfmacc_vf_f64m1( result8, B4, A0, gvl);

  139.                 result9 = __riscv_vfmacc_vf_f64m1( result9, B4, A1, gvl);

  140.                 result10 = __riscv_vfmacc_vf_f64m1( result10, B5, A0, gvl);

  141.                 result11 = __riscv_vfmacc_vf_f64m1( result11, B5, A1, gvl);

  142.                 result12 = __riscv_vfmacc_vf_f64m1( result12, B6, A0, gvl);

  143.                 result13 = __riscv_vfmacc_vf_f64m1( result13, B6, A1, gvl);

  144.                 result14 = __riscv_vfmacc_vf_f64m1( result14, B7, A0, gvl);

  145.                 result15 = __riscv_vfmacc_vf_f64m1( result15, B7, A1, gvl);

  146.             }

  147. 

  148. 

  149.             BLASLONG ci=n_top*ldc+m_top;

  150. 

  151.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  152.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  153.             vfloat64m1_t c2 = __riscv_vfmul_vf_f64m1( result2, alpha, gvl );

  154.             vfloat64m1_t c3 = __riscv_vfmul_vf_f64m1( result3, alpha, gvl );

  155.             vfloat64m1_t c4 = __riscv_vfmul_vf_f64m1( result4, alpha, gvl );

  156.             vfloat64m1_t c5 = __riscv_vfmul_vf_f64m1( result5, alpha, gvl );

  157.             vfloat64m1_t c6 = __riscv_vfmul_vf_f64m1( result6, alpha, gvl );

  158.             vfloat64m1_t c7 = __riscv_vfmul_vf_f64m1( result7, alpha, gvl );

  159.             vfloat64m1_t c8 = __riscv_vfmul_vf_f64m1( result8, alpha, gvl );

  160.             vfloat64m1_t c9 = __riscv_vfmul_vf_f64m1( result9, alpha, gvl );

  161.             vfloat64m1_t c10 = __riscv_vfmul_vf_f64m1( result10, alpha, gvl );

  162.             vfloat64m1_t c11 = __riscv_vfmul_vf_f64m1( result11, alpha, gvl );

  163.             vfloat64m1_t c12 = __riscv_vfmul_vf_f64m1( result12, alpha, gvl );

  164.             vfloat64m1_t c13 = __riscv_vfmul_vf_f64m1( result13, alpha, gvl );

  165.             vfloat64m1_t c14 = __riscv_vfmul_vf_f64m1( result14, alpha, gvl );

  166.             vfloat64m1_t c15 = __riscv_vfmul_vf_f64m1( result15, alpha, gvl );

  167.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += gvl;

  168.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl); ci += ldc-gvl*1;

  169.             __riscv_vse64_v_f64m1( &C[ci], c2, gvl); ci += gvl;

  170.             __riscv_vse64_v_f64m1( &C[ci], c3, gvl); ci += ldc-gvl*1;

  171.             __riscv_vse64_v_f64m1( &C[ci], c4, gvl); ci += gvl;

  172.             __riscv_vse64_v_f64m1( &C[ci], c5, gvl); ci += ldc-gvl*1;

  173.             __riscv_vse64_v_f64m1( &C[ci], c6, gvl); ci += gvl;

  174.             __riscv_vse64_v_f64m1( &C[ci], c7, gvl); ci += ldc-gvl*1;

  175.             __riscv_vse64_v_f64m1( &C[ci], c8, gvl); ci += gvl;

  176.             __riscv_vse64_v_f64m1( &C[ci], c9, gvl); ci += ldc-gvl*1;

  177.             __riscv_vse64_v_f64m1( &C[ci], c10, gvl); ci += gvl;

  178.             __riscv_vse64_v_f64m1( &C[ci], c11, gvl); ci += ldc-gvl*1;

  179.             __riscv_vse64_v_f64m1( &C[ci], c12, gvl); ci += gvl;

  180.             __riscv_vse64_v_f64m1( &C[ci], c13, gvl); ci += ldc-gvl*1;

  181.             __riscv_vse64_v_f64m1( &C[ci], c14, gvl); ci += gvl;

  182.             __riscv_vse64_v_f64m1( &C[ci], c15, gvl);

  183.             m_top += 8;

  184.         }

  185. 

  186. 

  187. 

  188.         // -- tails for main pass

  189. 

  190.         if( M & 4 ) {

  191.             gvl = __riscv_vsetvl_e64m1(4);

  192. 

  193.             BLASLONG ai=m_top*K;

  194.             BLASLONG bi=n_top*K;

  195.             BLASLONG pass_K = K;

  196.             #ifdef LEFT

  197.                 BLASLONG off = offset + m_top;

  198.             #else

  199.                 BLASLONG off = -offset + n_top;

  200.             #endif

  201.             #ifdef BACKWARDS

  202.                 ai += off*4;

  203.                 bi += off*8;

  204.                 pass_K -= off;

  205.             #else

  206.                 #ifdef LEFT

  207.                     pass_K = off + 4;

  208.                 #else

  209.                     pass_K = off + 8;

  210.                 #endif

  211.             #endif

  212.             double B0 = B[bi+0];

  213.             double B1 = B[bi+1];

  214.             double B2 = B[bi+2];

  215.             double B3 = B[bi+3];

  216.             double B4 = B[bi+4];

  217.             double B5 = B[bi+5];

  218.             double B6 = B[bi+6];

  219.             double B7 = B[bi+7];

  220.             bi += 8;

  221. 

  222.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  223.             ai += 4;

  224. 

  225.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  226.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A0, B1, gvl);

  227.             vfloat64m1_t result2 = __riscv_vfmul_vf_f64m1( A0, B2, gvl);

  228.             vfloat64m1_t result3 = __riscv_vfmul_vf_f64m1( A0, B3, gvl);

  229.             vfloat64m1_t result4 = __riscv_vfmul_vf_f64m1( A0, B4, gvl);

  230.             vfloat64m1_t result5 = __riscv_vfmul_vf_f64m1( A0, B5, gvl);

  231.             vfloat64m1_t result6 = __riscv_vfmul_vf_f64m1( A0, B6, gvl);

  232.             vfloat64m1_t result7 = __riscv_vfmul_vf_f64m1( A0, B7, gvl);

  233. 

  234.             for(BLASLONG k=1; k<pass_K; k++) {

  235.                 B0 = B[bi+0];

  236.                 B1 = B[bi+1];

  237.                 B2 = B[bi+2];

  238.                 B3 = B[bi+3];

  239.                 B4 = B[bi+4];

  240.                 B5 = B[bi+5];

  241.                 B6 = B[bi+6];

  242.                 B7 = B[bi+7];

  243.                 bi += 8;

  244. 

  245.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  246.                 ai += 4;

  247. 

  248.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  249.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B1, A0, gvl);

  250.                 result2 = __riscv_vfmacc_vf_f64m1( result2, B2, A0, gvl);

  251.                 result3 = __riscv_vfmacc_vf_f64m1( result3, B3, A0, gvl);

  252.                 result4 = __riscv_vfmacc_vf_f64m1( result4, B4, A0, gvl);

  253.                 result5 = __riscv_vfmacc_vf_f64m1( result5, B5, A0, gvl);

  254.                 result6 = __riscv_vfmacc_vf_f64m1( result6, B6, A0, gvl);

  255.                 result7 = __riscv_vfmacc_vf_f64m1( result7, B7, A0, gvl);

  256.             }

  257. 

  258. 

  259.             BLASLONG ci=n_top*ldc+m_top;

  260. 

  261.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  262.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  263.             vfloat64m1_t c2 = __riscv_vfmul_vf_f64m1( result2, alpha, gvl );

  264.             vfloat64m1_t c3 = __riscv_vfmul_vf_f64m1( result3, alpha, gvl );

  265.             vfloat64m1_t c4 = __riscv_vfmul_vf_f64m1( result4, alpha, gvl );

  266.             vfloat64m1_t c5 = __riscv_vfmul_vf_f64m1( result5, alpha, gvl );

  267.             vfloat64m1_t c6 = __riscv_vfmul_vf_f64m1( result6, alpha, gvl );

  268.             vfloat64m1_t c7 = __riscv_vfmul_vf_f64m1( result7, alpha, gvl );

  269.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += ldc-gvl*0;

  270.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl); ci += ldc-gvl*0;

  271.             __riscv_vse64_v_f64m1( &C[ci], c2, gvl); ci += ldc-gvl*0;

  272.             __riscv_vse64_v_f64m1( &C[ci], c3, gvl); ci += ldc-gvl*0;

  273.             __riscv_vse64_v_f64m1( &C[ci], c4, gvl); ci += ldc-gvl*0;

  274.             __riscv_vse64_v_f64m1( &C[ci], c5, gvl); ci += ldc-gvl*0;

  275.             __riscv_vse64_v_f64m1( &C[ci], c6, gvl); ci += ldc-gvl*0;

  276.             __riscv_vse64_v_f64m1( &C[ci], c7, gvl);

  277.             m_top += 4;

  278.         }

  279. 

  280. 

  281.         if( M & 2 ) {

  282.             double result0 = 0;

  283.             double result1 = 0;

  284.             double result2 = 0;

  285.             double result3 = 0;

  286.             double result4 = 0;

  287.             double result5 = 0;

  288.             double result6 = 0;

  289.             double result7 = 0;

  290.             double result8 = 0;

  291.             double result9 = 0;

  292.             double result10 = 0;

  293.             double result11 = 0;

  294.             double result12 = 0;

  295.             double result13 = 0;

  296.             double result14 = 0;

  297.             double result15 = 0;

  298.             BLASLONG ai=m_top*K;

  299.             BLASLONG bi=n_top*K;

  300.             BLASLONG pass_K = K;

  301.             #ifdef LEFT

  302.                 BLASLONG off = offset + m_top;

  303.             #else

  304.                 BLASLONG off = -offset + n_top;

  305.             #endif

  306.             #ifdef BACKWARDS

  307.                 ai += off*2;

  308.                 bi += off*8;

  309.                 pass_K -= off;

  310.             #else

  311.                 #ifdef LEFT

  312.                     pass_K = off + 2;

  313.                 #else

  314.                     pass_K = off + 8;

  315.                 #endif

  316.             #endif

  317. 

  318.             for(BLASLONG k=0; k<pass_K; k++) {

  319.                 result0+=A[ai+0]*B[bi+0];

  320.                 result1+=A[ai+1]*B[bi+0];

  321.                 result2+=A[ai+0]*B[bi+1];

  322.                 result3+=A[ai+1]*B[bi+1];

  323.                 result4+=A[ai+0]*B[bi+2];

  324.                 result5+=A[ai+1]*B[bi+2];

  325.                 result6+=A[ai+0]*B[bi+3];

  326.                 result7+=A[ai+1]*B[bi+3];

  327.                 result8+=A[ai+0]*B[bi+4];

  328.                 result9+=A[ai+1]*B[bi+4];

  329.                 result10+=A[ai+0]*B[bi+5];

  330.                 result11+=A[ai+1]*B[bi+5];

  331.                 result12+=A[ai+0]*B[bi+6];

  332.                 result13+=A[ai+1]*B[bi+6];

  333.                 result14+=A[ai+0]*B[bi+7];

  334.                 result15+=A[ai+1]*B[bi+7];

  335.                 ai+=2;

  336.                 bi+=8;

  337.             }

  338. 

  339.             BLASLONG ci=n_top*ldc+m_top;

  340.             C[ci+0*ldc+0] = alpha * result0;

  341.             C[ci+0*ldc+1] = alpha * result1;

  342.             C[ci+1*ldc+0] = alpha * result2;

  343.             C[ci+1*ldc+1] = alpha * result3;

  344.             C[ci+2*ldc+0] = alpha * result4;

  345.             C[ci+2*ldc+1] = alpha * result5;

  346.             C[ci+3*ldc+0] = alpha * result6;

  347.             C[ci+3*ldc+1] = alpha * result7;

  348.             C[ci+4*ldc+0] = alpha * result8;

  349.             C[ci+4*ldc+1] = alpha * result9;

  350.             C[ci+5*ldc+0] = alpha * result10;

  351.             C[ci+5*ldc+1] = alpha * result11;

  352.             C[ci+6*ldc+0] = alpha * result12;

  353.             C[ci+6*ldc+1] = alpha * result13;

  354.             C[ci+7*ldc+0] = alpha * result14;

  355.             C[ci+7*ldc+1] = alpha * result15;

  356.             m_top+=2;

  357.         }

  358. 

  359. 

  360.         if( M & 1 ) {

  361.             double result0 = 0;

  362.             double result1 = 0;

  363.             double result2 = 0;

  364.             double result3 = 0;

  365.             double result4 = 0;

  366.             double result5 = 0;

  367.             double result6 = 0;

  368.             double result7 = 0;

  369.             BLASLONG ai=m_top*K;

  370.             BLASLONG bi=n_top*K;

  371.             BLASLONG pass_K = K;

  372.             #ifdef LEFT

  373.                 BLASLONG off = offset + m_top;

  374.             #else

  375.                 BLASLONG off = -offset + n_top;

  376.             #endif

  377.             #ifdef BACKWARDS

  378.                 ai += off*1;

  379.                 bi += off*8;

  380.                 pass_K -= off;

  381.             #else

  382.                 #ifdef LEFT

  383.                     pass_K = off + 1;

  384.                 #else

  385.                     pass_K = off + 8;

  386.                 #endif

  387.             #endif

  388. 

  389.             for(BLASLONG k=0; k<pass_K; k++) {

  390.                 result0+=A[ai+0]*B[bi+0];

  391.                 result1+=A[ai+0]*B[bi+1];

  392.                 result2+=A[ai+0]*B[bi+2];

  393.                 result3+=A[ai+0]*B[bi+3];

  394.                 result4+=A[ai+0]*B[bi+4];

  395.                 result5+=A[ai+0]*B[bi+5];

  396.                 result6+=A[ai+0]*B[bi+6];

  397.                 result7+=A[ai+0]*B[bi+7];

  398.                 ai+=1;

  399.                 bi+=8;

  400.             }

  401. 

  402.             BLASLONG ci=n_top*ldc+m_top;

  403.             C[ci+0*ldc+0] = alpha * result0;

  404.             C[ci+1*ldc+0] = alpha * result1;

  405.             C[ci+2*ldc+0] = alpha * result2;

  406.             C[ci+3*ldc+0] = alpha * result3;

  407.             C[ci+4*ldc+0] = alpha * result4;

  408.             C[ci+5*ldc+0] = alpha * result5;

  409.             C[ci+6*ldc+0] = alpha * result6;

  410.             C[ci+7*ldc+0] = alpha * result7;

  411.             m_top+=1;

  412.         }

  413. 

  414.         n_top += 8;

  415.     }

  416. 

  417. 

  418. 

  419.     // -- tails for N=4

  420. 

  421.     if( N & 4 ) {

  422.         gvl = __riscv_vsetvl_e64m1(4);

  423.         m_top = 0;

  424. 

  425.         for (BLASLONG i=0; i<M/8; i+=1) {

  426.             BLASLONG ai=m_top*K;

  427.             BLASLONG bi=n_top*K;

  428.             BLASLONG pass_K = K;

  429.             #ifdef LEFT

  430.                 BLASLONG off = offset + m_top;

  431.             #else

  432.                 BLASLONG off = -offset + n_top;

  433.             #endif

  434.             #ifdef BACKWARDS

  435.                 ai += off*8;

  436.                 bi += off*4;

  437.                 pass_K -= off;

  438.             #else

  439.                 #ifdef LEFT

  440.                     pass_K = off + 8;

  441.                 #else

  442.                     pass_K = off + 4;

  443.                 #endif

  444.             #endif

  445.             double B0 = B[bi+0];

  446.             double B1 = B[bi+1];

  447.             double B2 = B[bi+2];

  448.             double B3 = B[bi+3];

  449.             bi += 4;

  450. 

  451.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  452.             vfloat64m1_t A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  453.             ai += 8;

  454. 

  455.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  456.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A1, B0, gvl);

  457.             vfloat64m1_t result2 = __riscv_vfmul_vf_f64m1( A0, B1, gvl);

  458.             vfloat64m1_t result3 = __riscv_vfmul_vf_f64m1( A1, B1, gvl);

  459.             vfloat64m1_t result4 = __riscv_vfmul_vf_f64m1( A0, B2, gvl);

  460.             vfloat64m1_t result5 = __riscv_vfmul_vf_f64m1( A1, B2, gvl);

  461.             vfloat64m1_t result6 = __riscv_vfmul_vf_f64m1( A0, B3, gvl);

  462.             vfloat64m1_t result7 = __riscv_vfmul_vf_f64m1( A1, B3, gvl);

  463. 

  464.             for(BLASLONG k=1; k<pass_K; k++) {

  465.                 B0 = B[bi+0];

  466.                 B1 = B[bi+1];

  467.                 B2 = B[bi+2];

  468.                 B3 = B[bi+3];

  469.                 bi += 4;

  470. 

  471.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  472.                 A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  473.                 ai += 8;

  474. 

  475.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  476.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B0, A1, gvl);

  477.                 result2 = __riscv_vfmacc_vf_f64m1( result2, B1, A0, gvl);

  478.                 result3 = __riscv_vfmacc_vf_f64m1( result3, B1, A1, gvl);

  479.                 result4 = __riscv_vfmacc_vf_f64m1( result4, B2, A0, gvl);

  480.                 result5 = __riscv_vfmacc_vf_f64m1( result5, B2, A1, gvl);

  481.                 result6 = __riscv_vfmacc_vf_f64m1( result6, B3, A0, gvl);

  482.                 result7 = __riscv_vfmacc_vf_f64m1( result7, B3, A1, gvl);

  483.             }

  484. 

  485. 

  486.             BLASLONG ci=n_top*ldc+m_top;

  487. 

  488.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  489.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  490.             vfloat64m1_t c2 = __riscv_vfmul_vf_f64m1( result2, alpha, gvl );

  491.             vfloat64m1_t c3 = __riscv_vfmul_vf_f64m1( result3, alpha, gvl );

  492.             vfloat64m1_t c4 = __riscv_vfmul_vf_f64m1( result4, alpha, gvl );

  493.             vfloat64m1_t c5 = __riscv_vfmul_vf_f64m1( result5, alpha, gvl );

  494.             vfloat64m1_t c6 = __riscv_vfmul_vf_f64m1( result6, alpha, gvl );

  495.             vfloat64m1_t c7 = __riscv_vfmul_vf_f64m1( result7, alpha, gvl );

  496.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += gvl;

  497.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl); ci += ldc-gvl*1;

  498.             __riscv_vse64_v_f64m1( &C[ci], c2, gvl); ci += gvl;

  499.             __riscv_vse64_v_f64m1( &C[ci], c3, gvl); ci += ldc-gvl*1;

  500.             __riscv_vse64_v_f64m1( &C[ci], c4, gvl); ci += gvl;

  501.             __riscv_vse64_v_f64m1( &C[ci], c5, gvl); ci += ldc-gvl*1;

  502.             __riscv_vse64_v_f64m1( &C[ci], c6, gvl); ci += gvl;

  503.             __riscv_vse64_v_f64m1( &C[ci], c7, gvl);

  504.             m_top += 8;

  505.         }

  506. 

  507. 

  508.         if( M & 4 ) {

  509.             gvl = __riscv_vsetvl_e64m1(4);

  510. 

  511.             BLASLONG ai=m_top*K;

  512.             BLASLONG bi=n_top*K;

  513.             BLASLONG pass_K = K;

  514.             #ifdef LEFT

  515.                 BLASLONG off = offset + m_top;

  516.             #else

  517.                 BLASLONG off = -offset + n_top;

  518.             #endif

  519.             #ifdef BACKWARDS

  520.                 ai += off*4;

  521.                 bi += off*4;

  522.                 pass_K -= off;

  523.             #else

  524.                 #ifdef LEFT

  525.                     pass_K = off + 4;

  526.                 #else

  527.                     pass_K = off + 4;

  528.                 #endif

  529.             #endif

  530.             double B0 = B[bi+0];

  531.             double B1 = B[bi+1];

  532.             double B2 = B[bi+2];

  533.             double B3 = B[bi+3];

  534.             bi += 4;

  535. 

  536.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  537.             ai += 4;

  538. 

  539.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  540.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A0, B1, gvl);

  541.             vfloat64m1_t result2 = __riscv_vfmul_vf_f64m1( A0, B2, gvl);

  542.             vfloat64m1_t result3 = __riscv_vfmul_vf_f64m1( A0, B3, gvl);

  543. 

  544.             for(BLASLONG k=1; k<pass_K; k++) {

  545.                 B0 = B[bi+0];

  546.                 B1 = B[bi+1];

  547.                 B2 = B[bi+2];

  548.                 B3 = B[bi+3];

  549.                 bi += 4;

  550. 

  551.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  552.                 ai += 4;

  553. 

  554.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  555.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B1, A0, gvl);

  556.                 result2 = __riscv_vfmacc_vf_f64m1( result2, B2, A0, gvl);

  557.                 result3 = __riscv_vfmacc_vf_f64m1( result3, B3, A0, gvl);

  558.             }

  559. 

  560. 

  561.             BLASLONG ci=n_top*ldc+m_top;

  562. 

  563.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  564.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  565.             vfloat64m1_t c2 = __riscv_vfmul_vf_f64m1( result2, alpha, gvl );

  566.             vfloat64m1_t c3 = __riscv_vfmul_vf_f64m1( result3, alpha, gvl );

  567.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += ldc-gvl*0;

  568.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl); ci += ldc-gvl*0;

  569.             __riscv_vse64_v_f64m1( &C[ci], c2, gvl); ci += ldc-gvl*0;

  570.             __riscv_vse64_v_f64m1( &C[ci], c3, gvl);

  571.             m_top += 4;

  572.         }

  573. 

  574. 

  575.         if( M & 2 ) {

  576.             double result0 = 0;

  577.             double result1 = 0;

  578.             double result2 = 0;

  579.             double result3 = 0;

  580.             double result4 = 0;

  581.             double result5 = 0;

  582.             double result6 = 0;

  583.             double result7 = 0;

  584.             BLASLONG ai=m_top*K;

  585.             BLASLONG bi=n_top*K;

  586.             BLASLONG pass_K = K;

  587.             #ifdef LEFT

  588.                 BLASLONG off = offset + m_top;

  589.             #else

  590.                 BLASLONG off = -offset + n_top;

  591.             #endif

  592.             #ifdef BACKWARDS

  593.                 ai += off*2;

  594.                 bi += off*4;

  595.                 pass_K -= off;

  596.             #else

  597.                 #ifdef LEFT

  598.                     pass_K = off + 2;

  599.                 #else

  600.                     pass_K = off + 4;

  601.                 #endif

  602.             #endif

  603. 

  604.             for(BLASLONG k=0; k<pass_K; k++) {

  605.                 result0+=A[ai+0]*B[bi+0];

  606.                 result1+=A[ai+1]*B[bi+0];

  607.                 result2+=A[ai+0]*B[bi+1];

  608.                 result3+=A[ai+1]*B[bi+1];

  609.                 result4+=A[ai+0]*B[bi+2];

  610.                 result5+=A[ai+1]*B[bi+2];

  611.                 result6+=A[ai+0]*B[bi+3];

  612.                 result7+=A[ai+1]*B[bi+3];

  613.                 ai+=2;

  614.                 bi+=4;

  615.             }

  616. 

  617.             BLASLONG ci=n_top*ldc+m_top;

  618.             C[ci+0*ldc+0] = alpha * result0;

  619.             C[ci+0*ldc+1] = alpha * result1;

  620.             C[ci+1*ldc+0] = alpha * result2;

  621.             C[ci+1*ldc+1] = alpha * result3;

  622.             C[ci+2*ldc+0] = alpha * result4;

  623.             C[ci+2*ldc+1] = alpha * result5;

  624.             C[ci+3*ldc+0] = alpha * result6;

  625.             C[ci+3*ldc+1] = alpha * result7;

  626.             m_top+=2;

  627.         }

  628. 

  629. 

  630.         if( M & 1 ) {

  631.             double result0 = 0;

  632.             double result1 = 0;

  633.             double result2 = 0;

  634.             double result3 = 0;

  635.             BLASLONG ai=m_top*K;

  636.             BLASLONG bi=n_top*K;

  637.             BLASLONG pass_K = K;

  638.             #ifdef LEFT

  639.                 BLASLONG off = offset + m_top;

  640.             #else

  641.                 BLASLONG off = -offset + n_top;

  642.             #endif

  643.             #ifdef BACKWARDS

  644.                 ai += off*1;

  645.                 bi += off*4;

  646.                 pass_K -= off;

  647.             #else

  648.                 #ifdef LEFT

  649.                     pass_K = off + 1;

  650.                 #else

  651.                     pass_K = off + 4;

  652.                 #endif

  653.             #endif

  654. 

  655.             for(BLASLONG k=0; k<pass_K; k++) {

  656.                 result0+=A[ai+0]*B[bi+0];

  657.                 result1+=A[ai+0]*B[bi+1];

  658.                 result2+=A[ai+0]*B[bi+2];

  659.                 result3+=A[ai+0]*B[bi+3];

  660.                 ai+=1;

  661.                 bi+=4;

  662.             }

  663. 

  664.             BLASLONG ci=n_top*ldc+m_top;

  665.             C[ci+0*ldc+0] = alpha * result0;

  666.             C[ci+1*ldc+0] = alpha * result1;

  667.             C[ci+2*ldc+0] = alpha * result2;

  668.             C[ci+3*ldc+0] = alpha * result3;

  669.             m_top+=1;

  670.         }

  671. 

  672.         n_top += 4;

  673.     }

  674. 

  675. 

  676. 

  677.     // -- tails for N=2

  678. 

  679.     if( N & 2 ) {

  680.         gvl = __riscv_vsetvl_e64m1(4);

  681.         m_top = 0;

  682. 

  683.         for (BLASLONG i=0; i<M/8; i+=1) {

  684.             BLASLONG ai=m_top*K;

  685.             BLASLONG bi=n_top*K;

  686.             BLASLONG pass_K = K;

  687.             #ifdef LEFT

  688.                 BLASLONG off = offset + m_top;

  689.             #else

  690.                 BLASLONG off = -offset + n_top;

  691.             #endif

  692.             #ifdef BACKWARDS

  693.                 ai += off*8;

  694.                 bi += off*2;

  695.                 pass_K -= off;

  696.             #else

  697.                 #ifdef LEFT

  698.                     pass_K = off + 8;

  699.                 #else

  700.                     pass_K = off + 2;

  701.                 #endif

  702.             #endif

  703.             double B0 = B[bi+0];

  704.             double B1 = B[bi+1];

  705.             bi += 2;

  706. 

  707.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  708.             vfloat64m1_t A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  709.             ai += 8;

  710. 

  711.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  712.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A1, B0, gvl);

  713.             vfloat64m1_t result2 = __riscv_vfmul_vf_f64m1( A0, B1, gvl);

  714.             vfloat64m1_t result3 = __riscv_vfmul_vf_f64m1( A1, B1, gvl);

  715. 

  716.             for(BLASLONG k=1; k<pass_K; k++) {

  717.                 B0 = B[bi+0];

  718.                 B1 = B[bi+1];

  719.                 bi += 2;

  720. 

  721.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  722.                 A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  723.                 ai += 8;

  724. 

  725.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  726.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B0, A1, gvl);

  727.                 result2 = __riscv_vfmacc_vf_f64m1( result2, B1, A0, gvl);

  728.                 result3 = __riscv_vfmacc_vf_f64m1( result3, B1, A1, gvl);

  729.             }

  730. 

  731. 

  732.             BLASLONG ci=n_top*ldc+m_top;

  733. 

  734.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  735.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  736.             vfloat64m1_t c2 = __riscv_vfmul_vf_f64m1( result2, alpha, gvl );

  737.             vfloat64m1_t c3 = __riscv_vfmul_vf_f64m1( result3, alpha, gvl );

  738.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += gvl;

  739.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl); ci += ldc-gvl*1;

  740.             __riscv_vse64_v_f64m1( &C[ci], c2, gvl); ci += gvl;

  741.             __riscv_vse64_v_f64m1( &C[ci], c3, gvl);

  742.             m_top += 8;

  743.         }

  744. 

  745. 

  746.         if( M & 4 ) {

  747.             gvl = __riscv_vsetvl_e64m1(4);

  748. 

  749.             BLASLONG ai=m_top*K;

  750.             BLASLONG bi=n_top*K;

  751.             BLASLONG pass_K = K;

  752.             #ifdef LEFT

  753.                 BLASLONG off = offset + m_top;

  754.             #else

  755.                 BLASLONG off = -offset + n_top;

  756.             #endif

  757.             #ifdef BACKWARDS

  758.                 ai += off*4;

  759.                 bi += off*2;

  760.                 pass_K -= off;

  761.             #else

  762.                 #ifdef LEFT

  763.                     pass_K = off + 4;

  764.                 #else

  765.                     pass_K = off + 2;

  766.                 #endif

  767.             #endif

  768.             double B0 = B[bi+0];

  769.             double B1 = B[bi+1];

  770.             bi += 2;

  771. 

  772.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  773.             ai += 4;

  774. 

  775.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  776.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A0, B1, gvl);

  777. 

  778.             for(BLASLONG k=1; k<pass_K; k++) {

  779.                 B0 = B[bi+0];

  780.                 B1 = B[bi+1];

  781.                 bi += 2;

  782. 

  783.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  784.                 ai += 4;

  785. 

  786.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  787.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B1, A0, gvl);

  788.             }

  789. 

  790. 

  791.             BLASLONG ci=n_top*ldc+m_top;

  792. 

  793.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  794.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  795.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += ldc-gvl*0;

  796.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl);

  797.             m_top += 4;

  798.         }

  799. 

  800. 

  801.         if( M & 2 ) {

  802.             double result0 = 0;

  803.             double result1 = 0;

  804.             double result2 = 0;

  805.             double result3 = 0;

  806.             BLASLONG ai=m_top*K;

  807.             BLASLONG bi=n_top*K;

  808.             BLASLONG pass_K = K;

  809.             #ifdef LEFT

  810.                 BLASLONG off = offset + m_top;

  811.             #else

  812.                 BLASLONG off = -offset + n_top;

  813.             #endif

  814.             #ifdef BACKWARDS

  815.                 ai += off*2;

  816.                 bi += off*2;

  817.                 pass_K -= off;

  818.             #else

  819.                 #ifdef LEFT

  820.                     pass_K = off + 2;

  821.                 #else

  822.                     pass_K = off + 2;

  823.                 #endif

  824.             #endif

  825. 

  826.             for(BLASLONG k=0; k<pass_K; k++) {

  827.                 result0+=A[ai+0]*B[bi+0];

  828.                 result1+=A[ai+1]*B[bi+0];

  829.                 result2+=A[ai+0]*B[bi+1];

  830.                 result3+=A[ai+1]*B[bi+1];

  831.                 ai+=2;

  832.                 bi+=2;

  833.             }

  834. 

  835.             BLASLONG ci=n_top*ldc+m_top;

  836.             C[ci+0*ldc+0] = alpha * result0;

  837.             C[ci+0*ldc+1] = alpha * result1;

  838.             C[ci+1*ldc+0] = alpha * result2;

  839.             C[ci+1*ldc+1] = alpha * result3;

  840.             m_top+=2;

  841.         }

  842. 

  843. 

  844.         if( M & 1 ) {

  845.             double result0 = 0;

  846.             double result1 = 0;

  847.             BLASLONG ai=m_top*K;

  848.             BLASLONG bi=n_top*K;

  849.             BLASLONG pass_K = K;

  850.             #ifdef LEFT

  851.                 BLASLONG off = offset + m_top;

  852.             #else

  853.                 BLASLONG off = -offset + n_top;

  854.             #endif

  855.             #ifdef BACKWARDS

  856.                 ai += off*1;

  857.                 bi += off*2;

  858.                 pass_K -= off;

  859.             #else

  860.                 #ifdef LEFT

  861.                     pass_K = off + 1;

  862.                 #else

  863.                     pass_K = off + 2;

  864.                 #endif

  865.             #endif

  866. 

  867.             for(BLASLONG k=0; k<pass_K; k++) {

  868.                 result0+=A[ai+0]*B[bi+0];

  869.                 result1+=A[ai+0]*B[bi+1];

  870.                 ai+=1;

  871.                 bi+=2;

  872.             }

  873. 

  874.             BLASLONG ci=n_top*ldc+m_top;

  875.             C[ci+0*ldc+0] = alpha * result0;

  876.             C[ci+1*ldc+0] = alpha * result1;

  877.             m_top+=1;

  878.         }

  879. 

  880.         n_top += 2;

  881.     }

  882. 

  883. 

  884. 

  885.     // -- tails for N=1

  886. 

  887.     if( N & 1 ) {

  888.         gvl = __riscv_vsetvl_e64m1(4);

  889.         m_top = 0;

  890. 

  891.         for (BLASLONG i=0; i<M/8; i+=1) {

  892.             BLASLONG ai=m_top*K;

  893.             BLASLONG bi=n_top*K;

  894.             BLASLONG pass_K = K;

  895.             #ifdef LEFT

  896.                 BLASLONG off = offset + m_top;

  897.             #else

  898.                 BLASLONG off = -offset + n_top;

  899.             #endif

  900.             #ifdef BACKWARDS

  901.                 ai += off*8;

  902.                 bi += off*1;

  903.                 pass_K -= off;

  904.             #else

  905.                 #ifdef LEFT

  906.                     pass_K = off + 8;

  907.                 #else

  908.                     pass_K = off + 1;

  909.                 #endif

  910.             #endif

  911.             double B0 = B[bi+0];

  912.             bi += 1;

  913. 

  914.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  915.             vfloat64m1_t A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  916.             ai += 8;

  917. 

  918.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  919.             vfloat64m1_t result1 = __riscv_vfmul_vf_f64m1( A1, B0, gvl);

  920. 

  921.             for(BLASLONG k=1; k<pass_K; k++) {

  922.                 B0 = B[bi+0];

  923.                 bi += 1;

  924. 

  925.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  926.                 A1 = __riscv_vle64_v_f64m1( &A[ai+1*gvl], gvl );

  927.                 ai += 8;

  928. 

  929.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  930.                 result1 = __riscv_vfmacc_vf_f64m1( result1, B0, A1, gvl);

  931.             }

  932. 

  933. 

  934.             BLASLONG ci=n_top*ldc+m_top;

  935. 

  936.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  937.             vfloat64m1_t c1 = __riscv_vfmul_vf_f64m1( result1, alpha, gvl );

  938.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl); ci += gvl;

  939.             __riscv_vse64_v_f64m1( &C[ci], c1, gvl);

  940.             m_top += 8;

  941.         }

  942. 

  943. 

  944.         if( M & 4 ) {

  945.             gvl = __riscv_vsetvl_e64m1(4);

  946. 

  947.             BLASLONG ai=m_top*K;

  948.             BLASLONG bi=n_top*K;

  949.             BLASLONG pass_K = K;

  950.             #ifdef LEFT

  951.                 BLASLONG off = offset + m_top;

  952.             #else

  953.                 BLASLONG off = -offset + n_top;

  954.             #endif

  955.             #ifdef BACKWARDS

  956.                 ai += off*4;

  957.                 bi += off*1;

  958.                 pass_K -= off;

  959.             #else

  960.                 #ifdef LEFT

  961.                     pass_K = off + 4;

  962.                 #else

  963.                     pass_K = off + 1;

  964.                 #endif

  965.             #endif

  966.             double B0 = B[bi+0];

  967.             bi += 1;

  968. 

  969.             vfloat64m1_t A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  970.             ai += 4;

  971. 

  972.             vfloat64m1_t result0 = __riscv_vfmul_vf_f64m1( A0, B0, gvl);

  973. 

  974.             for(BLASLONG k=1; k<pass_K; k++) {

  975.                 B0 = B[bi+0];

  976.                 bi += 1;

  977. 

  978.                 A0 = __riscv_vle64_v_f64m1( &A[ai+0*gvl], gvl );

  979.                 ai += 4;

  980. 

  981.                 result0 = __riscv_vfmacc_vf_f64m1( result0, B0, A0, gvl);

  982.             }

  983. 

  984. 

  985.             BLASLONG ci=n_top*ldc+m_top;

  986. 

  987.             vfloat64m1_t c0 = __riscv_vfmul_vf_f64m1( result0, alpha, gvl );

  988.             __riscv_vse64_v_f64m1( &C[ci], c0, gvl);

  989.             m_top += 4;

  990.         }

  991. 

  992. 

  993.         if( M & 2 ) {

  994.             double result0 = 0;

  995.             double result1 = 0;

  996.             BLASLONG ai=m_top*K;

  997.             BLASLONG bi=n_top*K;

  998.             BLASLONG pass_K = K;

  999.             #ifdef LEFT

  1000.                 BLASLONG off = offset + m_top;

  1001.             #else

  1002.                 BLASLONG off = -offset + n_top;

  1003.             #endif

  1004.             #ifdef BACKWARDS

  1005.                 ai += off*2;

  1006.                 bi += off*1;

  1007.                 pass_K -= off;

  1008.             #else

  1009.                 #ifdef LEFT

  1010.                     pass_K = off + 2;

  1011.                 #else

  1012.                     pass_K = off + 1;

  1013.                 #endif

  1014.             #endif

  1015. 

  1016.             for(BLASLONG k=0; k<pass_K; k++) {

  1017.                 result0+=A[ai+0]*B[bi+0];

  1018.                 result1+=A[ai+1]*B[bi+0];

  1019.                 ai+=2;

  1020.                 bi+=1;

  1021.             }

  1022. 

  1023.             BLASLONG ci=n_top*ldc+m_top;

  1024.             C[ci+0*ldc+0] = alpha * result0;

  1025.             C[ci+0*ldc+1] = alpha * result1;

  1026.             m_top+=2;

  1027.         }

  1028. 

  1029. 

  1030.         if( M & 1 ) {

  1031.             double result0 = 0;

  1032.             BLASLONG ai=m_top*K;

  1033.             BLASLONG bi=n_top*K;

  1034.             BLASLONG pass_K = K;

  1035.             #ifdef LEFT

  1036.                 BLASLONG off = offset + m_top;

  1037.             #else

  1038.                 BLASLONG off = -offset + n_top;

  1039.             #endif

  1040.             #ifdef BACKWARDS

  1041.                 ai += off*1;

  1042.                 bi += off*1;

  1043.                 pass_K -= off;

  1044.             #else

  1045.                 #ifdef LEFT

  1046.                     pass_K = off + 1;

  1047.                 #else

  1048.                     pass_K = off + 1;

  1049.                 #endif

  1050.             #endif

  1051. 

  1052.             for(BLASLONG k=0; k<pass_K; k++) {

  1053.                 result0+=A[ai+0]*B[bi+0];

  1054.                 ai+=1;

  1055.                 bi+=1;

  1056.             }

  1057. 

  1058.             BLASLONG ci=n_top*ldc+m_top;

  1059.             C[ci+0*ldc+0] = alpha * result0;

  1060.             m_top+=1;

  1061.         }

  1062. 

  1063.         n_top += 1;

  1064.     }

  1065. 

  1066.     return 0;

  1067. }