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

385 lines
13 kB
Raw Blame History 

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

  2. Copyright (c) 2013-2018, 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. #include "common.h"

  28. #include <math.h>

  29. 

  30. #if defined(DOUBLE)

  31. 

  32. #define ABS fabs

  33. 

  34. #else

  35. 

  36. #define ABS fabsf

  37. 

  38. #endif

  39. 

  40. /**

  41.  * Find  minimum index 

  42.  * Warning: requirements n>0  and n % 32 == 0

  43.  * @param n     

  44.  * @param x     pointer to the vector

  45.  * @param minf  (out) minimum absolute value .( only for output )

  46.  * @return minimum index 

  47.  */

  48. static BLASLONG diamin_kernel_32(BLASLONG n, FLOAT *x, FLOAT *minf) {

  49.     BLASLONG index;

  50.     register __vector long long start = {1,0};

  51.     register __vector long long temp_add_index = {2, 2}; 

  52.     __asm__(

  53.  

  54. 

  55.             "lxvd2x  44,      0,%[ptr_tmp] \n\t"

  56.             "lxvd2x  45, %[i16],%[ptr_tmp] \n\t"

  57.             "lxvd2x  46, %[i32],%[ptr_tmp] \n\t"

  58.             "lxvd2x  47, %[i48],%[ptr_tmp] \n\t" 

  59.             "lxvd2x  48, %[i64],%[ptr_tmp] \n\t"

  60.             "lxvd2x  49, %[i80],%[ptr_tmp] \n\t"

  61.             "lxvd2x  50, %[i96],%[ptr_tmp] \n\t"

  62.             "lxvd2x  51,%[i112],%[ptr_tmp] \n\t"

  63. 

  64.             "xxlor  40,%x[start],%x[start]  \n\t" //{ 1,0} vs40 | v8 

  65.             "vaddudm  9,8, %[adder]   \n\t" //{3,2} vs41 

  66.             "xxlxor  37,37 ,37        \n\t" //v5 v37 index_count

  67.             "vaddudm  10,9,%[adder]   \n\t" //{5,4} vs42

  68.             "xxlxor  38 ,38 ,38       \n\t"  // v6 | vs38 vec_min_index

  69.             "vaddudm  11,10,%[adder]  \n\t" //{7,6} vs43

  70.             "lxvdsx  39,0,%[ptr_minf] \n\t" //   vs39 vec_min_value

  71.             "vaddudm  4,11, %[adder]  \n\t" // {9,8} -{8;8} vs36 | v4

  72.             "xxspltd   36,36,0        \n\t"

  73.             "xvabsdp  39, 39 \n\t"             

  74.     

  75.             "xvabsdp  44, 44 \n\t"

  76.             "xvabsdp  45, 45 \n\t"

  77.             "xvabsdp  46, 46 \n\t"

  78.             "xvabsdp  47, 47 \n\t"                         

  79.             "xvabsdp  48, 48 \n\t"

  80.             "xvabsdp  49, 49 \n\t"

  81.             "xvabsdp  50, 50 \n\t"

  82.             "xvabsdp  51, 51 \n\t"

  83.   

  84.             //jump first half forward 

  85.             "b 2f  \n\t"

  86. 

  87. //===================================================================

  88. 

  89.             ".p2align   5            \n\t"

  90. 

  91.             "1: \n\t"

  92.             "xvcmpgtdp  2,44,45  \n\t "

  93.             "xvcmpgtdp  3,46,47  \n\t "

  94.             "xvcmpgtdp  4,48,49  \n\t "

  95.             "xvcmpgtdp  5,50,51  \n\t"

  96. 

  97.             "xxsel    32,40,41,2 \n\t"

  98.             "xxsel     0,44,45,2 \n\t" 

  99.             "xxsel    33,42,43,3 \n\t"

  100.             "xxsel     1,46,47,3 \n\t" 

  101.             "xxsel    34,40,41,4 \n\t"

  102.             "xxsel    45,48,49,4 \n\t"

  103.             "xxsel    35,42,43,5 \n\t"

  104.             "xxsel    47,50,51,5 \n\t"

  105. 

  106.             "xvcmpgtdp 2,0, 1     \n\t"

  107.             "xvcmpgtdp 3, 45,47   \n\t"

  108. 

  109.             "addi     %[ptr_tmp] ,%[ptr_tmp] , 128 \n\t" 

  110.     

  111.             "xxsel     32,32,33,2 \n\t"

  112.             "xxsel       0 ,0,1,2 \n\t"

  113.             "xxsel     34,34,35,3 \n\t"

  114.             "xxsel     5,45,47,3 \n\t"

  115.  

  116.           

  117.             //load next 64

  118.             "lxvd2x  44,      0,%[ptr_tmp] \n\t"

  119.             "lxvd2x  45, %[i16],%[ptr_tmp] \n\t"

  120.     

  121.             // for {second 8 elements } we have to add 8 to each so that it became {from 8 to 16}

  122.             "vaddudm     2,2,4  \n\t" // vs34=vs34 + vs36{8,8} 

  123.     

  124.             "lxvd2x  46, %[i32],%[ptr_tmp] \n\t"

  125.             "lxvd2x  47, %[i48],%[ptr_tmp] \n\t" 

  126. 

  127.             //choose smaller from first and second part

  128.             "xvcmpgtdp 4, 0,5     \n\t" 

  129.             "xxsel     3, 0,5,4  \n\t"

  130.             "xxsel     33,32,34,4  \n\t"

  131. 

  132.             //load next 64

  133.             "lxvd2x  48, %[i64],%[ptr_tmp] \n\t"

  134.             "lxvd2x  49, %[i80],%[ptr_tmp] \n\t"

  135. 

  136.             "vaddudm  1,1,5  \n\t"  //  get real index for first smaller  

  137. 

  138.             "lxvd2x  50, %[i96],%[ptr_tmp] \n\t"

  139.             "lxvd2x  51,%[i112],%[ptr_tmp] \n\t"

  140. 

  141.             //compare with previous to get vec_min_index(v6 | vs38 ) and vec_min_value (vs39)   

  142.             "xvcmpgtdp 2,39, 3    \n\t"

  143.             "xxsel     39,39,3,2  \n\t"

  144.             "xxsel     38,38,33,2  \n\t"

  145.     

  146.             //update index += 8 

  147.             "vaddudm   5,5,4       \n\t"  

  148. 

  149.             "xvabsdp  44, 44 \n\t"

  150.             "xvabsdp  45, 45 \n\t"

  151.             "xvabsdp  46, 46 \n\t"

  152.             "xvabsdp  47, 47 \n\t"   

  153. 

  154.             //update index += 8 

  155.             "vaddudm   5,5,4       \n\t"  

  156. 

  157.             "xvabsdp  48, 48 \n\t"

  158.             "xvabsdp  49, 49 \n\t"

  159.             "xvabsdp  50, 50 \n\t"

  160.             "xvabsdp  51, 51 \n\t"

  161. 

  162. //<-----------jump here from first load

  163.              "2:                  \n\t"

  164.     

  165.             "xvcmpgtdp  2,44,45  \n\t "

  166.             "xvcmpgtdp  3,46,47  \n\t "

  167.             "xvcmpgtdp  4,48,49  \n\t "

  168.             "xvcmpgtdp  5,50,51  \n\t"

  169. 

  170.             "xxsel    32,40,41,2 \n\t"

  171.             "xxsel     0,44,45,2 \n\t" 

  172.             "xxsel    33,42,43,3 \n\t"

  173.             "xxsel     1,46,47,3 \n\t" 

  174.             "xxsel    34,40,41,4 \n\t"

  175.             "xxsel    45,48,49,4 \n\t"

  176.             "xxsel    35,42,43,5 \n\t"

  177.             "xxsel    47,50,51,5 \n\t"

  178. 

  179.             "xvcmpgtdp 2,0, 1     \n\t"

  180.             "xvcmpgtdp 3, 45,47   \n\t"

  181.             "xxsel     32,32,33,2 \n\t"

  182.             "xxsel       0 ,0,1,2 \n\t"

  183.             "xxsel     34,34,35,3 \n\t"

  184.             "xxsel     5,45,47,3 \n\t"

  185. 

  186.             "addi     %[ptr_tmp] ,%[ptr_tmp] , 128 \n\t" 

  187.             // for {second 8 elements } we have to add 8 to each so that it became {from 8 to 16}

  188.             "vaddudm     2,2,4  \n\t" // vs34=vs34 + vs36{8,8} 

  189.           

  190.             //load next 64

  191.             "lxvd2x  44,      0,%[ptr_tmp] \n\t"

  192.             "lxvd2x  45, %[i16],%[ptr_tmp] \n\t"

  193.             "lxvd2x  46, %[i32],%[ptr_tmp] \n\t"

  194.             "lxvd2x  47, %[i48],%[ptr_tmp] \n\t" 

  195. 

  196.             //choose smaller from first and second part

  197.             "xvcmpgtdp 4, 0,5     \n\t" 

  198.             "xxsel     3, 0,5,4  \n\t"

  199.             "xxsel     33,32,34,4  \n\t"

  200. 

  201.             //load next 64

  202.             "lxvd2x  48, %[i64],%[ptr_tmp] \n\t"

  203.             "lxvd2x  49, %[i80],%[ptr_tmp] \n\t"

  204. 

  205.             "vaddudm  1,1,5  \n\t"  //  get real index for first smaller  

  206. 

  207.             "lxvd2x  50, %[i96],%[ptr_tmp] \n\t"

  208.             "lxvd2x  51,%[i112],%[ptr_tmp] \n\t"

  209. 

  210.  

  211. 

  212.             //compare with previous to get vec_min_index(v6 | vs38 ) and vec_min_value (vs39)   

  213.             "xvcmpgtdp 2,39, 3    \n\t"

  214.             "xxsel     39,39,3,2  \n\t"

  215.             "xxsel     38,38,33,2  \n\t"

  216.     

  217.             //update index += 8 

  218.             "vaddudm   5,5,4       \n\t"  

  219. 

  220.             "xvabsdp  44, 44 \n\t"

  221.             "xvabsdp  45, 45 \n\t"

  222.             "xvabsdp  46, 46 \n\t"

  223.             "xvabsdp  47, 47 \n\t"   

  224. 

  225.             //update index += 8 

  226.             "vaddudm   5,5,4       \n\t"  

  227. 

  228.             "xvabsdp  48, 48 \n\t"

  229.             "xvabsdp  49, 49 \n\t"

  230.             "xvabsdp  50, 50 \n\t"

  231.             "xvabsdp  51, 51 \n\t"

  232. 

  233.             //decrement n

  234.             "addic.    %[n], %[n], -32 \n\t"

  235.            

  236.             //Loop back if >0

  237.             "bgt+ 1b  \n\t"

  238. 

  239. //==============================================================================

  240. 

  241.             "xvcmpgtdp  2,44,45  \n\t "

  242.             "xvcmpgtdp  3,46,47  \n\t "

  243.             "xvcmpgtdp  4,48,49  \n\t "

  244.             "xvcmpgtdp  5,50,51  \n\t"

  245. 

  246.             "xxsel    32,40,41,2 \n\t"

  247.             "xxsel     0,44,45,2 \n\t" 

  248.             "xxsel    33,42,43,3 \n\t"

  249.             "xxsel     1,46,47,3 \n\t" 

  250.             "xxsel    34,40,41,4 \n\t"

  251.             "xxsel    45,48,49,4 \n\t"

  252.             "xxsel    35,42,43,5 \n\t"

  253.             "xxsel    47,50,51,5 \n\t"

  254. 

  255.             "xvcmpgtdp 2,0, 1     \n\t"

  256.             "xvcmpgtdp 3, 45,47   \n\t"

  257.   

  258.     

  259.             "xxsel     32,32,33,2 \n\t"

  260.             "xxsel       0 ,0,1,2 \n\t"

  261.             "xxsel     34,34,35,3 \n\t"

  262.             "xxsel     5,45,47,3 \n\t" 

  263.     

  264.             // for {second 8 elements } we have to add 8 to each so that it became {from 8 to 16}

  265.             "vaddudm     2,2,4  \n\t" // vs34=vs34 + vs36{8,8}  

  266.             //choose smaller from first and second part

  267.             "xvcmpgtdp 4, 0,5     \n\t" 

  268.             "xxsel     3, 0,5,4   \n\t"

  269.             "xxsel     33,32,34,4 \n\t" 

  270. 

  271.             "vaddudm  1,1,5  \n\t"  //  get real index for first smaller   

  272. 

  273.             //compare with previous to get vec_min_index(v6 | vs38 ) and vec_min_value (vs39)   

  274.             "xvcmpgtdp 2,39, 3    \n\t"

  275.             "xxsel     39,39,3,2  \n\t"

  276.             "xxsel     38,38,33,2  \n\t"

  277. 

  278.             ///////extract min value and min index from vector

  279. 

  280.             "xxspltd   32,38,1     \n\t"

  281.             "xxspltd   40,39,1     \n\t"

  282.             "xvcmpeqdp.  2, 40,39  \n\t"

  283.     

  284.             //cr6 0 bit set if all true, cr6=4*6+bit_ind=24,0011at CR(BI)==1, at=10 hint that it occurs rarely

  285.              //0b001110=14

  286.             "bc 14,24, 3f  \n\t" 

  287.             "xvcmpgtdp  4,39, 40  \n\t"

  288.             "xxsel    0,39,40,4           \n\t"

  289.             "xxsel    1,38,32,4  \n\t"

  290.             "stxsdx    0,0,%[ptr_minf]     \n\t" 

  291.             "b 4f    \n\t"

  292. 

  293.             "3:      \n\t" 

  294.                 //if elements value are equal then choose minimum index

  295.             "xxspltd  0,40,0          \n\t"

  296.             "vminud   0,0,6    \n\t"  //vs32 vs38

  297.             "xxlor 1,32,32     \n\t"

  298.             "stxsdx   0,0,%[ptr_minf]  \n\t"

  299.           

  300. 

  301.             "4:      \n\t"

  302.             "mfvsrd   %[index],1 \n\t"

  303. 

  304.             : [minf] "=m"(*minf),[ptr_tmp] "+&b"(x),[index] "=r"(index), [n] "+&r"(n)

  305.             : [mem] "m"(*(const double (*)[n])x), [ptr_x] "b"(x), [ptr_minf] "b"(minf) ,

  306.             [i16] "b"(16), [i32] "b"(32), [i48] "b"(48),

  307.             [i64] "b"(64), [i80] "b"(80), [i96] "b"(96), [i112] "b"(112),

  308.             [start] "v"(start),  [adder] "v"(temp_add_index)

  309.             : "cc", "vs0", "vs1","vs2","vs3", "vs4","vs5","vs32", "vs33", "vs34", "vs35", "vs36",

  310.             "vs37", "vs38", "vs39", "vs40", "vs41", "vs42", "vs43", "vs44", "vs45", "vs46", "vs47", "vs48", "vs49", "vs50", "vs51"

  311.             );

  312.  

  313.     return index;

  314. 

  315. }

  316. 

  317. 

  318. 

  319. BLASLONG CNAME(BLASLONG n, FLOAT *x, BLASLONG inc_x) {

  320.     BLASLONG i = 0;

  321.     BLASLONG j = 0; 

  322.     BLASLONG min = 0;

  323.     FLOAT minf = 0.0;

  324.     

  325.     if (n <= 0 || inc_x <= 0) return (min);

  326.     minf = ABS(x[0]); //index's not incremented

  327.     if (inc_x == 1) {

  328. 

  329.         BLASLONG n1 = n & -32;

  330.         if (n1 > 0) {

  331. 

  332.             min = diamin_kernel_32(n1, x, &minf);

  333.             i = n1;

  334.         }

  335. 

  336.         while (i < n) {

  337.             if (ABS(x[i]) < minf) {

  338.                 min = i;

  339.                 minf = ABS(x[i]);

  340.             }

  341.             i++;

  342.         }

  343.         return (min + 1);

  344. 

  345.     } else {

  346. 

  347.         BLASLONG n1 = n & -4;

  348.         while (j < n1) {

  349. 

  350.             if (ABS(x[i]) < minf) {

  351.                 min = j;

  352.                 minf = ABS(x[i]);

  353.             }

  354.             if (ABS(x[i + inc_x]) < minf) {

  355.                 min = j + 1;

  356.                 minf = ABS(x[i + inc_x]);

  357.             }

  358.             if (ABS(x[i + 2 * inc_x]) < minf) {

  359.                 min = j + 2;

  360.                 minf = ABS(x[i + 2 * inc_x]);

  361.             }

  362.             if (ABS(x[i + 3 * inc_x]) < minf) {

  363.                 min = j + 3;

  364.                 minf = ABS(x[i + 3 * inc_x]);

  365.             }

  366. 

  367.             i += inc_x * 4;

  368. 

  369.             j += 4;

  370. 

  371.         }

  372. 

  373. 

  374.         while (j < n) {

  375.             if (ABS(x[i]) < minf) {

  376.                 min = j;

  377.                 minf = ABS(x[i]);

  378.             }

  379.             i += inc_x;

  380.             j++;

  381.         }

  382.         return (min + 1);

  383.     }

  384. }