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: a3b0ef6596
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a3b0ef6596'
${ noResults }
OpenBLAS/kernel/riscv64/axpby_vector.c

386 lines
22 kB
Raw Blame History 

  1. /***************************************************************************

  2. Copyright (c) 2020, The OpenBLAS Project

  3. All rights reserved.

  4. Redistribution and use in source and binary forms, with or without

  5. modification, are permitted provided that the following conditions are

  6. met:

  7. 1. Redistributions of source code must retain the above copyright

  8. notice, this list of conditions and the following disclaimer.

  9. 2. Redistributions in binary form must reproduce the above copyright

  10. notice, this list of conditions and the following disclaimer in

  11. the documentation and/or other materials provided with the

  12. distribution.

  13. 3. Neither the name of the OpenBLAS project nor the names of

  14. its contributors may be used to endorse or promote products

  15. derived from this software without specific prior written permission.

  16. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  17. AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  18. IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  19. ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE

  20. LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  21. DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  22. SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  23. CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  24. OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE

  25. USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  26. *****************************************************************************/

  27. 

  28. #include "common.h"

  29. 

  30. #ifdef RISCV64_ZVL256B

  31. #       define LMUL m2

  32. #       if defined(DOUBLE)

  33. #               define ELEN 64

  34. #       else

  35. #               define ELEN 32

  36. #       endif

  37. #else

  38. #       define LMUL m4

  39. #       if defined(DOUBLE)

  40. #               define ELEN 64

  41. #       else

  42. #               define ELEN 32

  43. #       endif

  44. #endif

  45. 

  46. #define _

  47. #define JOIN2_X(x, y) x ## y

  48. #define JOIN2(x, y) JOIN2_X(x, y)

  49. #define JOIN(v, w, x, y, z) JOIN2( JOIN2( JOIN2( JOIN2( v, w ), x), y), z)

  50. 

  51. #define VSETVL          JOIN(RISCV_RVV(vsetvl),    _e,     ELEN,   LMUL,   _)

  52. #define FLOAT_V_T       JOIN(vfloat,            ELEN,   LMUL,   _t,     _)

  53. #define VLEV_FLOAT      JOIN(RISCV_RVV(vle),       ELEN,   _v_f,   ELEN,   LMUL)

  54. #define VLSEV_FLOAT     JOIN(RISCV_RVV(vlse),      ELEN,   _v_f,   ELEN,   LMUL)

  55. #define VSEV_FLOAT      JOIN(RISCV_RVV(vse),       ELEN,   _v_f,   ELEN,   LMUL)

  56. #define VSSEV_FLOAT     JOIN(RISCV_RVV(vsse),      ELEN,   _v_f,   ELEN,   LMUL)

  57. #define VFMACCVF_FLOAT  JOIN(RISCV_RVV(vfmacc),    _vf_f,  ELEN,   LMUL,   _)

  58. #define VFMVVF_FLOAT    JOIN(RISCV_RVV(vfmv),      _v_f_f, ELEN,   LMUL,   _)

  59. #define VFMULVF_FLOAT   JOIN(RISCV_RVV(vfmul),     _vf_f,  ELEN,   LMUL,   _)

  60. 

  61. int CNAME(BLASLONG n, FLOAT alpha, FLOAT *x, BLASLONG inc_x, FLOAT beta, FLOAT *y, BLASLONG inc_y)

  62. {

  63. 	if (n <= 0)  return(0);

  64. 

  65. 	BLASLONG i=0, j=0;

  66. 	unsigned int gvl = 0;

  67. 	FLOAT_V_T vx0, vx1;

  68.         FLOAT_V_T vy0, vy1;

  69. 

  70. 	BLASLONG stride_x, stride_y, ix = 0, iy = 0;

  71. 

  72.         if(beta == 0.0){

  73.                 if(alpha == 0.0){//alpha == 0 && beta == 0

  74.                         if(inc_y == 1){

  75.                                 gvl = VSETVL(n);

  76.                                 if(gvl <= n/2){

  77.                                         vy0 = VFMVVF_FLOAT(0.0, gvl);

  78.                                         for(i=0,j=0;i<n/(gvl*2);i++){

  79.                                                 VSEV_FLOAT(&y[j], vy0, gvl);

  80.                                                 VSEV_FLOAT(&y[j+gvl], vy0, gvl);

  81.                                                 j += gvl * 2;

  82.                                         }

  83.                                 }

  84.                                 for(;j<n;){

  85.                                         gvl = VSETVL(n-j);

  86.                                         vy0 = VFMVVF_FLOAT(0.0, gvl);

  87.                                         VSEV_FLOAT(&y[j], vy0, gvl);

  88.                                         j += gvl;

  89.                                 }

  90.                         }else{

  91.                                 gvl = VSETVL(n);

  92.                                 stride_y = inc_y * sizeof(FLOAT);

  93.                                 if(gvl <= n/2){

  94.                                         vy0 = VFMVVF_FLOAT(0.0, gvl);

  95.                                         BLASLONG inc_yv = inc_y * gvl;

  96.                                         for(i=0,j=0;i<n/(gvl*2);i++){

  97.                                                 VSSEV_FLOAT(&y[iy], stride_y, vy0, gvl);

  98.                                                 VSSEV_FLOAT(&y[iy+inc_yv], stride_y, vy0, gvl);

  99.                                                 j += gvl * 2;

  100.                                                 iy += inc_yv * 2;

  101.                                         }

  102.                                 }

  103.                                 for(;j<n;){

  104.                                         gvl = VSETVL(n-j);

  105.                                         vy0 = VFMVVF_FLOAT(0.0, gvl);

  106.                                         VSSEV_FLOAT(&y[j*inc_y], stride_y, vy0, gvl);

  107.                                         j += gvl;

  108.                                 }

  109.                         }

  110. 

  111.                 }else{//alpha != 0 && beta == 0, y = ax

  112. 			if(inc_x == 1 && inc_y == 1){

  113.                                 gvl = VSETVL(n);

  114.                                 if(gvl <= n/2){

  115.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  116.                                                 vx0 = VLEV_FLOAT(&x[j], gvl);

  117.                                                 vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  118.                                                 VSEV_FLOAT(&y[j], vy0, gvl);

  119. 

  120.                                                 vx1 = VLEV_FLOAT(&x[j+gvl], gvl);

  121.                                                 vy1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  122.                                                 VSEV_FLOAT(&y[j+gvl], vy1, gvl);

  123.                                                 j += gvl * 2;

  124.                                         }

  125.                                 }

  126.                                 for(;j<n;){

  127.                                         gvl = VSETVL(n-j);

  128.                                         vx0 = VLEV_FLOAT(&x[j], gvl);

  129.                                         vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  130.                                         VSEV_FLOAT(&y[j], vy0, gvl);

  131.                                         j += gvl;

  132.                                 }

  133. 			}else if(inc_y == 1){

  134.                                 gvl = VSETVL(n);

  135.                                 stride_x = inc_x * sizeof(FLOAT);

  136.                                 if(gvl <= n/2){

  137.                                         BLASLONG inc_xv = inc_x * gvl;

  138.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  139.                                                 vx0 = VLSEV_FLOAT(&x[ix], stride_x, gvl);

  140.                                                 vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  141.                                                 VSEV_FLOAT(&y[j], vy0, gvl);

  142. 

  143.                                                 vx1 = VLSEV_FLOAT(&x[ix+inc_xv], stride_x, gvl);

  144.                                                 vy1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  145.                                                 VSEV_FLOAT(&y[j+gvl], vy1, gvl);

  146.                                                 j += gvl * 2;

  147.                                                 ix += inc_xv * 2;

  148.                                         }

  149.                                 }

  150.                                 for(;j<n;){

  151.                                         gvl = VSETVL(n-j);

  152.                                         vx0 = VLSEV_FLOAT(&x[j*inc_x], stride_x, gvl);

  153.                                         vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  154.                                         VSEV_FLOAT(&y[j], vy0, gvl);

  155.                                         j += gvl;

  156.                                 }

  157.                         }else if(inc_x == 1){

  158.                                 gvl = VSETVL(n);

  159.                                 stride_y = inc_y * sizeof(FLOAT);

  160.                                 if(gvl <= n/2){

  161.                                         BLASLONG inc_yv = inc_y * gvl;

  162.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  163.                                                 vx0 = VLEV_FLOAT(&x[j], gvl);

  164.                                                 vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  165.                                                 VSSEV_FLOAT(&y[iy], stride_y, vy0, gvl);

  166. 

  167.                                                 vx1 = VLEV_FLOAT(&x[j+gvl], gvl);

  168.                                                 vy1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  169.                                                 VSSEV_FLOAT(&y[iy+inc_yv], stride_y, vy1, gvl);

  170.                                                 j += gvl * 2;

  171.                                                 iy += inc_yv * 2;

  172.                                         }

  173.                                 }

  174.                                 for(;j<n;){

  175.                                         gvl = VSETVL(n-j);

  176.                                         vx0 = VLEV_FLOAT(&x[j], gvl);

  177.                                         vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  178.                                         VSSEV_FLOAT(&y[j*inc_y], stride_y, vy0, gvl);

  179.                                         j += gvl;

  180.                                 }

  181.                         }else{//inc_x !=1 && inc_y != 1

  182.                                 gvl = VSETVL(n);

  183.                                 stride_x = inc_x * sizeof(FLOAT);

  184.                                 stride_y = inc_y * sizeof(FLOAT);

  185.                                 if(gvl <= n/2){

  186.                                         BLASLONG inc_xv = inc_x * gvl;

  187.                                         BLASLONG inc_yv = inc_y * gvl;

  188.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  189.                                                 vx0 = VLSEV_FLOAT(&x[ix], stride_x, gvl);

  190.                                                 vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  191.                                                 VSSEV_FLOAT(&y[iy], stride_y, vy0, gvl);

  192. 

  193.                                                 vx1 = VLSEV_FLOAT(&x[ix+inc_xv], stride_x, gvl);

  194.                                                 vy1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  195.                                                 VSSEV_FLOAT(&y[iy+inc_yv], stride_y, vy1, gvl);

  196.                                                 j += gvl * 2;

  197.                                                 ix += inc_xv * 2;

  198.                                                 iy += inc_yv * 2;

  199.                                         }

  200.                                 }

  201.                                 for(;j<n;){

  202.                                         gvl = VSETVL(n-j);

  203.                                         vx0 = VLSEV_FLOAT(&x[j*inc_x], stride_x, gvl);

  204.                                         vy0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  205.                                         VSSEV_FLOAT(&y[j*inc_y], stride_y, vy0, gvl);

  206.                                         j += gvl;

  207.                                 }

  208.                         }

  209. 		}

  210.         }else{//beta != 0

  211. 		if(alpha == 0.0){//alpha == 0 && beta != 0; y = by

  212. 			if(inc_y == 1){

  213.                                 gvl = VSETVL(n);

  214.                                 if(gvl <= n/2){

  215.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  216.                                                 vy0 = VLEV_FLOAT(&y[j], gvl);

  217.                                                 vy0 = VFMULVF_FLOAT(vy0, beta, gvl);

  218.                                                 VSEV_FLOAT(&y[j], vy0, gvl);

  219. 

  220.                                                 vy1 = VLEV_FLOAT(&y[j+gvl], gvl);

  221.                                                 vy1 = VFMULVF_FLOAT(vy1, beta, gvl);

  222.                                                 VSEV_FLOAT(&y[j+gvl], vy1, gvl);

  223.                                                 j += gvl * 2;

  224.                                         }

  225.                                 }

  226.                                 for(;j<n;){

  227.                                         gvl = VSETVL(n-j);

  228.                                         vy0 = VLEV_FLOAT(&y[j], gvl);

  229.                                         vy0 = VFMULVF_FLOAT(vy0, beta, gvl);

  230.                                         VSEV_FLOAT(&y[j], vy0, gvl);

  231.                                         j += gvl;

  232.                                 }

  233. 			}else{

  234.                                 gvl = VSETVL(n);

  235.                                 stride_y = inc_y * sizeof(FLOAT);

  236.                                 if(gvl <= n/2){

  237.                                         BLASLONG inc_yv = inc_y * gvl;

  238.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  239.                                                 vy0 = VLSEV_FLOAT(&y[iy], stride_y, gvl);

  240.                                                 vy0 = VFMULVF_FLOAT(vy0, beta, gvl);

  241.                                                 VSSEV_FLOAT(&y[iy], stride_y, vy0, gvl);

  242. 

  243.                                                 vy1 = VLSEV_FLOAT(&y[iy+inc_yv], stride_y, gvl);

  244.                                                 vy1 = VFMULVF_FLOAT(vy1, beta, gvl);

  245.                                                 VSSEV_FLOAT(&y[iy+inc_yv], stride_y, vy1, gvl);

  246.                                                 j += gvl * 2;

  247.                                                 iy += inc_yv * 2;

  248.                                         }

  249.                                 }

  250.                                 for(;j<n;){

  251.                                         gvl = VSETVL(n-j);

  252.                                         vy0 = VLSEV_FLOAT(&y[j*inc_y], stride_y, gvl);

  253.                                         vy0 = VFMULVF_FLOAT(vy0, beta, gvl);

  254.                                         VSSEV_FLOAT(&y[j*inc_y], stride_y, vy0, gvl);

  255.                                         j += gvl;

  256.                                 }

  257. 			}

  258. 

  259. 		}else{//alpha != 0 && beta != 0; y = ax + by

  260. 			if(inc_x == 1 && inc_y == 1){

  261.                                 gvl = VSETVL(n);

  262.                                 if(gvl <= n/2){

  263.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  264.                                                 vx0 = VLEV_FLOAT(&x[j], gvl);

  265.                                                 vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  266.                                                 vy0 = VLEV_FLOAT(&y[j], gvl);

  267.                                                 vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  268.                                                 VSEV_FLOAT(&y[j], vy0, gvl);

  269. 

  270.                                                 vx1 = VLEV_FLOAT(&x[j+gvl], gvl);

  271.                                                 vx1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  272.                                                 vy1 = VLEV_FLOAT(&y[j+gvl], gvl);

  273.                                                 vy1 = VFMACCVF_FLOAT(vx1, beta, vy1,gvl);

  274.                                                 VSEV_FLOAT(&y[j+gvl], vy1, gvl);

  275.                                                 j += gvl * 2;

  276.                                         }

  277.                                 }

  278.                                 for(;j<n;){

  279.                                         gvl = VSETVL(n-j);

  280.                                         vx0 = VLEV_FLOAT(&x[j], gvl);

  281.                                         vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  282.                                         vy0 = VLEV_FLOAT(&y[j], gvl);

  283.                                         vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  284.                                         VSEV_FLOAT(&y[j], vy0, gvl);

  285.                                         j += gvl;

  286.                                 }

  287. 			}else if(inc_y == 1){

  288.                                 gvl = VSETVL(n);

  289.                                 stride_x = inc_x * sizeof(FLOAT);

  290.                                 if(gvl <= n/2){

  291.                                         BLASLONG inc_xv = inc_x * gvl;

  292.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  293.                                                 vx0 = VLSEV_FLOAT(&x[ix], stride_x, gvl);

  294.                                                 vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  295.                                                 vy0 = VLEV_FLOAT(&y[j], gvl);

  296.                                                 vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  297.                                                 VSEV_FLOAT(&y[j], vy0, gvl);

  298. 

  299.                                                 vx1 = VLSEV_FLOAT(&x[ix+inc_xv], stride_x, gvl);

  300.                                                 vx1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  301.                                                 vy1 = VLEV_FLOAT(&y[j+gvl], gvl);

  302.                                                 vy1 = VFMACCVF_FLOAT(vx1, beta, vy1, gvl);

  303.                                                 VSEV_FLOAT(&y[j+gvl], vy1, gvl);

  304.                                                 j += gvl * 2;

  305.                                                 ix += inc_xv * 2;

  306.                                         }

  307.                                 }

  308.                                 for(;j<n;){

  309.                                         gvl = VSETVL(n-j);

  310.                                         vx0 = VLSEV_FLOAT(&x[j*inc_x], stride_x, gvl);

  311.                                         vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  312.                                         vy0 = VLEV_FLOAT(&y[j], gvl);

  313.                                         vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  314.                                         VSEV_FLOAT(&y[j], vy0, gvl);

  315.                                         j += gvl;

  316.                                 }

  317.                         }else if(inc_x == 1){

  318.                                 gvl = VSETVL(n);

  319.                                 stride_y = inc_y * sizeof(FLOAT);

  320.                                 if(gvl <= n/2){

  321.                                         BLASLONG inc_yv = inc_y * gvl;

  322.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  323.                                                 vx0 = VLEV_FLOAT(&x[j], gvl);

  324.                                                 vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  325.                                                 vy0 = VLSEV_FLOAT(&y[iy], stride_y, gvl);

  326.                                                 vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  327.                                                 VSSEV_FLOAT(&y[iy], stride_y, vy0, gvl);

  328. 

  329.                                                 vx1 = VLEV_FLOAT(&x[j+gvl], gvl);

  330.                                                 vx1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  331.                                                 vy1 = VLSEV_FLOAT(&y[iy+inc_yv], stride_y, gvl);

  332.                                                 vy1 = VFMACCVF_FLOAT(vx1, beta, vy1, gvl);

  333.                                                 VSSEV_FLOAT(&y[iy+inc_yv], stride_y, vy1, gvl);

  334.                                                 j += gvl * 2;

  335.                                                 iy += inc_yv * 2;

  336.                                         }

  337.                                 }

  338.                                 for(;j<n;){

  339.                                         gvl = VSETVL(n-j);

  340.                                         vx0 = VLEV_FLOAT(&x[j], gvl);

  341.                                         vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  342.                                         vy0 = VLSEV_FLOAT(&y[j*inc_y], stride_y, gvl);

  343.                                         vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  344.                                         VSSEV_FLOAT(&y[j*inc_y], stride_y, vy0, gvl);

  345.                                         j += gvl;

  346.                                 }

  347.                         }else{//inc_x != 1 && inc_y != 1

  348.                                 gvl = VSETVL(n);

  349.                                 stride_x = inc_x * sizeof(FLOAT);

  350.                                 stride_y = inc_y * sizeof(FLOAT);

  351.                                 if(gvl <= n/2){

  352.                                         BLASLONG inc_xv = inc_x * gvl;

  353.                                         BLASLONG inc_yv = inc_y * gvl;

  354.                                         for(i=0,j=0;i<n/(2*gvl);i++){

  355.                                                 vx0 = VLSEV_FLOAT(&x[ix], stride_x, gvl);

  356.                                                 vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  357.                                                 vy0 = VLSEV_FLOAT(&y[iy], stride_y, gvl);

  358.                                                 vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  359.                                                 VSSEV_FLOAT(&y[iy], stride_y, vy0, gvl);

  360. 

  361.                                                 vx1 = VLSEV_FLOAT(&x[ix+inc_xv], stride_x, gvl);

  362.                                                 vx1 = VFMULVF_FLOAT(vx1, alpha, gvl);

  363.                                                 vy1 = VLSEV_FLOAT(&y[iy+inc_yv], stride_y, gvl);

  364.                                                 vy1 = VFMACCVF_FLOAT(vx1, beta, vy1, gvl);

  365.                                                 VSSEV_FLOAT(&y[iy+inc_yv], stride_y, vy1, gvl);

  366.                                                 j += gvl * 2;

  367.                                                 ix += inc_xv * 2;

  368.                                                 iy += inc_yv * 2;

  369.                                         }

  370.                                 }

  371.                                 for(;j<n;){

  372.                                         gvl = VSETVL(n-j);

  373.                                         vx0 = VLSEV_FLOAT(&x[j*inc_x], stride_x, gvl);

  374.                                         vx0 = VFMULVF_FLOAT(vx0, alpha, gvl);

  375.                                         vy0 = VLSEV_FLOAT(&y[j*inc_y], stride_y, gvl);

  376.                                         vy0 = VFMACCVF_FLOAT(vx0, beta, vy0, gvl);

  377.                                         VSSEV_FLOAT(&y[j*inc_y], stride_y, vy0, gvl);

  378.                                         j += gvl;

  379.                                 }

  380.                         }

  381.                 }

  382.         }

  383. 	return(0);

  384. }