[cvs] / xvidcore / src / motion / ia64_asm / sad_ia64.s Repository:
ViewVC logotype

Diff of /xvidcore/src/motion/ia64_asm/sad_ia64.s

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2, Thu Jun 20 14:25:44 2002 UTC revision 1.6, Fri Sep 6 16:59:47 2002 UTC
# Line 1  Line 1 
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
# Line 494  Line 383 
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
# Line 644  Line 533 
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#
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.6
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4