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

886 lines
18 kB
Raw Blame History 

  1. #include "common.h"

  2. 

  3. #define MADD_ALPHA_N_STORE(C, res, alpha) \

  4. 	C[0] = res ## _r * alpha ## _r - res ## _i * alpha ## _i; \

  5. 	C[1] = res ## _r * alpha ## _i + res ## _i * alpha ## _r;

  6. 

  7. #if defined(NN) || defined(NT) || defined(TN) || defined(TT)

  8. #define MADD(res, op1, op2) \

  9. 	res ## _r += op1 ## _r * op2 ## _r; \

  10. 	res ## _r -= op1 ## _i * op2 ## _i; \

  11. 	res ## _i += op1 ## _r * op2 ## _i; \

  12. 	res ## _i += op1 ## _i * op2 ## _r;

  13. #elif defined(NR) || defined(NC) || defined(TR) || defined(TC)

  14. #define MADD(res, op1, op2) \

  15. 	res ## _r += op1 ## _r * op2 ## _r; \

  16. 	res ## _r += op1 ## _i * op2 ## _i; \

  17. 	res ## _i -= op1 ## _r * op2 ## _i; \

  18. 	res ## _i += op1 ## _i * op2 ## _r;

  19. #elif defined(RN) || defined(RT) || defined(CN) || defined(CT)

  20. #define MADD(res, op1, op2) \

  21. 	res ## _r += op1 ## _r * op2 ## _r; \

  22. 	res ## _r += op1 ## _i * op2 ## _i; \

  23. 	res ## _i += op1 ## _r * op2 ## _i; \

  24. 	res ## _i -= op1 ## _i * op2 ## _r;

  25. #elif defined(RR) || defined(RC) || defined(CR) || defined(CC)

  26. #define MADD(res, op1, op2) \

  27. 	res ## _r += op1 ## _r * op2 ## _r; \

  28. 	res ## _r -= op1 ## _i * op2 ## _i; \

  29. 	res ## _i -= op1 ## _r * op2 ## _i; \

  30. 	res ## _i -= op1 ## _i * op2 ## _r;

  31. #endif

  32. 

  33. int CNAME(BLASLONG bm,BLASLONG bn,BLASLONG bk,FLOAT alpha_r, FLOAT alpha_i,FLOAT* ba,FLOAT* bb,FLOAT* C,BLASLONG ldc

  34. 		, BLASLONG offset

  35. 		)

  36. {

  37. 

  38. 	BLASLONG i,j,k;

  39. 	FLOAT *C0,*C1,*C2,*C3,*ptrba,*ptrbb;

  40. 	FLOAT res00_r, res01_r, res02_r, res03_r;

  41. 	FLOAT res00_i, res01_i, res02_i, res03_i;

  42. 	FLOAT res10_r, res11_r, res12_r, res13_r;

  43. 	FLOAT res10_i, res11_i, res12_i, res13_i;

  44. 	FLOAT res20_r, res21_r, res22_r, res23_r;

  45. 	FLOAT res20_i, res21_i, res22_i, res23_i;

  46. 	FLOAT res30_r, res31_r, res32_r, res33_r;

  47. 	FLOAT res30_i, res31_i, res32_i, res33_i;

  48. 	FLOAT a0_r, a1_r;

  49. 	FLOAT a0_i, a1_i;

  50. 	FLOAT b0_r, b1_r, b2_r, b3_r;

  51. 	FLOAT b0_i, b1_i, b2_i, b3_i;

  52. 	BLASLONG off, temp;

  53. 

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

  55. 	off = -offset;

  56. #else

  57. 	off = 0;

  58. #endif

  59. 

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

  61. 	{

  62. 		C0 = C;

  63. 		C1 = C0+2*ldc;

  64. 		C2 = C1+2*ldc;

  65. 		C3 = C2+2*ldc;

  66. 

  67. 

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

  69. 		off = offset;

  70. #endif

  71. 

  72. 		ptrba = ba;

  73. 

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

  75. 		{

  76. 

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

  78. 			ptrbb = bb;

  79. #else

  80. 

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

  82. 			ptrbb = bb + off*4*2; // number of values in B

  83. #endif

  84. 

  85. 			res00_r = 0;

  86. 			res00_i = 0;

  87. 			res01_r = 0;

  88. 			res01_i = 0;

  89. 			res02_r = 0;

  90. 			res02_i = 0;

  91. 			res03_r = 0;

  92. 			res03_i = 0;

  93. 

  94. 			res10_r = 0;

  95. 			res10_i = 0;

  96. 			res11_r = 0;

  97. 			res11_i = 0;

  98. 			res12_r = 0;

  99. 			res12_i = 0;

  100. 			res13_r = 0;

  101. 			res13_i = 0;

  102. 

  103. 			res20_r = 0;

  104. 			res20_i = 0;

  105. 			res21_r = 0;

  106. 			res21_i = 0;

  107. 			res22_r = 0;

  108. 			res22_i = 0;

  109. 			res23_r = 0;

  110. 			res23_i = 0;

  111. 

  112. 			res30_r = 0;

  113. 			res30_i = 0;

  114. 			res31_r = 0;

  115. 			res31_i = 0;

  116. 			res32_r = 0;

  117. 			res32_i = 0;

  118. 			res33_r = 0;

  119. 			res33_i = 0;

  120. 

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

  122. 			temp = bk - off;

  123. #elif defined(LEFT)

  124. 			temp = off + 4;

  125. #else

  126. 			temp = off + 4;

  127. #endif

  128. 

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

  130. 			{

  131. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  132. 				b1_r = ptrbb[2*1+0]; b1_i = ptrbb[2*1+1];

  133. 				b2_r = ptrbb[2*2+0]; b2_i = ptrbb[2*2+1];

  134. 				b3_r = ptrbb[2*3+0]; b3_i = ptrbb[2*3+1];

  135. 

  136. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  137. 				MADD(res00, a0, b0);

  138. 				MADD(res10, a0, b1);

  139. 				MADD(res20, a0, b2);

  140. 				MADD(res30, a0, b3);

  141. 

  142. 				a1_r = ptrba[2*1+0]; a1_i = ptrba[2*1+1];

  143. 				MADD(res01, a1, b0);

  144. 				MADD(res11, a1, b1);

  145. 				MADD(res21, a1, b2);

  146. 				MADD(res31, a1, b3);

  147. 

  148. 				a0_r = ptrba[2*2+0]; a0_i = ptrba[2*2+1];

  149. 				MADD(res02, a0, b0);

  150. 				MADD(res12, a0, b1);

  151. 				MADD(res22, a0, b2);

  152. 				MADD(res32, a0, b3);

  153. 

  154. 

  155. 				a1_r = ptrba[2*3+0]; a1_i = ptrba[2*3+1];

  156. 				MADD(res03, a1, b0);

  157. 				MADD(res13, a1, b1);

  158. 				MADD(res23, a1, b2);

  159. 				MADD(res33, a1, b3);

  160. 

  161. 				ptrba = ptrba+8;

  162. 				ptrbb = ptrbb+8;

  163. 			}

  164. 

  165. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  166. 			C0 = C0 + 2;

  167. 			MADD_ALPHA_N_STORE(C0, res01, alpha);

  168. 			C0 = C0 + 2;

  169. 			MADD_ALPHA_N_STORE(C0, res02, alpha);

  170. 			C0 = C0 + 2;

  171. 			MADD_ALPHA_N_STORE(C0, res03, alpha);

  172. 			C0 = C0 + 2;

  173. 

  174. 			MADD_ALPHA_N_STORE(C1, res10, alpha);

  175. 			C1 = C1 + 2;

  176. 			MADD_ALPHA_N_STORE(C1, res11, alpha);

  177. 			C1 = C1 + 2;

  178. 			MADD_ALPHA_N_STORE(C1, res12, alpha);

  179. 			C1 = C1 + 2;

  180. 			MADD_ALPHA_N_STORE(C1, res13, alpha);

  181. 			C1 = C1 + 2;

  182. 

  183. 			MADD_ALPHA_N_STORE(C2, res20, alpha);

  184. 			C2 = C2 + 2;

  185. 			MADD_ALPHA_N_STORE(C2, res21, alpha);

  186. 			C2 = C2 + 2;

  187. 			MADD_ALPHA_N_STORE(C2, res22, alpha);

  188. 			C2 = C2 + 2;

  189. 			MADD_ALPHA_N_STORE(C2, res23, alpha);

  190. 			C2 = C2 + 2;

  191. 

  192. 			MADD_ALPHA_N_STORE(C3, res30, alpha);

  193. 			C3 = C3 + 2;

  194. 			MADD_ALPHA_N_STORE(C3, res31, alpha);

  195. 			C3 = C3 + 2;

  196. 			MADD_ALPHA_N_STORE(C3, res32, alpha);

  197. 			C3 = C3 + 2;

  198. 			MADD_ALPHA_N_STORE(C3, res33, alpha);

  199. 			C3 = C3 + 2;

  200. 

  201. 

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

  203. 			temp = bk-off;

  204. #if defined(LEFT)

  205. 			temp = temp - 4;

  206. #else

  207. 			temp = temp - 4;

  208. #endif

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

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

  211. #endif

  212. #ifdef LEFT

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

  214. #endif

  215. 

  216. 

  217. 		}

  218. 

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

  220. 		{

  221. 

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

  223. 			ptrbb = bb;

  224. #else

  225. 			ptrba += off*2*2;

  226. 			ptrbb = bb + off*4*2;

  227. #endif

  228. 

  229. 

  230. 			res00_r = 0;

  231. 			res00_i = 0;

  232. 			res01_r = 0;

  233. 			res01_i = 0;

  234. 

  235. 			res10_r = 0;

  236. 			res10_i = 0;

  237. 			res11_r = 0;

  238. 			res11_i = 0;

  239. 

  240. 			res20_r = 0;

  241. 			res20_i = 0;

  242. 			res21_r = 0;

  243. 			res21_i = 0;

  244. 

  245. 			res30_r = 0;

  246. 			res30_i = 0;

  247. 			res31_r = 0;

  248. 			res31_i = 0;

  249. 

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

  251. 			temp = bk-off;

  252. #elif defined(LEFT)

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

  254. #else

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

  256. #endif

  257. 

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

  259. 			{

  260. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  261. 				b1_r = ptrbb[2*1+0]; b1_i = ptrbb[2*1+1];

  262. 				b2_r = ptrbb[2*2+0]; b2_i = ptrbb[2*2+1];

  263. 				b3_r = ptrbb[2*3+0]; b3_i = ptrbb[2*3+1];

  264. 

  265. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  266. 				MADD(res00, a0, b0);

  267. 				MADD(res10, a0, b1);

  268. 				MADD(res20, a0, b2);

  269. 				MADD(res30, a0, b3);

  270. 

  271. 				a1_r = ptrba[2*1+0]; a1_i = ptrba[2*1+1];

  272. 				MADD(res01, a1, b0);

  273. 				MADD(res11, a1, b1);

  274. 				MADD(res21, a1, b2);

  275. 				MADD(res31, a1, b3);

  276. 

  277. 

  278. 				ptrba = ptrba+4;

  279. 				ptrbb = ptrbb+8;

  280. 			}

  281. 

  282. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  283. 			C0 = C0 + 2;

  284. 			MADD_ALPHA_N_STORE(C0, res01, alpha);

  285. 			C0 = C0 + 2;

  286. 

  287. 			MADD_ALPHA_N_STORE(C1, res10, alpha);

  288. 			C1 = C1 + 2;

  289. 			MADD_ALPHA_N_STORE(C1, res11, alpha);

  290. 			C1 = C1 + 2;

  291. 

  292. 			MADD_ALPHA_N_STORE(C2, res20, alpha);

  293. 			C2 = C2 + 2;

  294. 			MADD_ALPHA_N_STORE(C2, res21, alpha);

  295. 			C2 = C2 + 2;

  296. 

  297. 			MADD_ALPHA_N_STORE(C3, res30, alpha);

  298. 			C3 = C3 + 2;

  299. 			MADD_ALPHA_N_STORE(C3, res31, alpha);

  300. 			C3 = C3 + 2;

  301. 

  302. 

  303. 

  304. 

  305. 

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

  307. 			temp = bk - off;

  308. #ifdef LEFT

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

  310. #else

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

  312. #endif

  313. 			ptrba += temp*2*2;

  314. 			ptrbb += temp*4*2;

  315. #endif

  316. 

  317. #ifdef LEFT

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

  319. #endif

  320. 

  321. 

  322. 		}

  323. 

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

  325. 		{

  326. 

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

  328. 			ptrbb = bb;

  329. #else

  330. 			ptrba += off*1*2;

  331. 			ptrbb = bb + off*4*2;

  332. #endif

  333. 

  334. 			res00_r = 0;

  335. 			res00_i = 0;

  336. 			res10_r = 0;

  337. 			res10_i = 0;

  338. 			res20_r = 0;

  339. 			res20_i = 0;

  340. 			res30_r = 0;

  341. 			res30_i = 0;

  342. 

  343. 

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

  345. 			temp = bk-off;

  346. #elif defined(LEFT)

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

  348. #else

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

  350. #endif

  351. 

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

  353. 			{

  354. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  355. 				b1_r = ptrbb[2*1+0]; b1_i = ptrbb[2*1+1];

  356. 				b2_r = ptrbb[2*2+0]; b2_i = ptrbb[2*2+1];

  357. 				b3_r = ptrbb[2*3+0]; b3_i = ptrbb[2*3+1];

  358. 

  359. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  360. 				MADD(res00, a0, b0);

  361. 				MADD(res10, a0, b1);

  362. 				MADD(res20, a0, b2);

  363. 				MADD(res30, a0, b3);

  364. 

  365. 

  366. 				ptrba = ptrba+2;

  367. 				ptrbb = ptrbb+8;

  368. 			}

  369. 

  370. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  371. 			C0 = C0 + 2;

  372. 

  373. 			MADD_ALPHA_N_STORE(C1, res10, alpha);

  374. 			C1 = C1 + 2;

  375. 

  376. 			MADD_ALPHA_N_STORE(C2, res20, alpha);

  377. 			C2 = C2 + 2;

  378. 

  379. 			MADD_ALPHA_N_STORE(C3, res30, alpha);

  380. 			C3 = C3 + 2;

  381. 

  382. 

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

  384. 			temp = bk - off;

  385. #ifdef LEFT

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

  387. #else

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

  389. #endif

  390. 			ptrba += temp*1*2;

  391. 			ptrbb += temp*4*2;

  392. #endif

  393. 

  394. #ifdef LEFT

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

  396. #endif

  397. 

  398. 

  399. 		}

  400. 

  401. 

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

  403. 		off += 4;

  404. #endif

  405. 

  406. 		k = (bk<<3);

  407. 		bb = bb+k;

  408. 		i = (ldc<<3);

  409. 		C = C+i;

  410. 	}

  411. 

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

  413. 	{

  414. 		C0 = C;

  415. 		C1 = C0+ldc*2;

  416. 

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

  418. 		off = offset;

  419. #endif

  420. 

  421. 

  422. 		ptrba = ba;

  423. 

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

  425. 		{

  426. 

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

  428. 			ptrbb = bb;

  429. #else

  430. 			ptrba += off*4*2;

  431. 			ptrbb = bb + off*2*2;

  432. #endif

  433. 

  434. 			res00_r = 0;

  435. 			res00_i = 0;

  436. 			res01_r = 0;

  437. 			res01_i = 0;

  438. 			res02_r = 0;

  439. 			res02_i = 0;

  440. 			res03_r = 0;

  441. 			res03_i = 0;

  442. 

  443. 			res10_r = 0;

  444. 			res10_i = 0;

  445. 			res11_r = 0;

  446. 			res11_i = 0;

  447. 			res12_r = 0;

  448. 			res12_i = 0;

  449. 			res13_r = 0;

  450. 			res13_i = 0;

  451. 

  452. 

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

  454. 			temp = bk-off;

  455. #elif defined(LEFT)

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

  457. #else

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

  459. #endif

  460. 

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

  462. 			{

  463. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  464. 				b1_r = ptrbb[2*1+0]; b1_i = ptrbb[2*1+1];

  465. 

  466. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  467. 				MADD(res00, a0, b0);

  468. 				MADD(res10, a0, b1);

  469. 

  470. 				a1_r = ptrba[2*1+0]; a1_i = ptrba[2*1+1];

  471. 				MADD(res01, a1, b0);

  472. 				MADD(res11, a1, b1);

  473. 

  474. 				a0_r = ptrba[2*2+0]; a0_i = ptrba[2*2+1];

  475. 				MADD(res02, a0, b0);

  476. 				MADD(res12, a0, b1);

  477. 

  478. 				a1_r = ptrba[2*3+0]; a1_i = ptrba[2*3+1];

  479. 				MADD(res03, a1, b0);

  480. 				MADD(res13, a1, b1);

  481. 

  482. 				ptrba = ptrba+8;

  483. 				ptrbb = ptrbb+4;

  484. 			}

  485. 

  486. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  487. 			C0 = C0 + 2;

  488. 			MADD_ALPHA_N_STORE(C0, res01, alpha);

  489. 			C0 = C0 + 2;

  490. 			MADD_ALPHA_N_STORE(C0, res02, alpha);

  491. 			C0 = C0 + 2;

  492. 			MADD_ALPHA_N_STORE(C0, res03, alpha);

  493. 			C0 = C0 + 2;

  494. 

  495. 			MADD_ALPHA_N_STORE(C1, res10, alpha);

  496. 			C1 = C1 + 2;

  497. 			MADD_ALPHA_N_STORE(C1, res11, alpha);

  498. 			C1 = C1 + 2;

  499. 			MADD_ALPHA_N_STORE(C1, res12, alpha);

  500. 			C1 = C1 + 2;

  501. 			MADD_ALPHA_N_STORE(C1, res13, alpha);

  502. 			C1 = C1 + 2;

  503. 

  504. 

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

  506. 			temp = bk - off;

  507. #ifdef LEFT

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

  509. #else

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

  511. #endif

  512. 			ptrba += temp*4*2;

  513. 			ptrbb += temp*2*2;

  514. #endif

  515. 

  516. #ifdef LEFT

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

  518. #endif

  519. 

  520. 		}

  521. 

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

  523. 		{

  524. 

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

  526. 			ptrbb = bb;

  527. #else

  528. 			ptrba += off*2*2;

  529. 			ptrbb = bb + off*2*2;

  530. #endif

  531. 

  532. 			res00_r = 0;

  533. 			res00_i = 0;

  534. 			res01_r = 0;

  535. 			res01_i = 0;

  536. 

  537. 			res10_r = 0;

  538. 			res10_i = 0;

  539. 			res11_r = 0;

  540. 			res11_i = 0;

  541. 

  542. 

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

  544. 			temp = bk-off;

  545. #elif defined(LEFT)

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

  547. #else

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

  549. #endif

  550. 

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

  552. 			{

  553. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  554. 				b1_r = ptrbb[2*1+0]; b1_i = ptrbb[2*1+1];

  555. 

  556. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  557. 				MADD(res00, a0, b0);

  558. 				MADD(res10, a0, b1);

  559. 

  560. 				a1_r = ptrba[2*1+0]; a1_i = ptrba[2*1+1];

  561. 				MADD(res01, a1, b0);

  562. 				MADD(res11, a1, b1);

  563. 

  564. 

  565. 				ptrba = ptrba+4;

  566. 				ptrbb = ptrbb+4;

  567. 			}

  568. 

  569. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  570. 			C0 = C0 + 2;

  571. 			MADD_ALPHA_N_STORE(C0, res01, alpha);

  572. 			C0 = C0 + 2;

  573. 

  574. 			MADD_ALPHA_N_STORE(C1, res10, alpha);

  575. 			C1 = C1 + 2;

  576. 			MADD_ALPHA_N_STORE(C1, res11, alpha);

  577. 			C1 = C1 + 2;

  578. 

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

  580. 			temp = bk - off;

  581. #ifdef LEFT

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

  583. #else

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

  585. #endif

  586. 			ptrba += temp*2*2;

  587. 			ptrbb += temp*2*2;

  588. #endif

  589. 

  590. #ifdef LEFT

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

  592. #endif

  593. 

  594. 		}

  595. 

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

  597. 		{

  598. 

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

  600. 			ptrbb = bb;

  601. #else

  602. 			ptrba += off*1*2;

  603. 			ptrbb = bb + off*2*2;

  604. #endif

  605. 

  606. 			res00_r = 0;

  607. 			res00_i = 0;

  608. 

  609. 			res10_r = 0;

  610. 			res10_i = 0;

  611. 

  612. 

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

  614. 			temp = bk-off;

  615. #elif defined(LEFT)

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

  617. #else

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

  619. #endif

  620. 

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

  622. 			{

  623. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  624. 				b1_r = ptrbb[2*1+0]; b1_i = ptrbb[2*1+1];

  625. 

  626. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  627. 				MADD(res00, a0, b0);

  628. 				MADD(res10, a0, b1);

  629. 

  630. 				ptrba = ptrba+2;

  631. 				ptrbb = ptrbb+4;

  632. 			}

  633. 

  634. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  635. 			C0 = C0 + 2;

  636. 

  637. 			MADD_ALPHA_N_STORE(C1, res10, alpha);

  638. 			C1 = C1 + 2;

  639. 

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

  641. 			temp = bk - off;

  642. #ifdef LEFT

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

  644. #else

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

  646. #endif

  647. 			ptrba += temp*1*2;

  648. 			ptrbb += temp*2*2;

  649. #endif

  650. 

  651. #ifdef LEFT

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

  653. #endif

  654. 

  655. 		}

  656. 

  657. 

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

  659. 		off += 2;

  660. #endif

  661. 

  662. 		k = (bk<<2);

  663. 		bb = bb+k;

  664. 		i = (ldc<<2);

  665. 		C = C+i;

  666. 	}

  667. 

  668. 

  669. 

  670. 

  671. 

  672. 

  673. 

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

  675. 	{

  676. 		C0 = C;

  677. 

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

  679. 		off = offset;

  680. #endif

  681. 

  682. 		ptrba = ba;

  683. 

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

  685. 		{

  686. 

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

  688. 			ptrbb = bb;

  689. #else

  690. 			ptrba += off*4*2;

  691. 			ptrbb = bb + off*1*2;

  692. #endif

  693. 

  694. 			res00_r = 0;

  695. 			res00_i = 0;

  696. 			res01_r = 0;

  697. 			res01_i = 0;

  698. 			res02_r = 0;

  699. 			res02_i = 0;

  700. 			res03_r = 0;

  701. 			res03_i = 0;

  702. 

  703. 

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

  705. 			temp = bk-off;

  706. #elif defined(LEFT)

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

  708. #else

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

  710. #endif

  711. 

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

  713. 			{

  714. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  715. 

  716. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  717. 				MADD(res00, a0, b0);

  718. 

  719. 				a1_r = ptrba[2*1+0]; a1_i = ptrba[2*1+1];

  720. 				MADD(res01, a1, b0);

  721. 

  722. 				a0_r = ptrba[2*2+0]; a0_i = ptrba[2*2+1];

  723. 				MADD(res02, a0, b0);

  724. 

  725. 				a1_r = ptrba[2*3+0]; a1_i = ptrba[2*3+1];

  726. 				MADD(res03, a1, b0);

  727. 

  728. 				ptrba = ptrba+8;

  729. 				ptrbb = ptrbb+2;

  730. 			}

  731. 

  732. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  733. 			C0 = C0 + 2;

  734. 			MADD_ALPHA_N_STORE(C0, res01, alpha);

  735. 			C0 = C0 + 2;

  736. 			MADD_ALPHA_N_STORE(C0, res02, alpha);

  737. 			C0 = C0 + 2;

  738. 			MADD_ALPHA_N_STORE(C0, res03, alpha);

  739. 			C0 = C0 + 2;

  740. 

  741. 

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

  743. 			temp = bk - off;

  744. #ifdef LEFT

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

  746. #else

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

  748. #endif

  749. 			ptrba += temp*4*2;

  750. 			ptrbb += temp*1*2;

  751. #endif

  752. 

  753. #ifdef LEFT

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

  755. #endif

  756. 

  757. 		}

  758. 

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

  760. 		{

  761. 

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

  763. 			ptrbb = bb;

  764. #else

  765. 			ptrba += off*2*2;

  766. 			ptrbb = bb + off*1*2;

  767. #endif

  768. 

  769. 			res00_r = 0;

  770. 			res00_i = 0;

  771. 			res01_r = 0;

  772. 			res01_i = 0;

  773. 

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

  775. 			temp = bk-off;

  776. #elif defined(LEFT)

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

  778. #else

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

  780. #endif

  781. 

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

  783. 			{

  784. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  785. 

  786. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  787. 				MADD(res00, a0, b0);

  788. 

  789. 				a1_r = ptrba[2*1+0]; a1_i = ptrba[2*1+1];

  790. 				MADD(res01, a1, b0);

  791. 

  792. 

  793. 				ptrba = ptrba+4;

  794. 				ptrbb = ptrbb+2;

  795. 			}

  796. 

  797. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  798. 			C0 = C0 + 2;

  799. 			MADD_ALPHA_N_STORE(C0, res01, alpha);

  800. 			C0 = C0 + 2;

  801. 

  802. 

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

  804. 			temp = bk - off;

  805. #ifdef LEFT

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

  807. #else

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

  809. #endif

  810. 			ptrba += temp*2*2;

  811. 			ptrbb += temp*1*2;

  812. #endif

  813. 

  814. #ifdef LEFT

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

  816. #endif

  817. 

  818. 		}

  819. 

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

  821. 		{

  822. 

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

  824. 			ptrbb = bb;

  825. #else

  826. 			ptrba += off*1*2;

  827. 			ptrbb = bb + off*1*2;

  828. #endif

  829. 

  830. 			res00_r = 0;

  831. 			res00_i = 0;

  832. 

  833. 

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

  835. 			temp = bk-off;

  836. #elif defined(LEFT)

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

  838. #else

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

  840. #endif

  841. 

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

  843. 			{

  844. 				b0_r = ptrbb[2*0+0]; b0_i = ptrbb[2*0+1];

  845. 

  846. 				a0_r = ptrba[2*0+0]; a0_i = ptrba[2*0+1];

  847. 				MADD(res00, a0, b0);

  848. 

  849. 				ptrba = ptrba+2;

  850. 				ptrbb = ptrbb+2;

  851. 			}

  852. 

  853. 			MADD_ALPHA_N_STORE(C0, res00, alpha);

  854. 			C0 = C0 + 2;

  855. 

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

  857. 			temp = bk - off;

  858. #ifdef LEFT

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

  860. #else

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

  862. #endif

  863. 			ptrba += temp*1*2;

  864. 			ptrbb += temp*1*2;

  865. #endif

  866. 

  867. #ifdef LEFT

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

  869. #endif

  870. 

  871. 		}

  872. 

  873. 

  874. 

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

  876. 		off += 1;

  877. #endif

  878. 

  879. 		k = (bk<<1);

  880. 		bb = bb+k;

  881. 		i = (ldc<<1);

  882. 		C = C+i;

  883. 	}

  884. 	return 0;

  885. }