1 |
.text |
// /**************************************************************************** |
2 |
.align 16 |
// * |
3 |
.global sad16_ia64# |
// * XVID MPEG-4 VIDEO CODEC |
4 |
.proc sad16_ia64# |
// * - ia64 sum of absolute differences - |
5 |
sad16_ia64: |
// * |
6 |
|
// * Copyright(C) 2002 Hannes Jütting <s_juetti@ira.uka.de> |
7 |
_LL=3 |
// * Copyright(C) 2002 Christopher Özbek <s_oezbek@ira.uka.de> |
8 |
_SL=1 |
// * |
9 |
_OL=1 |
// * This program is an implementation of a part of one or more MPEG-4 |
10 |
_PL=1 |
// * Video tools as specified in ISO/IEC 14496-2 standard. Those intending |
11 |
_AL=1 |
// * to use this software module in hardware or software products are |
12 |
|
// * advised that its use may infringe existing patents or copyrights, and |
13 |
alloc r9=ar.pfs,4,44,0,48 |
// * any such use would be at such party's own risk. The original |
14 |
|
// * developer of this software module and his/her company, and subsequent |
15 |
mov r8 = r0 |
// * editors and their companies, will have no liability for use of this |
16 |
|
// * software or modifications or derivatives thereof. |
17 |
mov r20 = ar.lc |
// * |
18 |
mov r21 = pr |
// * This program is free software; you can redistribute it and/or modify |
19 |
|
// * it under the terms of the GNU General Public License as published by |
20 |
dep.z r22 = r32, 3, 3 // erste 3 Bit mit 8 multiplizieren |
// * the Free Software Foundation; either version 2 of the License, or |
21 |
dep.z r23 = r33, 3, 3 // in r22 und r23 -> Schiebeflags |
// * (at your option) any later version. |
22 |
|
// * |
23 |
and r14 = -8, r32 // Parameter in untere Register kopieren |
// * This program is distributed in the hope that it will be useful, |
24 |
and r15 = -8, r33 // Ref Cur mit 11111...1000 and-en |
// * but WITHOUT ANY WARRANTY; without even the implied warranty of |
25 |
mov r16 = r34 |
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
26 |
mov r17 = r35 |
// * GNU General Public License for more details. |
27 |
;; |
// * |
28 |
add r18 = 8, r14 // Adressenvorausberechnen |
// * You should have received a copy of the GNU General Public License |
29 |
add r19 = 8, r15 |
// * along with this program; if not, write to the Free Software |
30 |
|
// * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
31 |
sub r24 = 64, r22 // Schiftanzahl ausrechnen |
// * |
32 |
sub r25 = 64, r23 |
// ****************************************************************************/ |
33 |
|
|
34 |
add r26 = 16, r14 // Adressenvorausberechnen |
// ------------------------------------------------------------------------------ |
35 |
add r27 = 16, r15 |
// * |
36 |
|
// * Optimized Assembler Versions of sad8 and sad16 |
37 |
// Loop-counter initialisieren |
// * |
38 |
mov ar.lc = 15 // Loop 16 mal durchlaufen |
// ------------------------------------------------------------------------------ |
39 |
mov ar.ec = _LL + _SL + _OL + _PL + _AL + _AL // Die Loop am Schluss noch neun mal durchlaufen |
// * |
40 |
|
// * Hannes Jütting and Christopher Özbek |
41 |
// Rotating Predicate Register zuruecksetzen und P16 auf 1 |
// * {s_juetti,s_oezbek}@ira.uka.de |
42 |
mov pr.rot = 1 << 16 |
// * |
43 |
;; |
// * Programmed for the IA64 laboratory held at University Karlsruhe 2002 |
44 |
|
// * http://www.info.uni-karlsruhe.de/~rubino/ia64p/ |
45 |
// Array-Konstrukte initialisieren |
// * |
46 |
.rotr _ald1[_LL+1], _ald2[_LL+1], _ald3[_LL+1], _ald4[_LL+1], _ald5[_LL+1], _ald6[_LL+1], _shru1[_SL+1], _shl1[_SL+1], _shru2[_SL], _shl2[_SL], _shru3[_SL], _shl3[_SL], _shru4[_SL], _shl4[_SL+1], _or1[_OL], _or2[_OL], _or3[_OL], _or4[_OL+1], _psadr1[_PL+1], _psadr2[_PL+1], _addr1[_AL+1] |
// ------------------------------------------------------------------------------ |
47 |
.rotp _aldp[_LL], _shp[_SL], _orp[_OL], _psadrp[_PL], _addrp1[_AL], _addrp2[_AL] |
// * |
48 |
|
// * These are the optimized assembler versions of sad8 and sad16, which calculate |
49 |
.L_loop_16: |
// * the sum of absolute differences between two 8x8/16x16 block matrices. |
50 |
{.mmi |
// * |
51 |
(_aldp[0]) ld8 _ald1[0] = [r14], r16 // Cur Erste 8 Byte |
// * Our approach uses: |
52 |
(_aldp[0]) ld8 _ald2[0] = [r18], r16 // Cur Zweite 8 Byte |
// * - The Itanium command psad1, which solves the problem in hardware. |
53 |
(_psadrp[0]) psad1 _psadr1[0] = _or2[0], _or4[0] // Psadden |
// * - Modulo-Scheduled Loops as the best way to loop unrolling on the IA64 |
54 |
} |
// * EPIC architecture |
55 |
{.mmi |
// * - Alignment resolving to avoid memory faults |
56 |
(_aldp[0]) ld8 _ald3[0] = [r26], r16 // Cur Dritte 8 Byte |
// * |
57 |
(_aldp[0]) ld8 _ald4[0] = [r15], r16 // Ref Erste 8 Byte |
// ------------------------------------------------------------------------------ |
|
(_psadrp[0]) psad1 _psadr2[0] = _or3[0], _or4[_OL] // _or2 +1 |
|
|
} |
|
|
{.mmi |
|
|
(_aldp[0]) ld8 _ald5[0] = [r19], r16 // Ref Zweite 8 Byte |
|
|
(_aldp[0]) ld8 _ald6[0] = [r27], r16 // Ref Dritte 8 Byte |
|
|
(_shp[0]) shr.u _shru1[0] = _ald1[_LL], r22 |
|
|
} |
|
|
{.mii |
|
|
(_orp[0]) or _or1[0] = _shl2[0], _shru3[0] // _shru2 + 1 und _shl2 + 1 |
|
|
(_shp[0]) shl _shl1[0] = _ald2[_LL], r24 |
|
|
(_shp[0]) shr.u _shru2[0] = _ald2[_LL], r22 |
|
|
} |
|
|
{.mii |
|
|
(_orp[0]) or _or2[0] = _shl3[0], _shru4[0] // _shru3 + 1 und _shl3 + 1 |
|
|
(_shp[0]) shl _shl2[0] = _ald3[_LL], r24 |
|
|
(_shp[0]) shr.u _shru3[0] = _ald4[_LL], r23 |
|
|
} |
|
|
{.mii |
|
|
(_orp[0]) or _or3[0] = _shl4[0], _shl4[_SL] //_shru4 + 1 und _shl4 + 1 |
|
|
(_shp[0]) shl _shl3[0] = _ald5[_LL], r25 |
|
|
(_shp[0]) shr.u _shru4[0] = _ald5[_LL], r23 |
|
|
} |
|
|
{.mmi |
|
|
(_orp[0]) or _or4[0] = _shru1[_SL], _shl1[_SL] |
|
|
(_shp[0]) shl _shl4[0]= _ald6[_LL], r25 |
|
|
} |
|
|
{.mmb |
|
|
(_addrp1[0]) add _addr1[0] = _psadr1[_PL], _psadr2[_PL] // Aufsummieren |
|
|
(_addrp2[0]) add r8 = r8, _addr1[_AL] |
|
|
br.ctop.sptk.few .L_loop_16 |
|
|
;; |
|
|
} |
|
|
// Register zurueckschreiben |
|
|
mov ar.lc = r20 |
|
|
mov pr = r21,-1 |
|
|
br.ret.sptk.many rp |
|
|
.endp sad16_ia64# |
|
|
|
|
|
|
|
|
.align 16 |
|
|
.global sad8_ia64# |
|
|
.proc sad8_ia64# |
|
|
|
|
|
sad8_ia64: |
|
|
|
|
|
LL=3 |
|
|
SL=1 |
|
|
OL=1 |
|
|
PL=1 |
|
|
AL=1 |
|
|
|
|
|
alloc r9=ar.pfs,3,29,0,32 |
|
|
mov r20 = ar.lc |
|
|
mov r21 = pr |
|
|
|
|
|
dep.z r22 = r32, 3, 3 // erste 3 Bit mit 8 multiplizieren |
|
|
dep.z r23 = r33, 3, 3 // in r22 und r23 -> Schiebeflags |
|
|
|
|
|
mov r8 = r0 // . . . . |
|
|
and r14 = -8, r32 // 0xFFFFFFFFFFFFFFF8, r32 |
|
|
and r15 = -8, r33 // 0xFFFFFFFFFFFFFFF8, r33 |
|
|
mov r16 = r34 |
|
|
// mov r17 = r35 |
|
|
;; |
|
|
|
|
|
add r18 = 8, r14 |
|
|
add r19 = 8, r15 |
|
|
|
|
|
sub r24 = 64, r22 |
|
|
sub r25 = 64, r23 |
|
|
|
|
|
// Loop-counter initialisieren |
|
|
mov ar.lc = 7 // Loop 7 mal durchlaufen |
|
|
mov ar.ec = LL + SL + OL + PL + AL // Die Loop am Schluss noch zehn mal durchlaufen |
|
|
|
|
|
// Rotating Predicate Register zuruecksetzen und P16 auf 1 |
|
|
mov pr.rot = 1 << 16 |
|
|
;; |
|
|
.rotr ald1[LL+1], ald2[LL+1], ald3[LL+1], ald4[LL+1], shru1[SL+1], shl1[SL+1], shru2[SL+1], shl2[SL+1], or1[OL+1], or2[OL+1], psadr[PL+1], addr[AL+1] |
|
|
.rotp aldp[LL], shp[SL], orp[OL], psadrp[PL], addrp[AL] |
|
|
.L_loop_8: |
|
|
{.mmi |
|
|
(aldp[0]) ld8 ald1[0] = [r14], r16 // Cur laden |
|
|
(aldp[0]) ld8 ald2[0] = [r18], r16 |
|
|
(shp[0]) shr.u shru1[0] = ald1[LL], r22 // mergen |
|
|
} |
|
|
{.mii |
|
|
(orp[0]) or or1[0] = shru1[SL], shl1[SL] |
|
|
(shp[0]) shl shl1[0] = ald2[LL], r24 |
|
|
(shp[0]) shr.u shru2[0] = ald3[LL], r23 // mergen |
|
|
} |
|
|
{.mmi |
|
|
(aldp[0]) ld8 ald3[0] = [r15], r16 // Ref laden |
|
|
(aldp[0]) ld8 ald4[0] = [r19], r16 |
|
|
(shp[0]) shl shl2[0] = ald4[LL], r25 |
|
|
} |
|
|
{.mmi |
|
|
(orp[0]) or or2[0] = shru2[SL], shl2[SL] |
|
|
(addrp[0]) add r8 = r8, psadr[PL] |
|
|
(psadrp[0]) psad1 psadr[0] = or1[OL], or2[OL] |
|
|
} |
|
|
{.mbb |
|
|
br.ctop.sptk.few .L_loop_8 |
|
|
;; |
|
|
} |
|
|
|
|
|
mov ar.lc = r20 |
|
|
mov pr = r21,-1 |
|
|
br.ret.sptk.many b0 |
|
|
.endp sad8_ia64# |
|
|
|
|
58 |
|
|
59 |
.common sad16bi#,8,8 |
.common sad16bi#,8,8 |
60 |
.align 16 |
.align 16 |
383 |
} |
} |
384 |
{.mib |
{.mib |
385 |
add mean0 = mean0, mean1 |
add mean0 = mean0, mean1 |
386 |
// add mean2 = 127, mean2 // this could make our division more exact, but does not help much |
// add mean2 = 127, mean2 // this could make our division more exactly, but does not help much |
387 |
;; |
;; |
388 |
} |
} |
389 |
{.mib |
{.mib |
533 |
br.ret.sptk.many b0 |
br.ret.sptk.many b0 |
534 |
} |
} |
535 |
.endp dev16_ia64# |
.endp dev16_ia64# |
536 |
|
|
537 |
|
|
538 |
|
// ########################################################### |
539 |
|
// ########################################################### |
540 |
|
// Neue version von gruppe 01 ################################ |
541 |
|
// ########################################################### |
542 |
|
// ########################################################### |
543 |
|
|
544 |
|
|
545 |
|
|
546 |
|
.text |
547 |
|
.align 16 |
548 |
|
.global sad16_ia64# |
549 |
|
.proc sad16_ia64# |
550 |
|
sad16_ia64: |
551 |
|
alloc r1 = ar.pfs, 4, 76, 0, 0 |
552 |
|
mov r2 = pr |
553 |
|
dep r14 = r0, r33, 0, 3 // r14 = (r33 div 8)*8 (aligned version of ref) |
554 |
|
dep.z r31 = r33, 0, 3 // r31 = r33 mod 8 (misalignment of ref) |
555 |
|
;; |
556 |
|
mov r64 = r34 //(1) calculate multiples of stride |
557 |
|
shl r65 = r34, 1 //(2) for being able to load all the |
558 |
|
shladd r66 = r34, 1, r34 //(3) data at once |
559 |
|
shl r67 = r34, 2 //(4) |
560 |
|
shladd r68 = r34, 2, r34 //(5) |
561 |
|
shl r71 = r34, 3 //(8) |
562 |
|
shladd r72 = r34, 3, r34 //(9) |
563 |
|
;; |
564 |
|
shl r69 = r66, 1 //(6) |
565 |
|
shladd r70 = r66, 1, r34 //(7) |
566 |
|
shl r73 = r68, 1 //(10) |
567 |
|
shladd r74 = r68, 1, r34 //(11) |
568 |
|
shl r75 = r66, 2 //(12) |
569 |
|
shladd r76 = r66, 2, r34 //(13) |
570 |
|
shladd r77 = r66, 2, r65 //(14) |
571 |
|
shladd r78 = r66, 2, r66 //(15) |
572 |
|
;; |
573 |
|
cmp.eq p16, p17 = 0, r31 // prepare predicates according to the misalignment |
574 |
|
cmp.eq p18, p19 = 2, r31 // ref |
575 |
|
cmp.eq p20, p21 = 4, r31 |
576 |
|
cmp.eq p22, p23 = 6, r31 |
577 |
|
cmp.eq p24, p25 = 1, r31 |
578 |
|
cmp.eq p26, p27 = 3, r31 |
579 |
|
cmp.eq p28, p29 = 5, r31 |
580 |
|
mov r96 = r14 // and calculate all the adresses where we have |
581 |
|
mov r33 = r32 // to load from |
582 |
|
add r97 = r14, r64 |
583 |
|
add r35 = r32, r64 |
584 |
|
add r98 = r14, r65 |
585 |
|
add r37 = r32, r65 |
586 |
|
add r99 = r14, r66 |
587 |
|
add r39 = r32, r66 |
588 |
|
add r100 = r14, r67 |
589 |
|
add r41 = r32, r67 |
590 |
|
add r101 = r14, r68 |
591 |
|
add r43 = r32, r68 |
592 |
|
add r102 = r14, r69 |
593 |
|
add r45 = r32, r69 |
594 |
|
add r103 = r14, r70 |
595 |
|
add r47 = r32, r70 |
596 |
|
add r104 = r14, r71 |
597 |
|
add r49 = r32, r71 |
598 |
|
add r105 = r14, r72 |
599 |
|
add r51 = r32, r72 |
600 |
|
add r106 = r14, r73 |
601 |
|
add r53 = r32, r73 |
602 |
|
add r107 = r14, r74 |
603 |
|
add r55 = r32, r74 |
604 |
|
add r108 = r14, r75 |
605 |
|
add r57 = r32, r75 |
606 |
|
add r109 = r14, r76 |
607 |
|
add r59 = r32, r76 |
608 |
|
add r110 = r14, r77 |
609 |
|
add r61 = r32, r77 |
610 |
|
add r111 = r14, r78 |
611 |
|
add r63 = r32, r78 |
612 |
|
;; |
613 |
|
ld8 r32 = [r33], 8 // Load all the data which is needed for the sad |
614 |
|
ld8 r34 = [r35], 8 // in the registers. the goal is to have the array |
615 |
|
ld8 r36 = [r37], 8 // adressed by cur in the registers r32 - r63 and |
616 |
|
ld8 r38 = [r39], 8 // the aray adressed by ref in the registers |
617 |
|
ld8 r40 = [r41], 8 // r64 - r95. The registers r96 - r111 are needed |
618 |
|
ld8 r42 = [r43], 8 // to load the aligned 24 bits in which the |
619 |
|
ld8 r44 = [r45], 8 // needed misaligned 16 bits must be. |
620 |
|
ld8 r46 = [r47], 8 // After loading we start a preprocessing which |
621 |
|
ld8 r48 = [r49], 8 // guarantees that the data adressed by ref is in |
622 |
|
ld8 r50 = [r51], 8 // the registers r64 - r95. |
623 |
|
ld8 r52 = [r53], 8 |
624 |
|
ld8 r54 = [r55], 8 |
625 |
|
ld8 r56 = [r57], 8 |
626 |
|
ld8 r58 = [r59], 8 |
627 |
|
ld8 r60 = [r61], 8 |
628 |
|
ld8 r62 = [r63], 8 |
629 |
|
ld8 r64 = [r96], 8 |
630 |
|
ld8 r66 = [r97], 8 |
631 |
|
ld8 r68 = [r98], 8 |
632 |
|
ld8 r70 = [r99], 8 |
633 |
|
ld8 r72 = [r100], 8 |
634 |
|
ld8 r74 = [r101], 8 |
635 |
|
ld8 r76 = [r102], 8 |
636 |
|
ld8 r78 = [r103], 8 |
637 |
|
ld8 r80 = [r104], 8 |
638 |
|
ld8 r82 = [r105], 8 |
639 |
|
ld8 r84 = [r106], 8 |
640 |
|
ld8 r86 = [r107], 8 |
641 |
|
ld8 r88 = [r108], 8 |
642 |
|
ld8 r90 = [r109], 8 |
643 |
|
ld8 r92 = [r110], 8 |
644 |
|
ld8 r94 = [r111], 8 |
645 |
|
;; |
646 |
|
ld8 r33 = [r33] |
647 |
|
ld8 r35 = [r35] |
648 |
|
ld8 r37 = [r37] |
649 |
|
ld8 r39 = [r39] |
650 |
|
ld8 r41 = [r41] |
651 |
|
ld8 r43 = [r43] |
652 |
|
ld8 r45 = [r45] |
653 |
|
ld8 r47 = [r47] |
654 |
|
ld8 r49 = [r49] |
655 |
|
ld8 r51 = [r51] |
656 |
|
ld8 r53 = [r53] |
657 |
|
ld8 r55 = [r55] |
658 |
|
ld8 r57 = [r57] |
659 |
|
ld8 r59 = [r59] |
660 |
|
ld8 r61 = [r61] |
661 |
|
ld8 r63 = [r63] |
662 |
|
ld8 r65 = [r96], 8 |
663 |
|
ld8 r67 = [r97], 8 |
664 |
|
ld8 r69 = [r98], 8 |
665 |
|
ld8 r71 = [r99], 8 |
666 |
|
ld8 r73 = [r100], 8 |
667 |
|
ld8 r75 = [r101], 8 |
668 |
|
ld8 r77 = [r102], 8 |
669 |
|
ld8 r79 = [r103], 8 |
670 |
|
ld8 r81 = [r104], 8 |
671 |
|
ld8 r83 = [r105], 8 |
672 |
|
ld8 r85 = [r106], 8 |
673 |
|
ld8 r87 = [r107], 8 |
674 |
|
ld8 r89 = [r108], 8 |
675 |
|
ld8 r91 = [r109], 8 |
676 |
|
ld8 r93 = [r110], 8 |
677 |
|
ld8 r95 = [r111], 8 |
678 |
|
(p16) br.cond.dptk.many .Lber // If ref is aligned, everything is loaded and we can start the calculation |
679 |
|
;; |
680 |
|
ld8 r96 = [r96] // If not, we have to load a bit more |
681 |
|
ld8 r97 = [r97] |
682 |
|
ld8 r98 = [r98] |
683 |
|
ld8 r99 = [r99] |
684 |
|
ld8 r100 = [r100] |
685 |
|
ld8 r101 = [r101] |
686 |
|
ld8 r102 = [r102] |
687 |
|
ld8 r103 = [r103] |
688 |
|
ld8 r104 = [r104] |
689 |
|
ld8 r105 = [r105] |
690 |
|
ld8 r106 = [r106] |
691 |
|
ld8 r107 = [r107] |
692 |
|
ld8 r108 = [r108] |
693 |
|
ld8 r109 = [r109] |
694 |
|
ld8 r110 = [r110] |
695 |
|
ld8 r111 = [r111] |
696 |
|
(p24) br.cond.dptk.many .Lmod1 // according to the misalignment, we have |
697 |
|
(p18) br.cond.dpnt.many .Lmod2 // to jump to different preprocessing routines |
698 |
|
(p26) br.cond.dpnt.many .Lmod3 |
699 |
|
(p20) br.cond.dpnt.many .Lmod4 |
700 |
|
(p28) br.cond.dpnt.many .Lmod5 |
701 |
|
(p22) br.cond.dpnt.many .Lmod6 |
702 |
|
;; |
703 |
|
.Lmod7: // this jump point is not needed |
704 |
|
shrp r64 = r65, r64, 56 // in these blocks, we do the preprocessing |
705 |
|
shrp r65 = r96, r65, 56 |
706 |
|
shrp r66 = r67, r66, 56 |
707 |
|
shrp r67 = r97, r67, 56 |
708 |
|
shrp r68 = r69, r68, 56 |
709 |
|
shrp r69 = r98, r69, 56 |
710 |
|
shrp r70 = r71, r70, 56 |
711 |
|
shrp r71 = r99, r71, 56 |
712 |
|
shrp r72 = r73, r72, 56 |
713 |
|
shrp r73 = r100, r73, 56 |
714 |
|
shrp r74 = r75, r74, 56 |
715 |
|
shrp r75 = r101, r75, 56 |
716 |
|
shrp r76 = r77, r76, 56 |
717 |
|
shrp r77 = r102, r77, 56 |
718 |
|
shrp r78 = r79, r78, 56 |
719 |
|
shrp r79 = r103, r79, 56 |
720 |
|
shrp r80 = r81, r80, 56 |
721 |
|
shrp r81 = r104, r81, 56 |
722 |
|
shrp r82 = r83, r82, 56 |
723 |
|
shrp r83 = r105, r83, 56 |
724 |
|
shrp r84 = r85, r84, 56 |
725 |
|
shrp r85 = r106, r85, 56 |
726 |
|
shrp r86 = r87, r86, 56 |
727 |
|
shrp r87 = r107, r87, 56 |
728 |
|
shrp r88 = r89, r88, 56 |
729 |
|
shrp r89 = r108, r89, 56 |
730 |
|
shrp r90 = r91, r90, 56 |
731 |
|
shrp r91 = r109, r91, 56 |
732 |
|
shrp r92 = r93, r92, 56 |
733 |
|
shrp r93 = r110, r93, 56 |
734 |
|
shrp r94 = r95, r94, 56 |
735 |
|
shrp r95 = r111, r95, 56 |
736 |
|
br.cond.sptk.many .Lber // and then we jump to the calculation |
737 |
|
;; |
738 |
|
.Lmod6: |
739 |
|
shrp r64 = r65, r64, 48 |
740 |
|
shrp r65 = r96, r65, 48 |
741 |
|
shrp r66 = r67, r66, 48 |
742 |
|
shrp r67 = r97, r67, 48 |
743 |
|
shrp r68 = r69, r68, 48 |
744 |
|
shrp r69 = r98, r69, 48 |
745 |
|
shrp r70 = r71, r70, 48 |
746 |
|
shrp r71 = r99, r71, 48 |
747 |
|
shrp r72 = r73, r72, 48 |
748 |
|
shrp r73 = r100, r73, 48 |
749 |
|
shrp r74 = r75, r74, 48 |
750 |
|
shrp r75 = r101, r75, 48 |
751 |
|
shrp r76 = r77, r76, 48 |
752 |
|
shrp r77 = r102, r77, 48 |
753 |
|
shrp r78 = r79, r78, 48 |
754 |
|
shrp r79 = r103, r79, 48 |
755 |
|
shrp r80 = r81, r80, 48 |
756 |
|
shrp r81 = r104, r81, 48 |
757 |
|
shrp r82 = r83, r82, 48 |
758 |
|
shrp r83 = r105, r83, 48 |
759 |
|
shrp r84 = r85, r84, 48 |
760 |
|
shrp r85 = r106, r85, 48 |
761 |
|
shrp r86 = r87, r86, 48 |
762 |
|
shrp r87 = r107, r87, 48 |
763 |
|
shrp r88 = r89, r88, 48 |
764 |
|
shrp r89 = r108, r89, 48 |
765 |
|
shrp r90 = r91, r90, 48 |
766 |
|
shrp r91 = r109, r91, 48 |
767 |
|
shrp r92 = r93, r92, 48 |
768 |
|
shrp r93 = r110, r93, 48 |
769 |
|
shrp r94 = r95, r94, 48 |
770 |
|
shrp r95 = r111, r95, 48 |
771 |
|
br.cond.sptk.many .Lber |
772 |
|
;; |
773 |
|
.Lmod5: |
774 |
|
shrp r64 = r65, r64, 40 |
775 |
|
shrp r65 = r96, r65, 40 |
776 |
|
shrp r66 = r67, r66, 40 |
777 |
|
shrp r67 = r97, r67, 40 |
778 |
|
shrp r68 = r69, r68, 40 |
779 |
|
shrp r69 = r98, r69, 40 |
780 |
|
shrp r70 = r71, r70, 40 |
781 |
|
shrp r71 = r99, r71, 40 |
782 |
|
shrp r72 = r73, r72, 40 |
783 |
|
shrp r73 = r100, r73, 40 |
784 |
|
shrp r74 = r75, r74, 40 |
785 |
|
shrp r75 = r101, r75, 40 |
786 |
|
shrp r76 = r77, r76, 40 |
787 |
|
shrp r77 = r102, r77, 40 |
788 |
|
shrp r78 = r79, r78, 40 |
789 |
|
shrp r79 = r103, r79, 40 |
790 |
|
shrp r80 = r81, r80, 40 |
791 |
|
shrp r81 = r104, r81, 40 |
792 |
|
shrp r82 = r83, r82, 40 |
793 |
|
shrp r83 = r105, r83, 40 |
794 |
|
shrp r84 = r85, r84, 40 |
795 |
|
shrp r85 = r106, r85, 40 |
796 |
|
shrp r86 = r87, r86, 40 |
797 |
|
shrp r87 = r107, r87, 40 |
798 |
|
shrp r88 = r89, r88, 40 |
799 |
|
shrp r89 = r108, r89, 40 |
800 |
|
shrp r90 = r91, r90, 40 |
801 |
|
shrp r91 = r109, r91, 40 |
802 |
|
shrp r92 = r93, r92, 40 |
803 |
|
shrp r93 = r110, r93, 40 |
804 |
|
shrp r94 = r95, r94, 40 |
805 |
|
shrp r95 = r111, r95, 40 |
806 |
|
br.cond.sptk.many .Lber |
807 |
|
;; |
808 |
|
.Lmod4: |
809 |
|
shrp r64 = r65, r64, 32 |
810 |
|
shrp r65 = r96, r65, 32 |
811 |
|
shrp r66 = r67, r66, 32 |
812 |
|
shrp r67 = r97, r67, 32 |
813 |
|
shrp r68 = r69, r68, 32 |
814 |
|
shrp r69 = r98, r69, 32 |
815 |
|
shrp r70 = r71, r70, 32 |
816 |
|
shrp r71 = r99, r71, 32 |
817 |
|
shrp r72 = r73, r72, 32 |
818 |
|
shrp r73 = r100, r73, 32 |
819 |
|
shrp r74 = r75, r74, 32 |
820 |
|
shrp r75 = r101, r75, 32 |
821 |
|
shrp r76 = r77, r76, 32 |
822 |
|
shrp r77 = r102, r77, 32 |
823 |
|
shrp r78 = r79, r78, 32 |
824 |
|
shrp r79 = r103, r79, 32 |
825 |
|
shrp r80 = r81, r80, 32 |
826 |
|
shrp r81 = r104, r81, 32 |
827 |
|
shrp r82 = r83, r82, 32 |
828 |
|
shrp r83 = r105, r83, 32 |
829 |
|
shrp r84 = r85, r84, 32 |
830 |
|
shrp r85 = r106, r85, 32 |
831 |
|
shrp r86 = r87, r86, 32 |
832 |
|
shrp r87 = r107, r87, 32 |
833 |
|
shrp r88 = r89, r88, 32 |
834 |
|
shrp r89 = r108, r89, 32 |
835 |
|
shrp r90 = r91, r90, 32 |
836 |
|
shrp r91 = r109, r91, 32 |
837 |
|
shrp r92 = r93, r92, 32 |
838 |
|
shrp r93 = r110, r93, 32 |
839 |
|
shrp r94 = r95, r94, 32 |
840 |
|
shrp r95 = r111, r95, 32 |
841 |
|
br.cond.sptk.many .Lber |
842 |
|
;; |
843 |
|
.Lmod3: |
844 |
|
shrp r64 = r65, r64, 24 |
845 |
|
shrp r65 = r96, r65, 24 |
846 |
|
shrp r66 = r67, r66, 24 |
847 |
|
shrp r67 = r97, r67, 24 |
848 |
|
shrp r68 = r69, r68, 24 |
849 |
|
shrp r69 = r98, r69, 24 |
850 |
|
shrp r70 = r71, r70, 24 |
851 |
|
shrp r71 = r99, r71, 24 |
852 |
|
shrp r72 = r73, r72, 24 |
853 |
|
shrp r73 = r100, r73, 24 |
854 |
|
shrp r74 = r75, r74, 24 |
855 |
|
shrp r75 = r101, r75, 24 |
856 |
|
shrp r76 = r77, r76, 24 |
857 |
|
shrp r77 = r102, r77, 24 |
858 |
|
shrp r78 = r79, r78, 24 |
859 |
|
shrp r79 = r103, r79, 24 |
860 |
|
shrp r80 = r81, r80, 24 |
861 |
|
shrp r81 = r104, r81, 24 |
862 |
|
shrp r82 = r83, r82, 24 |
863 |
|
shrp r83 = r105, r83, 24 |
864 |
|
shrp r84 = r85, r84, 24 |
865 |
|
shrp r85 = r106, r85, 24 |
866 |
|
shrp r86 = r87, r86, 24 |
867 |
|
shrp r87 = r107, r87, 24 |
868 |
|
shrp r88 = r89, r88, 24 |
869 |
|
shrp r89 = r108, r89, 24 |
870 |
|
shrp r90 = r91, r90, 24 |
871 |
|
shrp r91 = r109, r91, 24 |
872 |
|
shrp r92 = r93, r92, 24 |
873 |
|
shrp r93 = r110, r93, 24 |
874 |
|
shrp r94 = r95, r94, 24 |
875 |
|
shrp r95 = r111, r95, 24 |
876 |
|
br.cond.sptk.many .Lber |
877 |
|
;; |
878 |
|
.Lmod2: |
879 |
|
shrp r64 = r65, r64, 16 |
880 |
|
shrp r65 = r96, r65, 16 |
881 |
|
shrp r66 = r67, r66, 16 |
882 |
|
shrp r67 = r97, r67, 16 |
883 |
|
shrp r68 = r69, r68, 16 |
884 |
|
shrp r69 = r98, r69, 16 |
885 |
|
shrp r70 = r71, r70, 16 |
886 |
|
shrp r71 = r99, r71, 16 |
887 |
|
shrp r72 = r73, r72, 16 |
888 |
|
shrp r73 = r100, r73, 16 |
889 |
|
shrp r74 = r75, r74, 16 |
890 |
|
shrp r75 = r101, r75, 16 |
891 |
|
shrp r76 = r77, r76, 16 |
892 |
|
shrp r77 = r102, r77, 16 |
893 |
|
shrp r78 = r79, r78, 16 |
894 |
|
shrp r79 = r103, r79, 16 |
895 |
|
shrp r80 = r81, r80, 16 |
896 |
|
shrp r81 = r104, r81, 16 |
897 |
|
shrp r82 = r83, r82, 16 |
898 |
|
shrp r83 = r105, r83, 16 |
899 |
|
shrp r84 = r85, r84, 16 |
900 |
|
shrp r85 = r106, r85, 16 |
901 |
|
shrp r86 = r87, r86, 16 |
902 |
|
shrp r87 = r107, r87, 16 |
903 |
|
shrp r88 = r89, r88, 16 |
904 |
|
shrp r89 = r108, r89, 16 |
905 |
|
shrp r90 = r91, r90, 16 |
906 |
|
shrp r91 = r109, r91, 16 |
907 |
|
shrp r92 = r93, r92, 16 |
908 |
|
shrp r93 = r110, r93, 16 |
909 |
|
shrp r94 = r95, r94, 16 |
910 |
|
shrp r95 = r111, r95, 16 |
911 |
|
br.cond.sptk.many .Lber |
912 |
|
;; |
913 |
|
.Lmod1: |
914 |
|
shrp r64 = r65, r64, 8 |
915 |
|
shrp r65 = r96, r65, 8 |
916 |
|
shrp r66 = r67, r66, 8 |
917 |
|
shrp r67 = r97, r67, 8 |
918 |
|
shrp r68 = r69, r68, 8 |
919 |
|
shrp r69 = r98, r69, 8 |
920 |
|
shrp r70 = r71, r70, 8 |
921 |
|
shrp r71 = r99, r71, 8 |
922 |
|
shrp r72 = r73, r72, 8 |
923 |
|
shrp r73 = r100, r73, 8 |
924 |
|
shrp r74 = r75, r74, 8 |
925 |
|
shrp r75 = r101, r75, 8 |
926 |
|
shrp r76 = r77, r76, 8 |
927 |
|
shrp r77 = r102, r77, 8 |
928 |
|
shrp r78 = r79, r78, 8 |
929 |
|
shrp r79 = r103, r79, 8 |
930 |
|
shrp r80 = r81, r80, 8 |
931 |
|
shrp r81 = r104, r81, 8 |
932 |
|
shrp r82 = r83, r82, 8 |
933 |
|
shrp r83 = r105, r83, 8 |
934 |
|
shrp r84 = r85, r84, 8 |
935 |
|
shrp r85 = r106, r85, 8 |
936 |
|
shrp r86 = r87, r86, 8 |
937 |
|
shrp r87 = r107, r87, 8 |
938 |
|
shrp r88 = r89, r88, 8 |
939 |
|
shrp r89 = r108, r89, 8 |
940 |
|
shrp r90 = r91, r90, 8 |
941 |
|
shrp r91 = r109, r91, 8 |
942 |
|
shrp r92 = r93, r92, 8 |
943 |
|
shrp r93 = r110, r93, 8 |
944 |
|
shrp r94 = r95, r94, 8 |
945 |
|
shrp r95 = r111, r95, 8 |
946 |
|
.Lber: |
947 |
|
;; |
948 |
|
psad1 r32 = r32, r64 // Here we do the calculation. |
949 |
|
psad1 r33 = r33, r65 // The machine is providing a fast method |
950 |
|
psad1 r34 = r34, r66 // for calculating sad, so we use it |
951 |
|
psad1 r35 = r35, r67 |
952 |
|
psad1 r36 = r36, r68 |
953 |
|
psad1 r37 = r37, r69 |
954 |
|
psad1 r38 = r38, r70 |
955 |
|
psad1 r39 = r39, r71 |
956 |
|
psad1 r40 = r40, r72 |
957 |
|
psad1 r41 = r41, r73 |
958 |
|
psad1 r42 = r42, r74 |
959 |
|
psad1 r43 = r43, r75 |
960 |
|
psad1 r44 = r44, r76 |
961 |
|
psad1 r45 = r45, r77 |
962 |
|
psad1 r46 = r46, r78 |
963 |
|
psad1 r47 = r47, r79 |
964 |
|
psad1 r48 = r48, r80 |
965 |
|
psad1 r49 = r49, r81 |
966 |
|
psad1 r50 = r50, r82 |
967 |
|
psad1 r51 = r51, r83 |
968 |
|
psad1 r52 = r52, r84 |
969 |
|
psad1 r53 = r53, r85 |
970 |
|
psad1 r54 = r54, r86 |
971 |
|
psad1 r55 = r55, r87 |
972 |
|
psad1 r56 = r56, r88 |
973 |
|
psad1 r57 = r57, r89 |
974 |
|
psad1 r58 = r58, r90 |
975 |
|
psad1 r59 = r59, r91 |
976 |
|
psad1 r60 = r60, r92 |
977 |
|
psad1 r61 = r61, r93 |
978 |
|
psad1 r62 = r62, r94 |
979 |
|
psad1 r63 = r63, r95 |
980 |
|
;; |
981 |
|
add r32 = r32, r63 // at last, we have to sum up |
982 |
|
add r33 = r33, r62 // in 5 stages |
983 |
|
add r34 = r34, r61 |
984 |
|
add r35 = r35, r60 |
985 |
|
add r36 = r36, r59 |
986 |
|
add r37 = r37, r58 |
987 |
|
add r38 = r38, r57 |
988 |
|
add r39 = r39, r56 |
989 |
|
add r40 = r40, r55 |
990 |
|
add r41 = r41, r54 |
991 |
|
add r42 = r42, r53 |
992 |
|
add r43 = r43, r52 |
993 |
|
add r44 = r44, r51 |
994 |
|
add r45 = r45, r50 |
995 |
|
add r46 = r46, r49 |
996 |
|
add r47 = r47, r48 |
997 |
|
;; |
998 |
|
add r32 = r32, r47 |
999 |
|
add r33 = r33, r46 |
1000 |
|
add r34 = r34, r45 |
1001 |
|
add r35 = r35, r44 |
1002 |
|
add r36 = r36, r43 |
1003 |
|
add r37 = r37, r42 |
1004 |
|
add r38 = r38, r41 |
1005 |
|
add r39 = r39, r40 |
1006 |
|
;; |
1007 |
|
add r32 = r32, r39 |
1008 |
|
add r33 = r33, r38 |
1009 |
|
add r34 = r34, r37 |
1010 |
|
add r35 = r35, r36 |
1011 |
|
;; |
1012 |
|
add r32 = r32, r35 |
1013 |
|
add r33 = r33, r34 |
1014 |
|
;; |
1015 |
|
add r8 = r32, r33 // and store the result in r8 |
1016 |
|
mov pr = r2, -1 |
1017 |
|
mov ar.pfs = r1 |
1018 |
|
br.ret.sptk.many b0 |
1019 |
|
.endp sad16_ia64# |
1020 |
|
|
1021 |
|
|
1022 |
|
|
1023 |
|
|
1024 |
|
.align 16 |
1025 |
|
.global sad8_ia64# |
1026 |
|
.proc sad8_ia64# |
1027 |
|
sad8_ia64: |
1028 |
|
alloc r1 = ar.pfs, 3, 21, 0, 0 |
1029 |
|
mov r2 = pr |
1030 |
|
dep r14 = r0, r33, 0, 3 // calculate aligned version of ref |
1031 |
|
dep.z r31 = r33, 0, 3 // calculate misalignment of ref |
1032 |
|
;; |
1033 |
|
mov r40 = r34 //(1) calculate multiples of stride |
1034 |
|
shl r41 = r34, 1 //(2) |
1035 |
|
shladd r42 = r34, 1, r34 //(3) |
1036 |
|
shl r43 = r34, 2 //(4) |
1037 |
|
shladd r44 = r34, 2, r34 //(5) |
1038 |
|
;; |
1039 |
|
cmp.eq p16, p17 = 0, r31 // set predicates according to the misalignment of ref |
1040 |
|
cmp.eq p18, p19 = 2, r31 |
1041 |
|
shl r45 = r42, 1 //(6) |
1042 |
|
cmp.eq p20, p21 = 4, r31 |
1043 |
|
cmp.eq p22, p23 = 6, r31 |
1044 |
|
shladd r46 = r42, 1, r34 //(7) |
1045 |
|
cmp.eq p24, p25 = 1, r31 |
1046 |
|
cmp.eq p26, p27 = 3, r31 |
1047 |
|
cmp.eq p28, p29 = 5, r31 |
1048 |
|
;; |
1049 |
|
mov r48 = r14 // calculate memory adresses of data |
1050 |
|
add r33 = r32, r40 |
1051 |
|
add r49 = r14, r40 |
1052 |
|
add r34 = r32, r41 |
1053 |
|
add r50 = r14, r41 |
1054 |
|
add r35 = r32, r42 |
1055 |
|
add r51 = r14, r42 |
1056 |
|
add r36 = r32, r43 |
1057 |
|
add r52 = r14, r43 |
1058 |
|
add r37 = r32, r44 |
1059 |
|
add r53 = r14, r44 |
1060 |
|
add r38 = r32, r45 |
1061 |
|
add r54 = r14, r45 |
1062 |
|
add r39 = r32, r46 |
1063 |
|
add r55 = r14, r46 |
1064 |
|
;; |
1065 |
|
ld8 r32 = [r32] // load everythingund alles wird geladen |
1066 |
|
ld8 r33 = [r33] // cur is located in r32 - r39 |
1067 |
|
ld8 r34 = [r34] // ref in r40 - r47 |
1068 |
|
ld8 r35 = [r35] |
1069 |
|
ld8 r36 = [r36] |
1070 |
|
ld8 r37 = [r37] |
1071 |
|
ld8 r38 = [r38] |
1072 |
|
ld8 r39 = [r39] |
1073 |
|
ld8 r40 = [r48] ,8 |
1074 |
|
ld8 r41 = [r49] ,8 |
1075 |
|
ld8 r42 = [r50] ,8 |
1076 |
|
ld8 r43 = [r51] ,8 |
1077 |
|
ld8 r44 = [r52] ,8 |
1078 |
|
ld8 r45 = [r53] ,8 |
1079 |
|
ld8 r46 = [r54] ,8 |
1080 |
|
ld8 r47 = [r55] ,8 |
1081 |
|
(p16) br.cond.dptk.many .Lber2 // if ref is aligned, we can start the calculation |
1082 |
|
;; |
1083 |
|
ld8 r48 = [r48] // if not, we have to load some more |
1084 |
|
ld8 r49 = [r49] // because of the alignment of ld8 |
1085 |
|
ld8 r50 = [r50] |
1086 |
|
ld8 r51 = [r51] |
1087 |
|
ld8 r52 = [r52] |
1088 |
|
ld8 r53 = [r53] |
1089 |
|
ld8 r54 = [r54] |
1090 |
|
ld8 r55 = [r55] |
1091 |
|
(p24) br.cond.dptk.many .Lmode1 |
1092 |
|
(p18) br.cond.dpnt.many .Lmode2 |
1093 |
|
(p26) br.cond.dpnt.many .Lmode3 |
1094 |
|
(p20) br.cond.dpnt.many .Lmode4 |
1095 |
|
(p28) br.cond.dpnt.many .Lmode5 |
1096 |
|
(p22) br.cond.dpnt.many .Lmode6 |
1097 |
|
;; |
1098 |
|
.Lmode7: // this jump piont is not needed, it is for better understandment |
1099 |
|
shrp r40 = r48, r40, 56 // here we do some preprocessing on the data |
1100 |
|
shrp r41 = r49, r41, 56 // this is because of the alignment problem of ref |
1101 |
|
shrp r42 = r50, r42, 56 |
1102 |
|
shrp r43 = r51, r43, 56 |
1103 |
|
shrp r44 = r52, r44, 56 |
1104 |
|
shrp r45 = r53, r45, 56 |
1105 |
|
shrp r46 = r54, r46, 56 |
1106 |
|
shrp r47 = r55, r47, 56 |
1107 |
|
br.cond.sptk.many .Lber2 |
1108 |
|
;; |
1109 |
|
.Lmode6: |
1110 |
|
shrp r40 = r48, r40, 48 |
1111 |
|
shrp r41 = r49, r41, 48 |
1112 |
|
shrp r42 = r50, r42, 48 |
1113 |
|
shrp r43 = r51, r43, 48 |
1114 |
|
shrp r44 = r52, r44, 48 |
1115 |
|
shrp r45 = r53, r45, 48 |
1116 |
|
shrp r46 = r54, r46, 48 |
1117 |
|
shrp r47 = r55, r47, 48 |
1118 |
|
br.cond.sptk.many .Lber2 |
1119 |
|
;; |
1120 |
|
.Lmode5: |
1121 |
|
shrp r40 = r48, r40, 40 |
1122 |
|
shrp r41 = r49, r41, 40 |
1123 |
|
shrp r42 = r50, r42, 40 |
1124 |
|
shrp r43 = r51, r43, 40 |
1125 |
|
shrp r44 = r52, r44, 40 |
1126 |
|
shrp r45 = r53, r45, 40 |
1127 |
|
shrp r46 = r54, r46, 40 |
1128 |
|
shrp r47 = r55, r47, 40 |
1129 |
|
br.cond.sptk.many .Lber2 |
1130 |
|
;; |
1131 |
|
.Lmode4: |
1132 |
|
shrp r40 = r48, r40, 32 |
1133 |
|
shrp r41 = r49, r41, 32 |
1134 |
|
shrp r42 = r50, r42, 32 |
1135 |
|
shrp r43 = r51, r43, 32 |
1136 |
|
shrp r44 = r52, r44, 32 |
1137 |
|
shrp r45 = r53, r45, 32 |
1138 |
|
shrp r46 = r54, r46, 32 |
1139 |
|
shrp r47 = r55, r47, 32 |
1140 |
|
br.cond.sptk.many .Lber2 |
1141 |
|
;; |
1142 |
|
.Lmode3: |
1143 |
|
shrp r40 = r48, r40, 24 |
1144 |
|
shrp r41 = r49, r41, 24 |
1145 |
|
shrp r42 = r50, r42, 24 |
1146 |
|
shrp r43 = r51, r43, 24 |
1147 |
|
shrp r44 = r52, r44, 24 |
1148 |
|
shrp r45 = r53, r45, 24 |
1149 |
|
shrp r46 = r54, r46, 24 |
1150 |
|
shrp r47 = r55, r47, 24 |
1151 |
|
br.cond.sptk.many .Lber2 |
1152 |
|
;; |
1153 |
|
.Lmode2: |
1154 |
|
shrp r40 = r48, r40, 16 |
1155 |
|
shrp r41 = r49, r41, 16 |
1156 |
|
shrp r42 = r50, r42, 16 |
1157 |
|
shrp r43 = r51, r43, 16 |
1158 |
|
shrp r44 = r52, r44, 16 |
1159 |
|
shrp r45 = r53, r45, 16 |
1160 |
|
shrp r46 = r54, r46, 16 |
1161 |
|
shrp r47 = r55, r47, 16 |
1162 |
|
br.cond.sptk.many .Lber2 |
1163 |
|
;; |
1164 |
|
.Lmode1: |
1165 |
|
shrp r40 = r48, r40, 8 |
1166 |
|
shrp r41 = r49, r41, 8 |
1167 |
|
shrp r42 = r50, r42, 8 |
1168 |
|
shrp r43 = r51, r43, 8 |
1169 |
|
shrp r44 = r52, r44, 8 |
1170 |
|
shrp r45 = r53, r45, 8 |
1171 |
|
shrp r46 = r54, r46, 8 |
1172 |
|
shrp r47 = r55, r47, 8 |
1173 |
|
.Lber2: |
1174 |
|
;; |
1175 |
|
psad1 r32 = r32, r40 // we start calculating sad |
1176 |
|
psad1 r33 = r33, r41 // using th psad1 command of IA64 |
1177 |
|
psad1 r34 = r34, r42 |
1178 |
|
psad1 r35 = r35, r43 |
1179 |
|
psad1 r36 = r36, r44 |
1180 |
|
psad1 r37 = r37, r45 |
1181 |
|
psad1 r38 = r38, r46 |
1182 |
|
psad1 r39 = r39, r47 |
1183 |
|
;; |
1184 |
|
add r32 = r32, r33 // then we sum up everything |
1185 |
|
add r33 = r34, r35 |
1186 |
|
add r34 = r36, r37 |
1187 |
|
add r35 = r38, r39 |
1188 |
|
;; |
1189 |
|
add r32 = r32, r33 |
1190 |
|
add r33 = r34, r35 |
1191 |
|
;; |
1192 |
|
add r8 = r32, r33 // and store the result un r8 |
1193 |
|
mov pr = r2, -1 |
1194 |
|
mov ar.pfs = r1 |
1195 |
|
br.ret.sptk.many b0 |
1196 |
|
.endp sad8_ia64# |