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: 6017ad7146
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6017ad7146'
${ noResults }
OpenBLAS/kernel/generic/trmm_lncopy_6.c

551 lines
16 kB
Raw Blame History 

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

  2. /* Copyright 2009, 2010 The University of Texas at Austin.           */

  3. /* All rights reserved.                                              */

  4. /*                                                                   */

  5. /* Redistribution and use in source and binary forms, with or        */

  6. /* without modification, are permitted provided that the following   */

  7. /* conditions are met:                                               */

  8. /*                                                                   */

  9. /*   1. Redistributions of source code must retain the above         */

  10. /*      copyright notice, this list of conditions and the following  */

  11. /*      disclaimer.                                                  */

  12. /*                                                                   */

  13. /*   2. Redistributions in binary form must reproduce the above      */

  14. /*      copyright notice, this list of conditions and the following  */

  15. /*      disclaimer in the documentation and/or other materials       */

  16. /*      provided with the distribution.                              */

  17. /*                                                                   */

  18. /*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */

  19. /*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */

  20. /*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */

  21. /*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */

  22. /*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */

  23. /*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */

  24. /*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */

  25. /*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */

  26. /*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */

  27. /*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */

  28. /*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */

  29. /*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */

  30. /*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */

  31. /*    POSSIBILITY OF SUCH DAMAGE.                                    */

  32. /*                                                                   */

  33. /* The views and conclusions contained in the software and           */

  34. /* documentation are those of the authors and should not be          */

  35. /* interpreted as representing official policies, either expressed   */

  36. /* or implied, of The University of Texas at Austin.                 */

  37. /*********************************************************************/

  38. 

  39. #include <stdio.h>

  40. #include "common.h"

  41. 

  42. int CNAME(BLASLONG m, BLASLONG n, FLOAT *a, BLASLONG lda, BLASLONG posX, BLASLONG posY, FLOAT *b){

  43. 

  44.     BLASLONG i, js, ii;

  45.     BLASLONG X;

  46. 

  47.     FLOAT data01, data02, data05, data06;

  48.     FLOAT *ao1, *ao2, *ao3, *ao4, *ao5, *ao6;

  49. 

  50.     js = (n / 6);

  51. 

  52.     if (js > 0){

  53.         do {

  54.             X = posX;

  55. 

  56.             if (posX <= posY) {

  57.                 ao1 = a + posY + (posX + 0) * lda;

  58.                 ao2 = a + posY + (posX + 1) * lda;

  59.                 ao3 = a + posY + (posX + 2) * lda;

  60.                 ao4 = a + posY + (posX + 3) * lda;

  61.                 ao5 = a + posY + (posX + 4) * lda;

  62.                 ao6 = a + posY + (posX + 5) * lda;

  63.             } else {

  64.                 ao1 = a + posX + (posY + 0) * lda;

  65.                 ao2 = a + posX + (posY + 1) * lda;

  66.                 ao3 = a + posX + (posY + 2) * lda;

  67.                 ao4 = a + posX + (posY + 3) * lda;

  68.                 ao5 = a + posX + (posY + 4) * lda;

  69.                 ao6 = a + posX + (posY + 5) * lda;

  70.             }

  71. 

  72.         i = (m / 6);

  73.         if (i > 0) {

  74.             do {

  75.                 if (X > posY) {

  76.                     for (ii = 0; ii < 6; ii++){

  77. 

  78.                         b[  0] = *(ao1 +  0);

  79.                         b[  1] = *(ao2 +  0);

  80.                         b[  2] = *(ao3 +  0);

  81.                         b[  3] = *(ao4 +  0);

  82.                         b[  4] = *(ao5 +  0);

  83.                         b[  5] = *(ao6 +  0);

  84. 

  85.                         ao1 ++;

  86.                         ao2 ++;

  87.                         ao3 ++;

  88.                         ao4 ++;

  89.                         ao5 ++;

  90.                         ao6 ++;

  91.                         b += 6;

  92.                     }

  93. 

  94.                 } else if (X < posY) {

  95.                     ao1 += 6 * lda;

  96.                     ao2 += 6 * lda;

  97.                     ao3 += 6 * lda;

  98.                     ao4 += 6 * lda;

  99.                     ao5 += 6 * lda;

  100.                     ao6 += 6 * lda;

  101.                     b += 36;

  102. 

  103.                 } else {

  104. #ifdef UNIT

  105.                     b[  0] = ONE;

  106. #else

  107.                     b[  0] = *(ao1 +  0);

  108. #endif

  109.                     b[  1] = ZERO;

  110.                     b[  2] = ZERO;

  111.                     b[  3] = ZERO;

  112.                     b[  4] = ZERO;

  113.                     b[  5] = ZERO;

  114. 

  115.                     b[ 6] = *(ao1 +  1);

  116. #ifdef UNIT

  117.                     b[ 7] = ONE;

  118. #else

  119.                     b[ 7] = *(ao2 +  1);

  120. #endif

  121.                     b[ 8] = ZERO;

  122.                     b[ 9] = ZERO;

  123.                     b[10] = ZERO;

  124.                     b[11] = ZERO;

  125. 

  126.                     b[12] = *(ao1 +  2);

  127.                     b[13] = *(ao2 +  2);

  128. #ifdef UNIT

  129.                     b[14] = ONE;

  130. #else

  131.                     b[14] = *(ao3 +  2);

  132. #endif

  133.                     b[15] = ZERO;

  134.                     b[16] = ZERO;

  135.                     b[17] = ZERO;

  136. 

  137.                     b[18] = *(ao1 +  3);

  138.                     b[19] = *(ao2 +  3);

  139.                     b[20] = *(ao3 +  3);

  140. #ifdef UNIT

  141.                     b[21] = ONE;

  142. #else

  143.                     b[21] = *(ao4 +  3);

  144. #endif

  145.                     b[22] = ZERO;

  146.                     b[23] = ZERO;

  147. 

  148.                     b[24] = *(ao1 +  4);

  149.                     b[25] = *(ao2 +  4);

  150.                     b[26] = *(ao3 +  4);

  151.                     b[27] = *(ao4 +  4);

  152. #ifdef UNIT

  153.                     b[28] = ONE;

  154. #else

  155.                     b[28] = *(ao5 +  4);

  156. #endif

  157.                     b[29] = ZERO;

  158. 

  159.                     b[30] = *(ao1 +  5);

  160.                     b[31] = *(ao2 +  5);

  161.                     b[32] = *(ao3 +  5);

  162.                     b[33] = *(ao4 +  5);

  163.                     b[34] = *(ao5 +  5);

  164. #ifdef UNIT

  165.                     b[35] = ONE;

  166. #else

  167.                     b[35] = *(ao6 +  5);

  168. #endif

  169.                     ao1 += 6;

  170.                     ao2 += 6;

  171.                     ao3 += 6;

  172.                     ao4 += 6;

  173.                     ao5 += 6;

  174.                     ao6 += 6;

  175.                     b += 36;

  176.                 }

  177. 

  178.                 X += 6;

  179.                 i --;

  180.             } while (i > 0);

  181.         }

  182. 

  183.         i = (m % 6);

  184.         if (i) {

  185. 

  186.             if (X > posY) {

  187.                 for (ii = 0; ii < i; ii++){

  188.                     b[  0] = *(ao1 +  0);

  189.                     b[  1] = *(ao2 +  0);

  190.                     b[  2] = *(ao3 +  0);

  191.                     b[  3] = *(ao4 +  0);

  192.                     b[  4] = *(ao5 +  0);

  193.                     b[  5] = *(ao6 +  0);

  194. 

  195.                     ao1 ++;

  196.                     ao2 ++;

  197.                     ao3 ++;

  198.                     ao4 ++;

  199.                     ao5 ++;

  200.                     ao6 ++;

  201.                     b += 6;

  202.                 }

  203. 

  204.             } else if (X < posY) {

  205. 

  206.                 b += 6 * i;

  207. 

  208.             } else {

  209. #ifdef UNIT

  210.                 b[  0] = ONE;

  211. #else

  212.                 b[  0] = *(ao1 +  0);

  213. #endif

  214.                 b[  1] = ZERO;

  215.                 b[  2] = ZERO;

  216.                 b[  3] = ZERO;

  217.                 b[  4] = ZERO;

  218.                 b[  5] = ZERO;

  219.                 b += 6;

  220. 

  221.                 if (i >= 2) {

  222.                     b[  0] = *(ao1 +  1);

  223. #ifdef UNIT

  224.                     b[  1] = ONE;

  225. #else

  226.                     b[  1] = *(ao2 +  1);

  227. #endif

  228.                     b[  2] = ZERO;

  229.                     b[  3] = ZERO;

  230.                     b[  4] = ZERO;

  231.                     b[  5] = ZERO;

  232.                     b += 6;

  233.                 }

  234. 

  235.                 if (i >= 3) {

  236.                     b[  0] = *(ao1 +  2);

  237.                     b[  1] = *(ao2 +  2);

  238. #ifdef UNIT

  239.                     b[  2] = ONE;

  240. #else

  241.                     b[  2] = *(ao3 +  2);

  242. #endif

  243.                     b[  3] = ZERO;

  244.                     b[  4] = ZERO;

  245.                     b[  5] = ZERO;

  246.                     b += 6;

  247.                 }

  248. 

  249.                 if (i >= 4) {

  250.                     b[  0] = *(ao1 +  3);

  251.                     b[  1] = *(ao2 +  3);

  252.                     b[  2] = *(ao3 +  3);

  253. #ifdef UNIT

  254.                     b[  3] = ONE;

  255. #else

  256.                     b[  3] = *(ao4 +  3);

  257. #endif

  258.                     b[  4] = ZERO;

  259.                     b[  5] = ZERO;

  260.                     b += 6;

  261.                 }

  262. 

  263.                 if (i >= 5) {

  264.                     b[  0] = *(ao1 +  4);

  265.                     b[  1] = *(ao2 +  4);

  266.                     b[  2] = *(ao3 +  4);

  267.                     b[  3] = *(ao4 +  4);

  268. #ifdef UNIT

  269.                     b[  4] = ONE;

  270. #else

  271.                     b[  4] = *(ao5 +  4);

  272. #endif

  273.                     b[  5] = ZERO;

  274.                     b += 6;

  275.                 }

  276.             }

  277.         }

  278. 

  279.         posY += 6;

  280.         js --;

  281.         } while (js > 0);

  282.     } /* End of main loop */

  283. 

  284.     if ((n % 6) & 4){

  285.         X = posX;

  286. 

  287.         if (posX <= posY) {

  288.             ao1 = a + posY + (posX + 0) * lda;

  289.             ao2 = a + posY + (posX + 1) * lda;

  290.             ao3 = a + posY + (posX + 2) * lda;

  291.             ao4 = a + posY + (posX + 3) * lda;

  292.         } else {

  293.             ao1 = a + posX + (posY + 0) * lda;

  294.             ao2 = a + posX + (posY + 1) * lda;

  295.             ao3 = a + posX + (posY + 2) * lda;

  296.             ao4 = a + posX + (posY + 3) * lda;

  297.         }

  298. 

  299.         i = (m >> 1);

  300.         if (i > 0) {

  301.         do {

  302.             if (X > posY) {

  303.                 for (ii = 0; ii < 2; ii++){

  304. 

  305.                     b[  0] = *(ao1 +  0);

  306.                     b[  1] = *(ao2 +  0);

  307.                     b[  2] = *(ao3 +  0);

  308.                     b[  3] = *(ao4 +  0);

  309. 

  310.                     ao1 ++;

  311.                     ao2 ++;

  312.                     ao3 ++;

  313.                     ao4 ++;

  314.                     b += 4;

  315.                 }

  316.             } else if (X < posY) {

  317.                 ao1 += 2 * lda;

  318.                 ao2 += 2 * lda;

  319.                 ao3 += 2 * lda;

  320.                 ao4 += 2 * lda;

  321.                 b += 8;

  322.             } else {

  323. #ifdef UNIT

  324.                 b[  0] = ONE;

  325. #else

  326.                 b[  0] = *(ao1 +  0);

  327. #endif

  328.                 b[  1] = ZERO;

  329.                 b[  2] = ZERO;

  330.                 b[  3] = ZERO;

  331. 

  332.                 b[  4] = *(ao1 +  1);

  333. #ifdef UNIT

  334.                 b[  5] = ONE;

  335. #else

  336.                 b[  5] = *(ao2 +  1);

  337. #endif

  338.                 b[  6] = ZERO;

  339.                 b[  7] = ZERO;

  340. 

  341.                 b[  8] = *(ao1 +  2);

  342.                 b[  9] = *(ao2 +  2);

  343. #ifdef UNIT

  344.                 b[ 10] = ONE;

  345. #else

  346.                 b[ 10] = *(ao3 +  2);

  347. #endif

  348.                 b[ 11] = ZERO;

  349. 

  350.                 b[ 12] = *(ao1 +  3);

  351.                 b[ 13] = *(ao2 +  3);

  352.                 b[ 14] = *(ao3 +  3);

  353. #ifdef UNIT

  354.                 b[ 15] = ONE;

  355. #else

  356.                 b[ 15] = *(ao4 +  3);

  357. #endif

  358. 

  359.                 ao1 += 4;

  360.                 ao2 += 4;

  361.                 ao3 += 4;

  362.                 ao4 += 4;

  363.                 b += 16;

  364.                 X += 4;

  365.                 i -= 2;

  366.                 continue;

  367.             }

  368. 

  369.             X += 2;

  370.             i --;

  371.             } while (i > 0);

  372.         }

  373. 

  374.         i = (m & 1);

  375.         if (i) {

  376. 

  377.             if (X > posY) {

  378.                 for (ii = 0; ii < i; ii++){

  379. 

  380.                     b[  0] = *(ao1 +  0);

  381.                     b[  1] = *(ao2 +  0);

  382.                     b[  2] = *(ao3 +  0);

  383.                     b[  3] = *(ao4 +  0);

  384. 

  385.                     ao1 ++;

  386.                     ao2 ++;

  387.                     ao3 ++;

  388.                     ao4 ++;

  389.                     b += 4;

  390.                 }

  391.             } else if (X < posY) {

  392.                 /* ao1 += i * lda;

  393.                 ao2 += i * lda;

  394.                 ao3 += i * lda;

  395.                 ao4 += i * lda; */

  396.                 b += 4 * i;

  397.             } else {

  398. #ifdef UNIT

  399.                 b[  0] = ONE;

  400. #else

  401.                 b[  0] = *(ao1 +  0);

  402. #endif

  403.                 b[  1] = ZERO;

  404.                 b[  2] = ZERO;

  405.                 b[  3] = ZERO;

  406.                 b += 4;

  407.             }

  408.         }

  409. 

  410.         posY += 4;

  411.     }

  412. 

  413. 

  414.     if ((n % 6) & 2){

  415.         X = posX;

  416. 

  417.         if (posX <= posY) {

  418.             ao1 = a + posY + (posX + 0) * lda;

  419.             ao2 = a + posY + (posX + 1) * lda;

  420.         } else {

  421.             ao1 = a + posX + (posY + 0) * lda;

  422.             ao2 = a + posX + (posY + 1) * lda;

  423.         }

  424. 

  425.         i = (m >> 1);

  426.         if (i > 0) {

  427.             do {

  428.                 if (X > posY) {

  429.                     data01 = *(ao1 + 0);

  430.                     data02 = *(ao1 + 1);

  431.                     data05 = *(ao2 + 0);

  432.                     data06 = *(ao2 + 1);

  433. 

  434.                     b[ 0] = data01;

  435.                     b[ 1] = data05;

  436.                     b[ 2] = data02;

  437.                     b[ 3] = data06;

  438. 

  439.                     ao1 += 2;

  440.                     ao2 += 2;

  441.                     b += 4;

  442. 

  443.                 } else if (X < posY) {

  444.                     ao1 += 2 * lda;

  445.                     ao2 += 2 * lda;

  446.                     b += 4;

  447.                 } else {

  448. #ifdef UNIT

  449.                     data02 = *(ao1 + 1);

  450. 

  451.                     b[ 0] = ONE;

  452.                     b[ 1] = ZERO;

  453.                     b[ 2] = data02;

  454.                     b[ 3] = ONE;

  455. #else

  456.                     data01 = *(ao1 + 0);

  457.                     data02 = *(ao1 + 1);

  458.                     data06 = *(ao2 + 1);

  459. 

  460.                     b[ 0] = data01;

  461.                     b[ 1] = ZERO;

  462.                     b[ 2] = data02;

  463.                     b[ 3] = data06;

  464. #endif

  465.                     ao1 += 2;

  466.                     ao2 += 2;

  467. 

  468.                     b += 4;

  469.                 }

  470. 

  471.                 X += 2;

  472.                 i --;

  473.             } while (i > 0);

  474.         }

  475. 

  476.         i = (m & 1);

  477.         if (i) {

  478. 

  479.             if (X > posY) {

  480.                 data01 = *(ao1 + 0);

  481.                 data02 = *(ao2 + 0);

  482.                 b[ 0] = data01;

  483.                 b[ 1] = data02;

  484. 

  485.                 ao1 += 1;

  486.                 ao2 += 1;

  487.                 b += 2;

  488.             } else if (X < posY) {

  489.                 ao1 += lda;

  490.                 b += 2;

  491.             } else {

  492. #ifdef UNIT

  493.                 data05 = *(ao2 + 0);

  494. 

  495.                 b[ 0] = ONE;

  496.                 b[ 1] = data05;

  497. #else

  498.                 data01 = *(ao1 + 0);

  499.                 data05 = *(ao2 + 0);

  500. 

  501.                 b[ 0] = data01;

  502.                 b[ 1] = data05;

  503. #endif

  504.                 b += 2;

  505.             }

  506.         }

  507.         posY += 2;

  508.     }

  509. 

  510.     if ((n % 6) & 1){

  511.         X = posX;

  512. 

  513.         if (posX <= posY) {

  514.             ao1 = a + posY + (posX + 0) * lda;

  515.         } else {

  516.             ao1 = a + posX + (posY + 0) * lda;

  517.         }

  518. 

  519.         i = m;

  520.         if (i > 0) {

  521.             do {

  522.                 if (X > posY) {

  523.                     data01 = *(ao1 + 0);

  524.                     b[ 0] = data01;

  525.                     b += 1;

  526.                     ao1 += 1;

  527.                 } else if (X < posY) {

  528.                     b += 1;

  529.                     ao1 += lda;

  530.                 } else {

  531. #ifdef UNIT

  532.                     b[ 0] = ONE;

  533. #else

  534.                     data01 = *(ao1 + 0);

  535.                     b[ 0] = data01;

  536. #endif

  537.                     b += 1;

  538.                     ao1 += 1;

  539.                 }

  540. 

  541.                 X ++;

  542.                 i --;

  543.             } while (i > 0);

  544.         }

  545. 

  546.         posY += 1;

  547.     }

  548. 

  549.     return 0;

  550. }