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

1403 lines
22 kB
Raw Blame History 

  1. #include "common.h"

  2. #include <stdbool.h>

  3. 

  4. int CNAME(BLASLONG bm,BLASLONG bn,BLASLONG bk,FLOAT alpha,FLOAT* ba,FLOAT* bb,FLOAT* C,BLASLONG ldc ,BLASLONG offset)

  5. {

  6. 

  7.    BLASLONG i,j,k;

  8.    FLOAT *C0,*C1,*C2,*C3,*C4,*C5,*C6,*C7,*ptrba,*ptrbb;

  9. 

  10.    FLOAT res0_0;

  11.    FLOAT res0_1;

  12.    FLOAT res0_2;

  13.    FLOAT res0_3;

  14. 

  15.    FLOAT res1_0;

  16.    FLOAT res1_1;

  17.    FLOAT res1_2;

  18.    FLOAT res1_3;

  19. 

  20.    FLOAT res2_0;

  21.    FLOAT res2_1;

  22.    FLOAT res2_2;

  23.    FLOAT res2_3;

  24. 

  25.    FLOAT res3_0;

  26.    FLOAT res3_1;

  27.    FLOAT res3_2;

  28.    FLOAT res3_3;

  29. 

  30.    FLOAT res4_0;

  31.    FLOAT res4_1;

  32.    FLOAT res4_2;

  33.    FLOAT res4_3;

  34. 

  35.    FLOAT res5_0;

  36.    FLOAT res5_1;

  37.    FLOAT res5_2;

  38.    FLOAT res5_3;

  39. 

  40.    FLOAT res6_0;

  41.    FLOAT res6_1;

  42.    FLOAT res6_2;

  43.    FLOAT res6_3;

  44. 

  45.    FLOAT res7_0;

  46.    FLOAT res7_1;

  47.    FLOAT res7_2;

  48.    FLOAT res7_3;

  49. 

  50.    FLOAT a0;

  51.    FLOAT a1;

  52. 

  53.    FLOAT b0;

  54.    FLOAT b1;

  55.    FLOAT b2;

  56.    FLOAT b3;

  57.    FLOAT b4;

  58.    FLOAT b5;

  59.    FLOAT b6;

  60.    FLOAT b7;

  61. 

  62.    BLASLONG off, temp;

  63. 

  64.    bool left;

  65.    bool transposed;

  66.    bool backwards;

  67. 

  68. #ifdef LEFT

  69.    left = true;

  70. #else

  71.    left = false;

  72. #endif

  73. 

  74. #ifdef TRANSA

  75.    transposed = true;

  76. #else

  77.    transposed = false;

  78. #endif

  79. 

  80.    backwards = left != transposed;

  81. 

  82.    if (!left) {

  83.       off = -offset;

  84.    }

  85. 

  86. 

  87.    for (j=0; j<bn/8; j+=1) // do blocks of the Mx8 loops 

  88.    {

  89.         C0 = C;

  90.         C1 = C0+ldc;

  91.         C2 = C1+ldc;

  92.         C3 = C2+ldc;

  93.         C4 = C3+ldc;

  94.         C5 = C4+ldc;

  95.         C6 = C5+ldc;

  96.         C7 = C6+ldc;

  97. 

  98. 

  99.         if (left) {

  100.             off = offset;

  101.         }

  102. 

  103.         ptrba = ba;

  104. 

  105.         for (i=0; i<bm/4; i+=1) // do blocks of 4x4

  106. 	{

  107. 

  108. 		ptrbb = bb;

  109.                 if (backwards)

  110.                 {

  111. 		   ptrba += off*4; // number of values in A

  112. 		   ptrbb += off*8; // number of values in B

  113.                 }

  114. 

  115. 		res0_0 = 0;

  116. 		res0_1 = 0;

  117. 		res0_2 = 0;

  118. 		res0_3 = 0;

  119. 

  120. 		res1_0 = 0;

  121. 		res1_1 = 0;

  122. 		res1_2 = 0;

  123. 		res1_3 = 0;

  124. 

  125. 		res2_0 = 0;

  126. 		res2_1 = 0;

  127. 		res2_2 = 0;

  128. 		res2_3 = 0;

  129. 

  130. 		res3_0 = 0;

  131. 		res3_1 = 0;

  132. 		res3_2 = 0;

  133. 		res3_3 = 0;

  134. 

  135. 		res4_0 = 0;

  136. 		res4_1 = 0;

  137. 		res4_2 = 0;

  138. 		res4_3 = 0;

  139. 

  140. 		res5_0 = 0;

  141. 		res5_1 = 0;

  142. 		res5_2 = 0;

  143. 		res5_3 = 0;

  144. 

  145. 		res6_0 = 0;

  146. 		res6_1 = 0;

  147. 		res6_2 = 0;

  148. 		res6_3 = 0;

  149. 

  150. 		res7_0 = 0;

  151. 		res7_1 = 0;

  152. 		res7_2 = 0;

  153. 		res7_3 = 0;

  154. 

  155.                 temp = backwards ? bk-off :

  156.                              left ? off + 4 : // number of values in A

  157.                                     off + 8;  // number of values in B

  158. 

  159. 		for (k=0; k<temp; k++)

  160.                 {

  161. 			b0 = ptrbb[0];

  162. 			b1 = ptrbb[1];

  163. 			b2 = ptrbb[2];

  164. 			b3 = ptrbb[3];

  165. 			b4 = ptrbb[4];

  166. 			b5 = ptrbb[5];

  167. 			b6 = ptrbb[6];

  168. 			b7 = ptrbb[7];

  169. 

  170. 			a0 = ptrba[0];

  171. 			res0_0 += a0*b0;

  172. 			res1_0 += a0*b1;

  173. 			res2_0 += a0*b2;

  174. 			res3_0 += a0*b3;

  175. 			res4_0 += a0*b4;

  176. 			res5_0 += a0*b5;

  177. 			res6_0 += a0*b6;

  178. 			res7_0 += a0*b7;

  179. 

  180. 			a1 = ptrba[1];

  181. 			res0_1 += a1*b0;

  182. 			res1_1 += a1*b1;

  183. 			res2_1 += a1*b2;

  184. 			res3_1 += a1*b3;

  185. 			res4_1 += a1*b4;

  186. 			res5_1 += a1*b5;

  187. 			res6_1 += a1*b6;

  188. 			res7_1 += a1*b7;

  189. 

  190. 			a0 = ptrba[2];

  191. 			res0_2 += a0*b0;

  192. 			res1_2 += a0*b1;

  193. 			res2_2 += a0*b2;

  194. 			res3_2 += a0*b3;

  195. 			res4_2 += a0*b4;

  196. 			res5_2 += a0*b5;

  197. 			res6_2 += a0*b6;

  198. 			res7_2 += a0*b7;

  199. 

  200. 			a1 = ptrba[3];

  201. 			res0_3 += a1*b0;

  202. 			res1_3 += a1*b1;

  203. 			res2_3 += a1*b2;

  204. 			res3_3 += a1*b3;

  205. 			res4_3 += a1*b4;

  206. 			res5_3 += a1*b5;

  207. 			res6_3 += a1*b6;

  208. 			res7_3 += a1*b7;

  209. 

  210. 			ptrba = ptrba+4;

  211. 			ptrbb = ptrbb+8;

  212.                 }

  213. 

  214. 		res0_0 *= alpha;

  215. 		res0_1 *= alpha;

  216. 		res0_2 *= alpha;

  217. 		res0_3 *= alpha;

  218. 

  219. 		res1_0 *= alpha;

  220. 		res1_1 *= alpha;

  221. 		res1_2 *= alpha;

  222. 		res1_3 *= alpha;

  223. 

  224. 		res2_0 *= alpha;

  225. 		res2_1 *= alpha;

  226. 		res2_2 *= alpha;

  227. 		res2_3 *= alpha;

  228. 

  229. 		res3_0 *= alpha;

  230. 		res3_1 *= alpha;

  231. 		res3_2 *= alpha;

  232. 		res3_3 *= alpha;

  233. 

  234. 		res4_0 *= alpha;

  235. 		res4_1 *= alpha;

  236. 		res4_2 *= alpha;

  237. 		res4_3 *= alpha;

  238. 

  239. 		res5_0 *= alpha;

  240. 		res5_1 *= alpha;

  241. 		res5_2 *= alpha;

  242. 		res5_3 *= alpha;

  243. 

  244. 		res6_0 *= alpha;

  245. 		res6_1 *= alpha;

  246. 		res6_2 *= alpha;

  247. 		res6_3 *= alpha;

  248. 

  249. 		res7_0 *= alpha;

  250. 		res7_1 *= alpha;

  251. 		res7_2 *= alpha;

  252. 		res7_3 *= alpha;

  253. 

  254. 

  255. 		C0[0] = res0_0;

  256. 		C0[1] = res0_1;

  257. 		C0[2] = res0_2;

  258. 		C0[3] = res0_3;

  259. 

  260. 		C1[0] = res1_0;

  261. 		C1[1] = res1_1;

  262. 		C1[2] = res1_2;

  263. 		C1[3] = res1_3;

  264. 

  265. 		C2[0] = res2_0;

  266. 		C2[1] = res2_1;

  267. 		C2[2] = res2_2;

  268. 		C2[3] = res2_3;

  269. 

  270. 		C3[0] = res3_0;

  271. 		C3[1] = res3_1;

  272. 		C3[2] = res3_2;

  273. 		C3[3] = res3_3;

  274. 

  275. 		C4[0] = res4_0;

  276. 		C4[1] = res4_1;

  277. 		C4[2] = res4_2;

  278. 		C4[3] = res4_3;

  279. 

  280. 		C5[0] = res5_0;

  281. 		C5[1] = res5_1;

  282. 		C5[2] = res5_2;

  283. 		C5[3] = res5_3;

  284. 

  285. 		C6[0] = res6_0;

  286. 		C6[1] = res6_1;

  287. 		C6[2] = res6_2;

  288. 		C6[3] = res6_3;

  289. 

  290. 		C7[0] = res7_0;

  291. 		C7[1] = res7_1;

  292. 		C7[2] = res7_2;

  293. 		C7[3] = res7_3;

  294. 

  295. 		if (!backwards) {

  296.                     temp = bk-off;

  297.                     temp = left ? temp - 4 : // number of values in A

  298.                                   temp - 8;  // number of values in B

  299. 

  300.                     ptrba += temp*4; // number of values in A

  301. 		    ptrbb += temp*8; // number of values in B

  302.                 }

  303. #ifdef LEFT

  304. 		off += 4; // number of values in A

  305. #endif

  306. 

  307. 		C0 = C0+4;

  308. 		C1 = C1+4;

  309. 		C2 = C2+4;

  310. 		C3 = C3+4;

  311. 		C4 = C4+4;

  312. 		C5 = C5+4;

  313. 		C6 = C6+4;

  314. 		C7 = C7+4;

  315. 

  316. 	}

  317. 

  318. 	if ( bm & 2 ) // do any 2x4 loop

  319. 	{

  320. 

  321. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  322. 		ptrbb = bb;

  323. #else

  324. 		ptrba += off*2;

  325. 		ptrbb = bb + off*8;

  326. #endif

  327. 

  328. 		res0_0 = 0;

  329. 		res0_1 = 0;

  330. 

  331. 		res1_0 = 0;

  332. 		res1_1 = 0;

  333. 

  334. 		res2_0 = 0;

  335. 		res2_1 = 0;

  336. 

  337. 		res3_0 = 0;

  338. 		res3_1 = 0;

  339. 

  340. 		res4_0 = 0;

  341. 		res4_1 = 0;

  342. 

  343. 		res5_0 = 0;

  344. 		res5_1 = 0;

  345. 

  346. 		res6_0 = 0;

  347. 		res6_1 = 0;

  348. 

  349. 		res7_0 = 0;

  350. 		res7_1 = 0;

  351. 

  352. 

  353. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  354. 		temp = bk-off;

  355. #elif defined(LEFT)

  356. 		temp = off+2;	// number of values in A

  357. #else

  358. 		temp = off+8;	// number of values in B

  359. #endif

  360. 

  361. 		for (k=0; k<temp; k++)

  362.                 {

  363. 			b0 = ptrbb[0];

  364. 			b1 = ptrbb[1];

  365. 			b2 = ptrbb[2];

  366. 			b3 = ptrbb[3];

  367. 			b4 = ptrbb[4];

  368. 			b5 = ptrbb[5];

  369. 			b6 = ptrbb[6];

  370. 			b7 = ptrbb[7];

  371. 

  372. 			a0 = ptrba[0];

  373. 			res0_0 += a0*b0;

  374. 			res1_0 += a0*b1;

  375. 			res2_0 += a0*b2;

  376. 			res3_0 += a0*b3;

  377. 			res4_0 += a0*b4;

  378. 			res5_0 += a0*b5;

  379. 			res6_0 += a0*b6;

  380. 			res7_0 += a0*b7;

  381. 

  382. 			a1 = ptrba[1];

  383. 			res0_1 += a1*b0;

  384. 			res1_1 += a1*b1;

  385. 			res2_1 += a1*b2;

  386. 			res3_1 += a1*b3;

  387. 			res4_1 += a1*b4;

  388. 			res5_1 += a1*b5;

  389. 			res6_1 += a1*b6;

  390. 			res7_1 += a1*b7;

  391. 

  392. 			ptrba = ptrba+2;

  393. 			ptrbb = ptrbb+8;

  394.                 }

  395. 

  396. 		res0_0 *= alpha;

  397. 		res0_1 *= alpha;

  398. 

  399. 		res1_0 *= alpha;

  400. 		res1_1 *= alpha;

  401. 

  402. 		res2_0 *= alpha;

  403. 		res2_1 *= alpha;

  404. 

  405. 		res3_0 *= alpha;

  406. 		res3_1 *= alpha;

  407. 

  408. 		res4_0 *= alpha;

  409. 		res4_1 *= alpha;

  410. 

  411. 		res5_0 *= alpha;

  412. 		res5_1 *= alpha;

  413. 

  414. 		res6_0 *= alpha;

  415. 		res6_1 *= alpha;

  416. 

  417. 		res7_0 *= alpha;

  418. 		res7_1 *= alpha;

  419. 

  420. 		C0[0] = res0_0;

  421. 		C0[1] = res0_1;

  422. 

  423. 		C1[0] = res1_0;

  424. 		C1[1] = res1_1;

  425. 

  426. 		C2[0] = res2_0;

  427. 		C2[1] = res2_1;

  428. 

  429. 		C3[0] = res3_0;

  430. 		C3[1] = res3_1;

  431. 

  432. 		C4[0] = res4_0;

  433. 		C4[1] = res4_1;

  434. 

  435. 		C5[0] = res5_0;

  436. 		C5[1] = res5_1;

  437. 

  438. 		C6[0] = res6_0;

  439. 		C6[1] = res6_1;

  440. 

  441. 		C7[0] = res7_0;

  442. 		C7[1] = res7_1;

  443. 

  444. 

  445. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  446. 		temp = bk - off;

  447. #ifdef LEFT

  448. 		temp -= 2; // number of values in A

  449. #else

  450. 		temp -= 8; // number of values in B

  451. #endif

  452. 		ptrba += temp*2;

  453. 		ptrbb += temp*8;

  454. #endif

  455. 

  456. #ifdef LEFT

  457. 		off += 2; // number of values in A

  458. #endif

  459. 

  460. 		C0 = C0+2;

  461. 		C1 = C1+2;

  462. 		C2 = C2+2;

  463. 		C3 = C3+2;

  464. 		C4 = C4+2;

  465. 		C5 = C5+2;

  466. 		C6 = C6+2;

  467. 		C7 = C7+2;

  468. 

  469. 	}

  470. 

  471. 	if ( bm & 1 ) // do any 1x4 loop

  472. 	{

  473. 

  474. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  475. 		ptrbb = bb;

  476. #else

  477. 		ptrba += off*1;

  478. 		ptrbb = bb + off*8;

  479. #endif

  480. 

  481. 		res0_0 = 0;

  482. 		res1_0 = 0;

  483. 		res2_0 = 0;

  484. 		res3_0 = 0;

  485. 		res4_0 = 0;

  486. 		res5_0 = 0;

  487. 		res6_0 = 0;

  488. 		res7_0 = 0;

  489. 

  490. 

  491. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  492. 		temp = bk-off;

  493. #elif defined(LEFT)

  494. 		temp = off+1;	// number of values in A

  495. #else

  496. 		temp = off+8;	// number of values in B

  497. #endif

  498. 

  499. 		for (k=0; k<temp; k++)

  500.                 {

  501. 			b0 = ptrbb[0];

  502. 			b1 = ptrbb[1];

  503. 			b2 = ptrbb[2];

  504. 			b3 = ptrbb[3];

  505. 			b4 = ptrbb[4];

  506. 			b5 = ptrbb[5];

  507. 			b6 = ptrbb[6];

  508. 			b7 = ptrbb[7];

  509. 

  510. 			a0 = ptrba[0];

  511. 			res0_0 += a0*b0;

  512. 			res1_0 += a0*b1;

  513. 			res2_0 += a0*b2;

  514. 			res3_0 += a0*b3;

  515. 			res4_0 += a0*b4;

  516. 			res5_0 += a0*b5;

  517. 			res6_0 += a0*b6;

  518. 			res7_0 += a0*b7;

  519. 

  520. 			ptrba = ptrba+1;

  521. 			ptrbb = ptrbb+8;

  522.                 }

  523. 

  524. 		res0_0 *= alpha;

  525. 

  526. 		res1_0 *= alpha;

  527. 

  528. 		res2_0 *= alpha;

  529. 

  530. 		res3_0 *= alpha;

  531. 		res4_0 *= alpha;

  532. 		res5_0 *= alpha;

  533. 		res6_0 *= alpha;

  534. 		res7_0 *= alpha;

  535. 

  536. 		C0[0] = res0_0;

  537. 

  538. 		C1[0] = res1_0;

  539. 

  540. 		C2[0] = res2_0;

  541. 

  542. 		C3[0] = res3_0;

  543. 		C4[0] = res4_0;

  544. 		C5[0] = res5_0;

  545. 		C6[0] = res6_0;

  546. 		C7[0] = res7_0;

  547. 

  548. 

  549. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  550. 		temp = bk - off;

  551. #ifdef LEFT

  552. 		temp -= 1; // number of values in A

  553. #else

  554. 		temp -= 8; // number of values in B

  555. #endif

  556. 		ptrba += temp*1;

  557. 		ptrbb += temp*8;

  558. #endif

  559. 

  560. #ifdef LEFT

  561. 		off += 1; // number of values in A

  562. #endif

  563. 

  564. 		C0 = C0+1;

  565. 		C1 = C1+1;

  566. 		C2 = C2+1;

  567. 		C3 = C3+1;

  568. 		C4 = C4+1;

  569. 		C5 = C5+1;

  570. 		C6 = C6+1;

  571. 		C7 = C7+1;

  572. 

  573. 	}

  574. 

  575. 

  576. #if defined(TRMMKERNEL) && !defined(LEFT)

  577. 		off += 8;

  578. #endif

  579. 

  580.         k = (bk<<3);

  581.         bb = bb+k;

  582.         i = (ldc<<3);

  583.         C = C+i;

  584.     }

  585. 

  586. 

  587. 

  588.    for (j=0; j<(bn&4); j+=4) // do blocks of the Mx4 loops 

  589.    {

  590.         C0 = C;

  591.         C1 = C0+ldc;

  592.         C2 = C1+ldc;

  593.         C3 = C2+ldc;

  594. 

  595. 

  596.         if (left) {

  597.             off = offset;

  598.         }

  599. 

  600.         ptrba = ba;

  601. 

  602.         for (i=0; i<bm/4; i+=1) // do blocks of 4x4

  603. 	{

  604. 

  605. 		ptrbb = bb;

  606.                 if (backwards)

  607.                 {

  608. 		   ptrba += off*4; // number of values in A

  609. 		   ptrbb += off*4; // number of values in B

  610.                 }

  611. 

  612. 		res0_0 = 0;

  613. 		res0_1 = 0;

  614. 		res0_2 = 0;

  615. 		res0_3 = 0;

  616. 

  617. 		res1_0 = 0;

  618. 		res1_1 = 0;

  619. 		res1_2 = 0;

  620. 		res1_3 = 0;

  621. 

  622. 		res2_0 = 0;

  623. 		res2_1 = 0;

  624. 		res2_2 = 0;

  625. 		res2_3 = 0;

  626. 

  627. 		res3_0 = 0;

  628. 		res3_1 = 0;

  629. 		res3_2 = 0;

  630. 		res3_3 = 0;

  631. 

  632.                 temp = backwards ? bk-off :

  633.                              left ? off + 4 : // number of values in A

  634.                                     off + 4;  // number of values in B

  635. 

  636. 		for (k=0; k<temp; k++)

  637.                 {

  638. 			b0 = ptrbb[0];

  639. 			b1 = ptrbb[1];

  640. 			b2 = ptrbb[2];

  641. 			b3 = ptrbb[3];

  642. 

  643. 			a0 = ptrba[0];

  644. 			res0_0 += a0*b0;

  645. 			res1_0 += a0*b1;

  646. 			res2_0 += a0*b2;

  647. 			res3_0 += a0*b3;

  648. 

  649. 			a1 = ptrba[1];

  650. 			res0_1 += a1*b0;

  651. 			res1_1 += a1*b1;

  652. 			res2_1 += a1*b2;

  653. 			res3_1 += a1*b3;

  654. 

  655. 			a0 = ptrba[2];

  656. 			res0_2 += a0*b0;

  657. 			res1_2 += a0*b1;

  658. 			res2_2 += a0*b2;

  659. 			res3_2 += a0*b3;

  660. 

  661. 			a1 = ptrba[3];

  662. 			res0_3 += a1*b0;

  663. 			res1_3 += a1*b1;

  664. 			res2_3 += a1*b2;

  665. 			res3_3 += a1*b3;

  666. 

  667. 			ptrba = ptrba+4;

  668. 			ptrbb = ptrbb+4;

  669.                 }

  670. 

  671. 		res0_0 *= alpha;

  672. 		res0_1 *= alpha;

  673. 		res0_2 *= alpha;

  674. 		res0_3 *= alpha;

  675. 

  676. 		res1_0 *= alpha;

  677. 		res1_1 *= alpha;

  678. 		res1_2 *= alpha;

  679. 		res1_3 *= alpha;

  680. 

  681. 		res2_0 *= alpha;

  682. 		res2_1 *= alpha;

  683. 		res2_2 *= alpha;

  684. 		res2_3 *= alpha;

  685. 

  686. 		res3_0 *= alpha;

  687. 		res3_1 *= alpha;

  688. 		res3_2 *= alpha;

  689. 		res3_3 *= alpha;

  690. 

  691. 		C0[0] = res0_0;

  692. 		C0[1] = res0_1;

  693. 		C0[2] = res0_2;

  694. 		C0[3] = res0_3;

  695. 

  696. 		C1[0] = res1_0;

  697. 		C1[1] = res1_1;

  698. 		C1[2] = res1_2;

  699. 		C1[3] = res1_3;

  700. 

  701. 		C2[0] = res2_0;

  702. 		C2[1] = res2_1;

  703. 		C2[2] = res2_2;

  704. 		C2[3] = res2_3;

  705. 

  706. 		C3[0] = res3_0;

  707. 		C3[1] = res3_1;

  708. 		C3[2] = res3_2;

  709. 		C3[3] = res3_3;

  710. 

  711. 		if (!backwards) {

  712.                     temp = bk-off;

  713.                     temp = left ? temp - 4 : // number of values in A

  714.                                   temp - 4;  // number of values in B

  715. 

  716.                     ptrba += temp*4; // number of values in A

  717. 		    ptrbb += temp*4; // number of values in B

  718.                 }

  719. #ifdef LEFT

  720. 		off += 4; // number of values in A

  721. #endif

  722. 

  723. 		C0 = C0+4;

  724. 		C1 = C1+4;

  725. 		C2 = C2+4;

  726. 		C3 = C3+4;

  727. 

  728. 	}

  729. 

  730. 	if ( bm & 2 ) // do any 2x4 loop

  731. 	{

  732. 

  733. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  734. 		ptrbb = bb;

  735. #else

  736. 		ptrba += off*2;

  737. 		ptrbb = bb + off*4;

  738. #endif

  739. 

  740. 		res0_0 = 0;

  741. 		res0_1 = 0;

  742. 

  743. 		res1_0 = 0;

  744. 		res1_1 = 0;

  745. 

  746. 		res2_0 = 0;

  747. 		res2_1 = 0;

  748. 

  749. 		res3_0 = 0;

  750. 		res3_1 = 0;

  751. 

  752. 

  753. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  754. 		temp = bk-off;

  755. #elif defined(LEFT)

  756. 		temp = off+2;	// number of values in A

  757. #else

  758. 		temp = off+4;	// number of values in B

  759. #endif

  760. 

  761. 		for (k=0; k<temp; k++)

  762.                 {

  763. 			b0 = ptrbb[0];

  764. 			b1 = ptrbb[1];

  765. 			b2 = ptrbb[2];

  766. 			b3 = ptrbb[3];

  767. 

  768. 			a0 = ptrba[0];

  769. 			res0_0 += a0*b0;

  770. 			res1_0 += a0*b1;

  771. 			res2_0 += a0*b2;

  772. 			res3_0 += a0*b3;

  773. 

  774. 			a1 = ptrba[1];

  775. 			res0_1 += a1*b0;

  776. 			res1_1 += a1*b1;

  777. 			res2_1 += a1*b2;

  778. 			res3_1 += a1*b3;

  779. 

  780. 			ptrba = ptrba+2;

  781. 			ptrbb = ptrbb+4;

  782.                 }

  783. 

  784. 		res0_0 *= alpha;

  785. 		res0_1 *= alpha;

  786. 

  787. 		res1_0 *= alpha;

  788. 		res1_1 *= alpha;

  789. 

  790. 		res2_0 *= alpha;

  791. 		res2_1 *= alpha;

  792. 

  793. 		res3_0 *= alpha;

  794. 		res3_1 *= alpha;

  795. 

  796. 		C0[0] = res0_0;

  797. 		C0[1] = res0_1;

  798. 

  799. 		C1[0] = res1_0;

  800. 		C1[1] = res1_1;

  801. 

  802. 		C2[0] = res2_0;

  803. 		C2[1] = res2_1;

  804. 

  805. 		C3[0] = res3_0;

  806. 		C3[1] = res3_1;

  807. 

  808. 

  809. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  810. 		temp = bk - off;

  811. #ifdef LEFT

  812. 		temp -= 2; // number of values in A

  813. #else

  814. 		temp -= 4; // number of values in B

  815. #endif

  816. 		ptrba += temp*2;

  817. 		ptrbb += temp*4;

  818. #endif

  819. 

  820. #ifdef LEFT

  821. 		off += 2; // number of values in A

  822. #endif

  823. 

  824. 		C0 = C0+2;

  825. 		C1 = C1+2;

  826. 		C2 = C2+2;

  827. 		C3 = C3+2;

  828. 

  829. 	}

  830. 

  831. 	if ( bm & 1 ) // do any 1x4 loop

  832. 	{

  833. 

  834. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  835. 		ptrbb = bb;

  836. #else

  837. 		ptrba += off*1;

  838. 		ptrbb = bb + off*4;

  839. #endif

  840. 

  841. 		res0_0 = 0;

  842. 		res1_0 = 0;

  843. 		res2_0 = 0;

  844. 		res3_0 = 0;

  845. 

  846. 

  847. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  848. 		temp = bk-off;

  849. #elif defined(LEFT)

  850. 		temp = off+1;	// number of values in A

  851. #else

  852. 		temp = off+4;	// number of values in B

  853. #endif

  854. 

  855. 		for (k=0; k<temp; k++)

  856.                 {

  857. 			b0 = ptrbb[0];

  858. 			b1 = ptrbb[1];

  859. 			b2 = ptrbb[2];

  860. 			b3 = ptrbb[3];

  861. 

  862. 			a0 = ptrba[0];

  863. 			res0_0 += a0*b0;

  864. 			res1_0 += a0*b1;

  865. 			res2_0 += a0*b2;

  866. 			res3_0 += a0*b3;

  867. 

  868. 			ptrba = ptrba+1;

  869. 			ptrbb = ptrbb+4;

  870.                 }

  871. 

  872. 		res0_0 *= alpha;

  873. 

  874. 		res1_0 *= alpha;

  875. 

  876. 		res2_0 *= alpha;

  877. 

  878. 		res3_0 *= alpha;

  879. 

  880. 		C0[0] = res0_0;

  881. 

  882. 		C1[0] = res1_0;

  883. 

  884. 		C2[0] = res2_0;

  885. 

  886. 		C3[0] = res3_0;

  887. 

  888. 

  889. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  890. 		temp = bk - off;

  891. #ifdef LEFT

  892. 		temp -= 1; // number of values in A

  893. #else

  894. 		temp -= 4; // number of values in B

  895. #endif

  896. 		ptrba += temp*1;

  897. 		ptrbb += temp*4;

  898. #endif

  899. 

  900. #ifdef LEFT

  901. 		off += 1; // number of values in A

  902. #endif

  903. 

  904. 		C0 = C0+1;

  905. 		C1 = C1+1;

  906. 		C2 = C2+1;

  907. 		C3 = C3+1;

  908. 

  909. 	}

  910. 

  911. 

  912. #if defined(TRMMKERNEL) && !defined(LEFT)

  913. 		off += 4;

  914. #endif

  915. 

  916.         k = (bk<<2);

  917.         bb = bb+k;

  918.         i = (ldc<<2);

  919.         C = C+i;

  920.     }

  921. 

  922. 

  923. 

  924.    for (j=0; j<(bn&2); j+=2) // do the Mx2 loops 

  925.    {

  926.         C0 = C;

  927.         C1 = C0+ldc;

  928. 

  929. #if defined(TRMMKERNEL) && defined(LEFT)

  930. 		off = offset;

  931. #endif

  932. 

  933. 

  934.         ptrba = ba;

  935. 

  936.         for (i=0; i<bm/4; i+=1) // do blocks of 4x2

  937. 	{

  938. 

  939. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  940. 		ptrbb = bb;

  941. #else

  942. 		ptrba += off*4;

  943. 		ptrbb = bb + off*2;

  944. #endif

  945. 

  946. 		res0_0 = 0;

  947. 		res0_1 = 0;

  948. 		res0_2 = 0;

  949. 		res0_3 = 0;

  950. 

  951. 		res1_0 = 0;

  952. 		res1_1 = 0;

  953. 		res1_2 = 0;

  954. 		res1_3 = 0;

  955. 

  956. 

  957. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  958. 		temp = bk-off;

  959. #elif defined(LEFT)

  960. 		temp = off+4;	// number of values in A

  961. #else

  962. 		temp = off+2;	// number of values in B

  963. #endif

  964. 

  965. 		for (k=0; k<temp; k++)

  966.                 {

  967. 			b0 = ptrbb[0];

  968. 			b1 = ptrbb[1];

  969. 

  970. 			a0 = ptrba[0];

  971. 			res0_0 += a0*b0;

  972. 			res1_0 += a0*b1;

  973. 

  974. 			a1 = ptrba[1];

  975. 			res0_1 += a1*b0;

  976. 			res1_1 += a1*b1;

  977. 

  978. 			a0 = ptrba[2];

  979. 			res0_2 += a0*b0;

  980. 			res1_2 += a0*b1;

  981. 

  982. 			a1 = ptrba[3];

  983. 			res0_3 += a1*b0;

  984. 			res1_3 += a1*b1;

  985. 

  986. 			ptrba = ptrba+4;

  987. 			ptrbb = ptrbb+2;

  988.                 }

  989. 

  990. 		res0_0 *= alpha;

  991. 		res0_1 *= alpha;

  992. 		res0_2 *= alpha;

  993. 		res0_3 *= alpha;

  994. 

  995. 		res1_0 *= alpha;

  996. 		res1_1 *= alpha;

  997. 		res1_2 *= alpha;

  998. 		res1_3 *= alpha;

  999. 

  1000. 		C0[0] = res0_0;

  1001. 		C0[1] = res0_1;

  1002. 		C0[2] = res0_2;

  1003. 		C0[3] = res0_3;

  1004. 

  1005. 		C1[0] = res1_0;

  1006. 		C1[1] = res1_1;

  1007. 		C1[2] = res1_2;

  1008. 		C1[3] = res1_3;

  1009. 

  1010. 

  1011. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1012. 		temp = bk - off;

  1013. #ifdef LEFT

  1014. 		temp -= 4; // number of values in A

  1015. #else

  1016. 		temp -= 2; // number of values in B

  1017. #endif

  1018. 		ptrba += temp*4;

  1019. 		ptrbb += temp*2;

  1020. #endif

  1021. 

  1022. #ifdef LEFT

  1023. 		off += 4; // number of values in A

  1024. #endif

  1025. 

  1026. 		C0 = C0+4;

  1027. 		C1 = C1+4;

  1028. 

  1029. 	}

  1030. 

  1031. 	if ( bm & 2 ) // do any 2x2 loop

  1032. 	{

  1033. 

  1034. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1035. 		ptrbb = bb;

  1036. #else

  1037. 		ptrba += off*2;

  1038. 		ptrbb = bb + off*2;

  1039. #endif

  1040. 

  1041. 		res0_0 = 0;

  1042. 		res0_1 = 0;

  1043. 

  1044. 		res1_0 = 0;

  1045. 		res1_1 = 0;

  1046. 

  1047. 

  1048. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  1049. 		temp = bk-off;

  1050. #elif defined(LEFT)

  1051. 		temp = off+2;	// number of values in A

  1052. #else

  1053. 		temp = off+2;	// number of values in B

  1054. #endif

  1055. 

  1056. 		for (k=0; k<temp; k++)

  1057.                 {

  1058. 			b0 = ptrbb[0];

  1059. 			b1 = ptrbb[1];

  1060. 

  1061. 			a0 = ptrba[0];

  1062. 			res0_0 += a0*b0;

  1063. 			res1_0 += a0*b1;

  1064. 

  1065. 			a1 = ptrba[1];

  1066. 			res0_1 += a1*b0;

  1067. 			res1_1 += a1*b1;

  1068. 

  1069. 			ptrba = ptrba+2;

  1070. 			ptrbb = ptrbb+2;

  1071.                 }

  1072. 

  1073. 		res0_0 *= alpha;

  1074. 		res0_1 *= alpha;

  1075. 

  1076. 		res1_0 *= alpha;

  1077. 		res1_1 *= alpha;

  1078. 

  1079. 		C0[0] = res0_0;

  1080. 		C0[1] = res0_1;

  1081. 

  1082. 		C1[0] = res1_0;

  1083. 		C1[1] = res1_1;

  1084. 

  1085. 

  1086. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1087. 		temp = bk - off;

  1088. #ifdef LEFT

  1089. 		temp -= 2; // number of values in A

  1090. #else

  1091. 		temp -= 2; // number of values in B

  1092. #endif

  1093. 		ptrba += temp*2;

  1094. 		ptrbb += temp*2;

  1095. #endif

  1096. 

  1097. #ifdef LEFT

  1098. 		off += 2; // number of values in A

  1099. #endif

  1100. 

  1101. 		C0 = C0+2;

  1102. 		C1 = C1+2;

  1103. 

  1104. 	}

  1105. 

  1106. 	if ( bm & 1 ) // do any 1x2 loop

  1107. 	{

  1108. 

  1109. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1110. 		ptrbb = bb;

  1111. #else

  1112. 		ptrba += off*1;

  1113. 		ptrbb = bb + off*2;

  1114. #endif

  1115. 

  1116. 		res0_0 = 0;

  1117. 

  1118. 		res1_0 = 0;

  1119. 

  1120. 

  1121. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  1122. 		temp = bk-off;

  1123. #elif defined(LEFT)

  1124. 		temp = off+1;	// number of values in A

  1125. #else

  1126. 		temp = off+2;	// number of values in B

  1127. #endif

  1128. 

  1129. 		for (k=0; k<temp; k++)

  1130.                 {

  1131. 			b0 = ptrbb[0];

  1132. 			b1 = ptrbb[1];

  1133. 

  1134. 			a0 = ptrba[0];

  1135. 			res0_0 += a0*b0;

  1136. 			res1_0 += a0*b1;

  1137. 

  1138. 			ptrba = ptrba+1;

  1139. 			ptrbb = ptrbb+2;

  1140.                 }

  1141. 

  1142. 		res0_0 *= alpha;

  1143. 

  1144. 		res1_0 *= alpha;

  1145. 

  1146. 		C0[0] = res0_0;

  1147. 

  1148. 		C1[0] = res1_0;

  1149. 

  1150. 

  1151. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1152. 		temp = bk - off;

  1153. #ifdef LEFT

  1154. 		temp -= 1; // number of values in A

  1155. #else

  1156. 		temp -= 2; // number of values in B

  1157. #endif

  1158. 		ptrba += temp*1;

  1159. 		ptrbb += temp*2;

  1160. #endif

  1161. 

  1162. #ifdef LEFT

  1163. 		off += 1; // number of values in A

  1164. #endif

  1165. 

  1166. 		C0 = C0+1;

  1167. 		C1 = C1+1;

  1168. 

  1169. 	}

  1170. 

  1171. 

  1172. #if defined(TRMMKERNEL) && !defined(LEFT)

  1173. 		off += 2;

  1174. #endif

  1175. 

  1176.         k = (bk<<1);

  1177.         bb = bb+k;

  1178.         i = (ldc<<1);

  1179.         C = C+i;

  1180.     }

  1181. 

  1182. 

  1183. 

  1184. 

  1185. 

  1186. 

  1187. 

  1188.    for (j=0; j<(bn&1); j+=1) // do the Mx1 loops

  1189.    {

  1190.         C0 = C;

  1191. 

  1192. #if defined(TRMMKERNEL) &&  defined(LEFT)

  1193. 	off = offset;

  1194. #endif

  1195. 

  1196.         ptrba = ba;

  1197. 

  1198.         for (i=0; i<bm/4; i+=1) // do blocks of 4x1 loops

  1199. 	{

  1200. 

  1201. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1202. 		ptrbb = bb;

  1203. #else

  1204. 		ptrba += off*4;

  1205. 		ptrbb = bb + off*1;

  1206. #endif

  1207. 

  1208. 		res0_0 = 0;

  1209. 		res0_1 = 0;

  1210. 		res0_2 = 0;

  1211. 		res0_3 = 0;

  1212. 

  1213. 

  1214. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  1215. 		temp = bk-off;

  1216. #elif defined(LEFT)

  1217. 		temp = off+4;	// number of values in A

  1218. #else

  1219. 		temp = off+1;	// number of values in B

  1220. #endif

  1221. 

  1222. 		for (k=0; k<temp; k++)

  1223.                 {

  1224. 			b0 = ptrbb[0];

  1225. 

  1226. 			a0 = ptrba[0];

  1227. 			res0_0 += a0*b0;

  1228. 

  1229. 			a1 = ptrba[1];

  1230. 			res0_1 += a1*b0;

  1231. 

  1232. 			a0 = ptrba[2];

  1233. 			res0_2 += a0*b0;

  1234. 

  1235. 			a1 = ptrba[3];

  1236. 			res0_3 += a1*b0;

  1237. 

  1238. 			ptrba = ptrba+4;

  1239. 			ptrbb = ptrbb+1;

  1240.                 }

  1241. 

  1242. 		res0_0 *= alpha;

  1243. 		res0_1 *= alpha;

  1244. 		res0_2 *= alpha;

  1245. 		res0_3 *= alpha;

  1246. 

  1247. 		C0[0] = res0_0;

  1248. 		C0[1] = res0_1;

  1249. 		C0[2] = res0_2;

  1250. 		C0[3] = res0_3;

  1251. 

  1252. 

  1253. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1254. 		temp = bk - off;

  1255. #ifdef LEFT

  1256. 		temp -= 4; // number of values in A

  1257. #else

  1258. 		temp -= 1; // number of values in B

  1259. #endif

  1260. 		ptrba += temp*4;

  1261. 		ptrbb += temp*1;

  1262. #endif

  1263. 

  1264. #ifdef LEFT

  1265. 		off += 4; // number of values in A

  1266. #endif

  1267. 

  1268. 		C0 = C0+4;

  1269. 

  1270. 	}

  1271. 

  1272. 	if ( bm & 2 ) // do any 2x1 loop

  1273. 	{

  1274. 

  1275. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1276. 		ptrbb = bb;

  1277. #else

  1278. 		ptrba += off*2;

  1279. 		ptrbb = bb + off*1;

  1280. #endif

  1281. 

  1282. 		res0_0 = 0;

  1283. 		res0_1 = 0;

  1284. 

  1285. 

  1286. 

  1287. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  1288. 		temp = bk-off;

  1289. #elif defined(LEFT)

  1290. 		temp = off+2;	// number of values in A

  1291. #else

  1292. 		temp = off+1;	// number of values in B

  1293. #endif

  1294. 

  1295. 		for (k=0; k<temp; k++)

  1296.                 {

  1297. 			b0 = ptrbb[0];

  1298. 

  1299. 			a0 = ptrba[0];

  1300. 			res0_0 += a0*b0;

  1301. 

  1302. 			a1 = ptrba[1];

  1303. 			res0_1 += a1*b0;

  1304. 

  1305. 			ptrba = ptrba+2;

  1306. 			ptrbb = ptrbb+1;

  1307.                 }

  1308. 

  1309. 		res0_0 *= alpha;

  1310. 		res0_1 *= alpha;

  1311. 

  1312. 		C0[0] = res0_0;

  1313. 		C0[1] = res0_1;

  1314. 

  1315. 

  1316. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1317. 		temp = bk - off;

  1318. #ifdef LEFT

  1319. 		temp -= 2; // number of values in A

  1320. #else

  1321. 		temp -= 1; // number of values in B

  1322. #endif

  1323. 		ptrba += temp*2;

  1324. 		ptrbb += temp*1;

  1325. #endif

  1326. 

  1327. #ifdef LEFT

  1328. 		off += 2; // number of values in A

  1329. #endif

  1330. 

  1331. 		C0 = C0+2;

  1332. 

  1333. 	}

  1334. 

  1335. 	if ( bm & 1 ) // do any 1x1 loop

  1336. 	{

  1337. 

  1338. #if (defined(LEFT) &&  defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1339. 		ptrbb = bb;

  1340. #else

  1341. 		ptrba += off*1;

  1342. 		ptrbb = bb + off*1;

  1343. #endif

  1344. 

  1345. 		res0_0 = 0;

  1346. 

  1347. 

  1348. #if (defined(LEFT) && !defined(TRANSA)) || (!defined(LEFT) && defined(TRANSA))

  1349. 		temp = bk-off;

  1350. #elif defined(LEFT)

  1351. 		temp = off+1;	// number of values in A

  1352. #else

  1353. 		temp = off+1;	// number of values in B

  1354. #endif

  1355. 

  1356. 		for (k=0; k<temp; k++)

  1357.                 {

  1358. 			b0 = ptrbb[0];

  1359. 

  1360. 			a0 = ptrba[0];

  1361. 			res0_0 += a0*b0;

  1362. 

  1363. 			ptrba = ptrba+1;

  1364. 			ptrbb = ptrbb+1;

  1365.                 }

  1366. 

  1367. 		res0_0 *= alpha;

  1368. 

  1369. 		C0[0] = res0_0;

  1370. 

  1371. 

  1372. #if ( defined(LEFT) && defined(TRANSA)) || (!defined(LEFT) && !defined(TRANSA))

  1373. 		temp = bk - off;

  1374. #ifdef LEFT

  1375. 		temp -= 1; // number of values in A

  1376. #else

  1377. 		temp -= 1; // number of values in B

  1378. #endif

  1379. 		ptrba += temp*1;

  1380. 		ptrbb += temp*1;

  1381. #endif

  1382. 

  1383. #ifdef LEFT

  1384. 		off += 1; // number of values in A

  1385. #endif

  1386. 

  1387. 		C0 = C0+1;

  1388. 

  1389. 	}

  1390. 

  1391. 

  1392. 

  1393. #if defined(TRMMKERNEL) && !defined(LEFT)

  1394. 		off += 1;

  1395. #endif

  1396. 

  1397.         k = (bk<<0);

  1398.         bb = bb+k;

  1399.         C = C+ldc;

  1400.    }

  1401.    return 0;

  1402. }