23 |
// * |
// * |
24 |
// ------------------------------------------------------------------------------ |
// ------------------------------------------------------------------------------ |
25 |
|
|
|
.text |
|
|
|
|
|
// ------------------------------------------------------------------------------ |
|
|
// * SAD16_IA64 |
|
|
// * |
|
|
// * In: |
|
|
// * r32 = cur (aligned) |
|
|
// * r33 = ref (not aligned) |
|
|
// * r34 = stride |
|
|
// * r35 = bestsad |
|
|
// * Out: |
|
|
// * r8 = sum of absolute differences |
|
|
// * |
|
|
// ------------------------------------------------------------------------------ |
|
|
|
|
|
.align 16 |
|
|
.global sad16_ia64# |
|
|
.proc sad16_ia64# |
|
|
sad16_ia64: |
|
|
|
|
|
|
|
|
// Define Latencies |
|
|
LL16=3 // load latency |
|
|
SL16=1 // shift latency |
|
|
OL16=1 // or latency |
|
|
PL16=1 // psad latency |
|
|
AL16=1 // add latency |
|
|
|
|
|
// Allocate Registern in RSE |
|
|
alloc r9=ar.pfs,4,36,0,40 |
|
|
|
|
|
// lfetch [r32] // might help |
|
|
|
|
|
mov r8 = r0 // clear the return reg |
|
|
|
|
|
// Save LC and predicates |
|
|
mov r20 = ar.lc |
|
|
mov r21 = pr |
|
|
|
|
|
dep.z r23 = r33, 3, 3 // get the # of bits ref is misaligned |
|
|
and r15 = -8, r33 // align the ref pointer by deleting the last 3 bit |
|
|
|
|
|
mov r14 = r32 // save the cur pointer |
|
|
mov r16 = r34 // save stride |
|
|
mov r17 = r35 // save bestsad |
|
|
|
|
|
;; |
|
|
add r18 = 8, r14 // precalc second cur pointer |
|
|
add r19 = 8, r15 // precalc second ref pointer |
|
|
add r27 = 16, r15 // precalc third ref pointer |
|
|
sub r25 = 64, r23 // # of right shifts |
|
|
|
|
|
// Initialize Loop-counters |
|
|
mov ar.lc = 15 // loop 16 times |
|
|
mov ar.ec = LL16 + SL16 + OL16 + PL16 + AL16 + AL16 |
|
|
mov pr.rot = 1 << 16 // reseting rotating predicate regs and set p16 to 1 |
|
|
;; |
|
|
|
|
|
// Intialize Arrays for Register Rotation |
|
|
.rotr r_cur_ld1[LL16+SL16+OL16+1], r_cur_ld2[LL16+SL16+OL16+1], r_ref_16_ld1[LL16+1], r_ref_16_ld2[LL16+1], r_ref_16_ld3[LL16+1], r_ref_16_shru1[SL16], r_ref_16_shl1[SL16], r_ref_16_shru2[SL16], r_ref_16_shl2[SL16+1], r_ref_16_or1[OL16], r_ref_16_or2[OL16+1], r_psad1[PL16+1], r_psad2[PL16+1], r_add_16[AL16+1] |
|
|
.rotp p_ld_16[LL16], p_sh_16[SL16], p_or_16[OL16], p_psad_16[PL16], p_add1_16[AL16], p_add2_16[AL16] |
|
26 |
|
|
|
.L_loop16: |
|
|
{.mmi |
|
|
(p_ld_16[0]) ld8 r_cur_ld1[0] = [r14], r16 // Cur load first 8 Byte |
|
|
(p_ld_16[0]) ld8 r_cur_ld2[0] = [r18], r16 // Cur load next 8 Byte |
|
|
(p_psad_16[0]) psad1 r_psad1[0] = r_cur_ld1[LL16+SL16+OL16], r_ref_16_or2[0] // psad of cur and ref |
|
|
} |
|
|
{.mmi |
|
|
(p_ld_16[0]) ld8 r_ref_16_ld1[0] = [r15], r16 // Ref load first 8 Byte (unaligned) |
|
|
(p_ld_16[0]) ld8 r_ref_16_ld2[0] = [r19], r16 // Ref load next 8 Byte (unaligned) |
|
|
(p_psad_16[0]) psad1 r_psad2[0] = r_cur_ld2[LL16+SL16+OL16], r_ref_16_or2[OL16] // psad of cur_2 and ref_2 |
|
|
} |
|
|
{.mii |
|
|
(p_ld_16[0]) ld8 r_ref_16_ld3[0] = [r27], r16 // Ref load third 8 Byte (unaligned) |
|
|
(p_or_16[0]) or r_ref_16_or1[0] = r_ref_16_shl1[0], r_ref_16_shru2[0] // Ref or r_ref_16_shl1 + 1 and r_ref_16_shl1 + 1 |
|
|
(p_sh_16[0]) shr.u r_ref_16_shru1[0] = r_ref_16_ld1[LL16], r23 // Ref shift |
|
|
} |
|
|
{.mii |
|
|
(p_or_16[0]) or r_ref_16_or2[0] = r_ref_16_shl2[0], r_ref_16_shl2[SL16] // Ref or r_ref_shru2 + 1 and r_ref_shl2 + 1 |
|
|
(p_sh_16[0]) shl r_ref_16_shl1[0] = r_ref_16_ld2[LL16], r25 // Ref shift |
|
|
(p_sh_16[0]) shr.u r_ref_16_shru2[0] = r_ref_16_ld2[LL16], r23 // Ref shift |
|
|
} |
|
|
{.mib |
|
|
(p_add2_16[0]) cmp.ge.unc p6, p7 = r8, r17 |
|
|
(p_sh_16[0]) shl r_ref_16_shl2[0]= r_ref_16_ld3[LL16], r25 // Ref shift |
|
|
(p6) br.spnt.few .L_loop_exit16 |
|
|
} |
|
|
{.mmb |
|
|
(p_add1_16[0]) add r_add_16[0] = r_psad1[PL16], r_psad2[PL16] // add the psad results |
|
|
(p_add2_16[0]) add r8 = r8, r_add_16[AL16] // add the results to the sum |
|
|
br.ctop.sptk.few .L_loop16 |
|
|
;; |
|
|
} |
|
|
.L_loop_exit16: |
|
|
|
|
|
// Restore LC and predicates |
|
|
mov ar.lc = r20 |
|
|
mov pr = r21,-1 |
|
|
|
|
|
// Return |
|
|
br.ret.sptk.many rp |
|
|
.endp sad16_ia64# |
|
|
|
|
|
// ------------------------------------------------------------------------------ |
|
|
// * SAD8_IA64 |
|
|
// * |
|
|
// * In: |
|
|
// * r32 = cur (aligned) |
|
|
// * r33 = ref (not aligned) |
|
|
// * r34 = stride |
|
|
// * Out: |
|
|
// * r8 = sum of absolute differences |
|
|
// * |
|
|
// ------------------------------------------------------------------------------ |
|
|
|
|
|
.align 16 |
|
|
.global sad8_ia64# |
|
|
.proc sad8_ia64# |
|
|
|
|
|
sad8_ia64: |
|
|
|
|
|
|
|
|
// Define Latencies |
|
|
LL8=3 // load latency |
|
|
SL8=1 // shift latency |
|
|
OL8=1 // or latency |
|
|
PL8=1 // psad latency |
|
|
AL8=1 // add latency |
|
|
|
|
|
// Allocate Registers in RSE |
|
|
alloc r9 = ar.pfs,3,21,0,24 |
|
|
|
|
|
// lfetch [r32] // Maybe this helps? |
|
|
|
|
|
mov r8 = r0 // Initialize result |
|
|
|
|
|
mov r14 = r32 // Save Cur |
|
|
and r15 = -8, r33 // Align the Ref pointer by deleting the last 3 bit |
|
|
mov r16 = r34 // Save Stride |
|
|
|
|
|
// Save LC and predicates |
|
|
mov r20 = ar.lc |
|
|
mov r21 = pr |
|
|
|
|
|
dep.z r23 = r33, 3, 3 // get the # of bits ref is misaligned |
|
|
|
|
|
;; |
|
|
|
|
|
add r19 = 8, r15 // Precalculate second load-offset |
|
|
sub r25 = 64, r23 // Precalculate # of shifts |
|
|
|
|
|
// Initialize Loop-Counters |
|
|
mov ar.lc = 7 // Loop 7 times |
|
|
mov ar.ec = LL8 + SL8 + OL8 + PL8 + AL8 // Epiloque |
|
|
mov pr.rot = 1 << 16 // Reset Predicate Registers and initialize with P16 |
|
|
|
|
|
// Initalize Arrays for Register Rotation |
|
|
.rotr r_cur_ld[LL8+SL8+OL8+1], r_ref_ld1[LL8+1], r_ref_ld2[LL8+1], r_shru[SL8+1], r_shl[SL8+1], r_or[OL8+1], r_psad[PL8+1] |
|
|
.rotp p_ld[LL8], p_sh[SL8], p_or[OL8], p_psad[PL8], p_add[AL8] |
|
|
|
|
|
;; |
|
|
.L_loop8: |
|
|
// {.mmi |
|
|
(p_ld[0]) ld8 r_ref_ld1[0] = [r15], r16 // Load 1st 8Byte from Ref |
|
|
(p_ld[0]) ld8 r_cur_ld[0] = [r14], r16 // Load Cur |
|
|
(p_psad[0]) psad1 r_psad[0] = r_cur_ld[LL8+SL8+OL8], r_or[OL8] // Do the Calculation |
|
|
// } |
|
|
// {.mii |
|
|
(p_ld[0]) ld8 r_ref_ld2[0] = [r19], r16 // Load 2nd 8Byte from Ref |
|
|
(p_sh[0]) shr.u r_shru[0] = r_ref_ld1[LL8], r23 // Shift unaligned Ref parts |
|
|
(p_sh[0]) shl r_shl[0] = r_ref_ld2[LL8], r25 // Shift unaligned Ref parts |
|
|
// } |
|
|
// {.mib |
|
|
(p_or[0]) or r_or[0] = r_shru[SL8], r_shl[SL8] // Combine unaligned Ref parts |
|
|
(p_add[0]) add r8 = r8, r_psad[PL8] // Sum psad result |
|
|
br.ctop.sptk.few .L_loop8 |
|
|
;; |
|
|
// } |
|
|
|
|
|
// Restore Loop counters |
|
|
mov ar.lc = r20 |
|
|
mov pr = r21,-1 |
|
|
|
|
|
// Return |
|
|
br.ret.sptk.many b0 |
|
|
.endp sad8_ia64# |
|
27 |
|
|
28 |
|
|
29 |
.common sad16bi#,8,8 |
.common sad16bi#,8,8 |
503 |
br.ret.sptk.many b0 |
br.ret.sptk.many b0 |
504 |
} |
} |
505 |
.endp dev16_ia64# |
.endp dev16_ia64# |
506 |
|
|
507 |
|
|
508 |
|
// ########################################################### |
509 |
|
// ########################################################### |
510 |
|
// Neue version von gruppe 01 ################################ |
511 |
|
// ########################################################### |
512 |
|
// ########################################################### |
513 |
|
|
514 |
|
|
515 |
|
|
516 |
|
.text |
517 |
|
.align 16 |
518 |
|
.global sad16_ia64# |
519 |
|
.proc sad16_ia64# |
520 |
|
sad16_ia64: |
521 |
|
alloc r1 = ar.pfs, 4, 76, 0, 0 |
522 |
|
mov r2 = pr |
523 |
|
dep r14 = r0, r33, 0, 3 // r14 = (r33 div 8)*8 (aligned version of ref) |
524 |
|
dep.z r31 = r33, 0, 3 // r31 = r33 mod 8 (misalignment of ref) |
525 |
|
;; |
526 |
|
mov r64 = r34 //(1) calculate multiples of stride |
527 |
|
shl r65 = r34, 1 //(2) for being able to load all the |
528 |
|
shladd r66 = r34, 1, r34 //(3) data at once |
529 |
|
shl r67 = r34, 2 //(4) |
530 |
|
shladd r68 = r34, 2, r34 //(5) |
531 |
|
shl r71 = r34, 3 //(8) |
532 |
|
shladd r72 = r34, 3, r34 //(9) |
533 |
|
;; |
534 |
|
shl r69 = r66, 1 //(6) |
535 |
|
shladd r70 = r66, 1, r34 //(7) |
536 |
|
shl r73 = r68, 1 //(10) |
537 |
|
shladd r74 = r68, 1, r34 //(11) |
538 |
|
shl r75 = r66, 2 //(12) |
539 |
|
shladd r76 = r66, 2, r34 //(13) |
540 |
|
shladd r77 = r66, 2, r65 //(14) |
541 |
|
shladd r78 = r66, 2, r66 //(15) |
542 |
|
;; |
543 |
|
cmp.eq p16, p17 = 0, r31 // prepare predicates according to the misalignment |
544 |
|
cmp.eq p18, p19 = 2, r31 // ref |
545 |
|
cmp.eq p20, p21 = 4, r31 |
546 |
|
cmp.eq p22, p23 = 6, r31 |
547 |
|
cmp.eq p24, p25 = 1, r31 |
548 |
|
cmp.eq p26, p27 = 3, r31 |
549 |
|
cmp.eq p28, p29 = 5, r31 |
550 |
|
mov r96 = r14 // and calculate all the adresses where we have |
551 |
|
mov r33 = r32 // to load from |
552 |
|
add r97 = r14, r64 |
553 |
|
add r35 = r32, r64 |
554 |
|
add r98 = r14, r65 |
555 |
|
add r37 = r32, r65 |
556 |
|
add r99 = r14, r66 |
557 |
|
add r39 = r32, r66 |
558 |
|
add r100 = r14, r67 |
559 |
|
add r41 = r32, r67 |
560 |
|
add r101 = r14, r68 |
561 |
|
add r43 = r32, r68 |
562 |
|
add r102 = r14, r69 |
563 |
|
add r45 = r32, r69 |
564 |
|
add r103 = r14, r70 |
565 |
|
add r47 = r32, r70 |
566 |
|
add r104 = r14, r71 |
567 |
|
add r49 = r32, r71 |
568 |
|
add r105 = r14, r72 |
569 |
|
add r51 = r32, r72 |
570 |
|
add r106 = r14, r73 |
571 |
|
add r53 = r32, r73 |
572 |
|
add r107 = r14, r74 |
573 |
|
add r55 = r32, r74 |
574 |
|
add r108 = r14, r75 |
575 |
|
add r57 = r32, r75 |
576 |
|
add r109 = r14, r76 |
577 |
|
add r59 = r32, r76 |
578 |
|
add r110 = r14, r77 |
579 |
|
add r61 = r32, r77 |
580 |
|
add r111 = r14, r78 |
581 |
|
add r63 = r32, r78 |
582 |
|
;; |
583 |
|
ld8 r32 = [r33], 8 // Load all the data which is needed for the sad |
584 |
|
ld8 r34 = [r35], 8 // in the registers. the goal is to have the array |
585 |
|
ld8 r36 = [r37], 8 // adressed by cur in the registers r32 - r63 and |
586 |
|
ld8 r38 = [r39], 8 // the aray adressed by ref in the registers |
587 |
|
ld8 r40 = [r41], 8 // r64 - r95. The registers r96 - r111 are needed |
588 |
|
ld8 r42 = [r43], 8 // to load the aligned 24 bits in which the |
589 |
|
ld8 r44 = [r45], 8 // needed misaligned 16 bits must be. |
590 |
|
ld8 r46 = [r47], 8 // After loading we start a preprocessing which |
591 |
|
ld8 r48 = [r49], 8 // guarantees that the data adressed by ref is in |
592 |
|
ld8 r50 = [r51], 8 // the registers r64 - r95. |
593 |
|
ld8 r52 = [r53], 8 |
594 |
|
ld8 r54 = [r55], 8 |
595 |
|
ld8 r56 = [r57], 8 |
596 |
|
ld8 r58 = [r59], 8 |
597 |
|
ld8 r60 = [r61], 8 |
598 |
|
ld8 r62 = [r63], 8 |
599 |
|
ld8 r64 = [r96], 8 |
600 |
|
ld8 r66 = [r97], 8 |
601 |
|
ld8 r68 = [r98], 8 |
602 |
|
ld8 r70 = [r99], 8 |
603 |
|
ld8 r72 = [r100], 8 |
604 |
|
ld8 r74 = [r101], 8 |
605 |
|
ld8 r76 = [r102], 8 |
606 |
|
ld8 r78 = [r103], 8 |
607 |
|
ld8 r80 = [r104], 8 |
608 |
|
ld8 r82 = [r105], 8 |
609 |
|
ld8 r84 = [r106], 8 |
610 |
|
ld8 r86 = [r107], 8 |
611 |
|
ld8 r88 = [r108], 8 |
612 |
|
ld8 r90 = [r109], 8 |
613 |
|
ld8 r92 = [r110], 8 |
614 |
|
ld8 r94 = [r111], 8 |
615 |
|
;; |
616 |
|
ld8 r33 = [r33] |
617 |
|
ld8 r35 = [r35] |
618 |
|
ld8 r37 = [r37] |
619 |
|
ld8 r39 = [r39] |
620 |
|
ld8 r41 = [r41] |
621 |
|
ld8 r43 = [r43] |
622 |
|
ld8 r45 = [r45] |
623 |
|
ld8 r47 = [r47] |
624 |
|
ld8 r49 = [r49] |
625 |
|
ld8 r51 = [r51] |
626 |
|
ld8 r53 = [r53] |
627 |
|
ld8 r55 = [r55] |
628 |
|
ld8 r57 = [r57] |
629 |
|
ld8 r59 = [r59] |
630 |
|
ld8 r61 = [r61] |
631 |
|
ld8 r63 = [r63] |
632 |
|
ld8 r65 = [r96], 8 |
633 |
|
ld8 r67 = [r97], 8 |
634 |
|
ld8 r69 = [r98], 8 |
635 |
|
ld8 r71 = [r99], 8 |
636 |
|
ld8 r73 = [r100], 8 |
637 |
|
ld8 r75 = [r101], 8 |
638 |
|
ld8 r77 = [r102], 8 |
639 |
|
ld8 r79 = [r103], 8 |
640 |
|
ld8 r81 = [r104], 8 |
641 |
|
ld8 r83 = [r105], 8 |
642 |
|
ld8 r85 = [r106], 8 |
643 |
|
ld8 r87 = [r107], 8 |
644 |
|
ld8 r89 = [r108], 8 |
645 |
|
ld8 r91 = [r109], 8 |
646 |
|
ld8 r93 = [r110], 8 |
647 |
|
ld8 r95 = [r111], 8 |
648 |
|
(p16) br.cond.dptk.many .Lber // If ref is aligned, everything is loaded and we can start the calculation |
649 |
|
;; |
650 |
|
ld8 r96 = [r96] // If not, we have to load a bit more |
651 |
|
ld8 r97 = [r97] |
652 |
|
ld8 r98 = [r98] |
653 |
|
ld8 r99 = [r99] |
654 |
|
ld8 r100 = [r100] |
655 |
|
ld8 r101 = [r101] |
656 |
|
ld8 r102 = [r102] |
657 |
|
ld8 r103 = [r103] |
658 |
|
ld8 r104 = [r104] |
659 |
|
ld8 r105 = [r105] |
660 |
|
ld8 r106 = [r106] |
661 |
|
ld8 r107 = [r107] |
662 |
|
ld8 r108 = [r108] |
663 |
|
ld8 r109 = [r109] |
664 |
|
ld8 r110 = [r110] |
665 |
|
ld8 r111 = [r111] |
666 |
|
(p24) br.cond.dptk.many .Lmod1 // according to the misalignment, we have |
667 |
|
(p18) br.cond.dpnt.many .Lmod2 // to jump to different preprocessing routines |
668 |
|
(p26) br.cond.dpnt.many .Lmod3 |
669 |
|
(p20) br.cond.dpnt.many .Lmod4 |
670 |
|
(p28) br.cond.dpnt.many .Lmod5 |
671 |
|
(p22) br.cond.dpnt.many .Lmod6 |
672 |
|
;; |
673 |
|
.Lmod7: // this jump point is not needed |
674 |
|
shrp r64 = r65, r64, 56 // in these blocks, we do the preprocessing |
675 |
|
shrp r65 = r96, r65, 56 |
676 |
|
shrp r66 = r67, r66, 56 |
677 |
|
shrp r67 = r97, r67, 56 |
678 |
|
shrp r68 = r69, r68, 56 |
679 |
|
shrp r69 = r98, r69, 56 |
680 |
|
shrp r70 = r71, r70, 56 |
681 |
|
shrp r71 = r99, r71, 56 |
682 |
|
shrp r72 = r73, r72, 56 |
683 |
|
shrp r73 = r100, r73, 56 |
684 |
|
shrp r74 = r75, r74, 56 |
685 |
|
shrp r75 = r101, r75, 56 |
686 |
|
shrp r76 = r77, r76, 56 |
687 |
|
shrp r77 = r102, r77, 56 |
688 |
|
shrp r78 = r79, r78, 56 |
689 |
|
shrp r79 = r103, r79, 56 |
690 |
|
shrp r80 = r81, r80, 56 |
691 |
|
shrp r81 = r104, r81, 56 |
692 |
|
shrp r82 = r83, r82, 56 |
693 |
|
shrp r83 = r105, r83, 56 |
694 |
|
shrp r84 = r85, r84, 56 |
695 |
|
shrp r85 = r106, r85, 56 |
696 |
|
shrp r86 = r87, r86, 56 |
697 |
|
shrp r87 = r107, r87, 56 |
698 |
|
shrp r88 = r89, r88, 56 |
699 |
|
shrp r89 = r108, r89, 56 |
700 |
|
shrp r90 = r91, r90, 56 |
701 |
|
shrp r91 = r109, r91, 56 |
702 |
|
shrp r92 = r93, r92, 56 |
703 |
|
shrp r93 = r110, r93, 56 |
704 |
|
shrp r94 = r95, r94, 56 |
705 |
|
shrp r95 = r111, r95, 56 |
706 |
|
br.cond.sptk.many .Lber // and then we jump to the calculation |
707 |
|
;; |
708 |
|
.Lmod6: |
709 |
|
shrp r64 = r65, r64, 48 |
710 |
|
shrp r65 = r96, r65, 48 |
711 |
|
shrp r66 = r67, r66, 48 |
712 |
|
shrp r67 = r97, r67, 48 |
713 |
|
shrp r68 = r69, r68, 48 |
714 |
|
shrp r69 = r98, r69, 48 |
715 |
|
shrp r70 = r71, r70, 48 |
716 |
|
shrp r71 = r99, r71, 48 |
717 |
|
shrp r72 = r73, r72, 48 |
718 |
|
shrp r73 = r100, r73, 48 |
719 |
|
shrp r74 = r75, r74, 48 |
720 |
|
shrp r75 = r101, r75, 48 |
721 |
|
shrp r76 = r77, r76, 48 |
722 |
|
shrp r77 = r102, r77, 48 |
723 |
|
shrp r78 = r79, r78, 48 |
724 |
|
shrp r79 = r103, r79, 48 |
725 |
|
shrp r80 = r81, r80, 48 |
726 |
|
shrp r81 = r104, r81, 48 |
727 |
|
shrp r82 = r83, r82, 48 |
728 |
|
shrp r83 = r105, r83, 48 |
729 |
|
shrp r84 = r85, r84, 48 |
730 |
|
shrp r85 = r106, r85, 48 |
731 |
|
shrp r86 = r87, r86, 48 |
732 |
|
shrp r87 = r107, r87, 48 |
733 |
|
shrp r88 = r89, r88, 48 |
734 |
|
shrp r89 = r108, r89, 48 |
735 |
|
shrp r90 = r91, r90, 48 |
736 |
|
shrp r91 = r109, r91, 48 |
737 |
|
shrp r92 = r93, r92, 48 |
738 |
|
shrp r93 = r110, r93, 48 |
739 |
|
shrp r94 = r95, r94, 48 |
740 |
|
shrp r95 = r111, r95, 48 |
741 |
|
br.cond.sptk.many .Lber |
742 |
|
;; |
743 |
|
.Lmod5: |
744 |
|
shrp r64 = r65, r64, 40 |
745 |
|
shrp r65 = r96, r65, 40 |
746 |
|
shrp r66 = r67, r66, 40 |
747 |
|
shrp r67 = r97, r67, 40 |
748 |
|
shrp r68 = r69, r68, 40 |
749 |
|
shrp r69 = r98, r69, 40 |
750 |
|
shrp r70 = r71, r70, 40 |
751 |
|
shrp r71 = r99, r71, 40 |
752 |
|
shrp r72 = r73, r72, 40 |
753 |
|
shrp r73 = r100, r73, 40 |
754 |
|
shrp r74 = r75, r74, 40 |
755 |
|
shrp r75 = r101, r75, 40 |
756 |
|
shrp r76 = r77, r76, 40 |
757 |
|
shrp r77 = r102, r77, 40 |
758 |
|
shrp r78 = r79, r78, 40 |
759 |
|
shrp r79 = r103, r79, 40 |
760 |
|
shrp r80 = r81, r80, 40 |
761 |
|
shrp r81 = r104, r81, 40 |
762 |
|
shrp r82 = r83, r82, 40 |
763 |
|
shrp r83 = r105, r83, 40 |
764 |
|
shrp r84 = r85, r84, 40 |
765 |
|
shrp r85 = r106, r85, 40 |
766 |
|
shrp r86 = r87, r86, 40 |
767 |
|
shrp r87 = r107, r87, 40 |
768 |
|
shrp r88 = r89, r88, 40 |
769 |
|
shrp r89 = r108, r89, 40 |
770 |
|
shrp r90 = r91, r90, 40 |
771 |
|
shrp r91 = r109, r91, 40 |
772 |
|
shrp r92 = r93, r92, 40 |
773 |
|
shrp r93 = r110, r93, 40 |
774 |
|
shrp r94 = r95, r94, 40 |
775 |
|
shrp r95 = r111, r95, 40 |
776 |
|
br.cond.sptk.many .Lber |
777 |
|
;; |
778 |
|
.Lmod4: |
779 |
|
shrp r64 = r65, r64, 32 |
780 |
|
shrp r65 = r96, r65, 32 |
781 |
|
shrp r66 = r67, r66, 32 |
782 |
|
shrp r67 = r97, r67, 32 |
783 |
|
shrp r68 = r69, r68, 32 |
784 |
|
shrp r69 = r98, r69, 32 |
785 |
|
shrp r70 = r71, r70, 32 |
786 |
|
shrp r71 = r99, r71, 32 |
787 |
|
shrp r72 = r73, r72, 32 |
788 |
|
shrp r73 = r100, r73, 32 |
789 |
|
shrp r74 = r75, r74, 32 |
790 |
|
shrp r75 = r101, r75, 32 |
791 |
|
shrp r76 = r77, r76, 32 |
792 |
|
shrp r77 = r102, r77, 32 |
793 |
|
shrp r78 = r79, r78, 32 |
794 |
|
shrp r79 = r103, r79, 32 |
795 |
|
shrp r80 = r81, r80, 32 |
796 |
|
shrp r81 = r104, r81, 32 |
797 |
|
shrp r82 = r83, r82, 32 |
798 |
|
shrp r83 = r105, r83, 32 |
799 |
|
shrp r84 = r85, r84, 32 |
800 |
|
shrp r85 = r106, r85, 32 |
801 |
|
shrp r86 = r87, r86, 32 |
802 |
|
shrp r87 = r107, r87, 32 |
803 |
|
shrp r88 = r89, r88, 32 |
804 |
|
shrp r89 = r108, r89, 32 |
805 |
|
shrp r90 = r91, r90, 32 |
806 |
|
shrp r91 = r109, r91, 32 |
807 |
|
shrp r92 = r93, r92, 32 |
808 |
|
shrp r93 = r110, r93, 32 |
809 |
|
shrp r94 = r95, r94, 32 |
810 |
|
shrp r95 = r111, r95, 32 |
811 |
|
br.cond.sptk.many .Lber |
812 |
|
;; |
813 |
|
.Lmod3: |
814 |
|
shrp r64 = r65, r64, 24 |
815 |
|
shrp r65 = r96, r65, 24 |
816 |
|
shrp r66 = r67, r66, 24 |
817 |
|
shrp r67 = r97, r67, 24 |
818 |
|
shrp r68 = r69, r68, 24 |
819 |
|
shrp r69 = r98, r69, 24 |
820 |
|
shrp r70 = r71, r70, 24 |
821 |
|
shrp r71 = r99, r71, 24 |
822 |
|
shrp r72 = r73, r72, 24 |
823 |
|
shrp r73 = r100, r73, 24 |
824 |
|
shrp r74 = r75, r74, 24 |
825 |
|
shrp r75 = r101, r75, 24 |
826 |
|
shrp r76 = r77, r76, 24 |
827 |
|
shrp r77 = r102, r77, 24 |
828 |
|
shrp r78 = r79, r78, 24 |
829 |
|
shrp r79 = r103, r79, 24 |
830 |
|
shrp r80 = r81, r80, 24 |
831 |
|
shrp r81 = r104, r81, 24 |
832 |
|
shrp r82 = r83, r82, 24 |
833 |
|
shrp r83 = r105, r83, 24 |
834 |
|
shrp r84 = r85, r84, 24 |
835 |
|
shrp r85 = r106, r85, 24 |
836 |
|
shrp r86 = r87, r86, 24 |
837 |
|
shrp r87 = r107, r87, 24 |
838 |
|
shrp r88 = r89, r88, 24 |
839 |
|
shrp r89 = r108, r89, 24 |
840 |
|
shrp r90 = r91, r90, 24 |
841 |
|
shrp r91 = r109, r91, 24 |
842 |
|
shrp r92 = r93, r92, 24 |
843 |
|
shrp r93 = r110, r93, 24 |
844 |
|
shrp r94 = r95, r94, 24 |
845 |
|
shrp r95 = r111, r95, 24 |
846 |
|
br.cond.sptk.many .Lber |
847 |
|
;; |
848 |
|
.Lmod2: |
849 |
|
shrp r64 = r65, r64, 16 |
850 |
|
shrp r65 = r96, r65, 16 |
851 |
|
shrp r66 = r67, r66, 16 |
852 |
|
shrp r67 = r97, r67, 16 |
853 |
|
shrp r68 = r69, r68, 16 |
854 |
|
shrp r69 = r98, r69, 16 |
855 |
|
shrp r70 = r71, r70, 16 |
856 |
|
shrp r71 = r99, r71, 16 |
857 |
|
shrp r72 = r73, r72, 16 |
858 |
|
shrp r73 = r100, r73, 16 |
859 |
|
shrp r74 = r75, r74, 16 |
860 |
|
shrp r75 = r101, r75, 16 |
861 |
|
shrp r76 = r77, r76, 16 |
862 |
|
shrp r77 = r102, r77, 16 |
863 |
|
shrp r78 = r79, r78, 16 |
864 |
|
shrp r79 = r103, r79, 16 |
865 |
|
shrp r80 = r81, r80, 16 |
866 |
|
shrp r81 = r104, r81, 16 |
867 |
|
shrp r82 = r83, r82, 16 |
868 |
|
shrp r83 = r105, r83, 16 |
869 |
|
shrp r84 = r85, r84, 16 |
870 |
|
shrp r85 = r106, r85, 16 |
871 |
|
shrp r86 = r87, r86, 16 |
872 |
|
shrp r87 = r107, r87, 16 |
873 |
|
shrp r88 = r89, r88, 16 |
874 |
|
shrp r89 = r108, r89, 16 |
875 |
|
shrp r90 = r91, r90, 16 |
876 |
|
shrp r91 = r109, r91, 16 |
877 |
|
shrp r92 = r93, r92, 16 |
878 |
|
shrp r93 = r110, r93, 16 |
879 |
|
shrp r94 = r95, r94, 16 |
880 |
|
shrp r95 = r111, r95, 16 |
881 |
|
br.cond.sptk.many .Lber |
882 |
|
;; |
883 |
|
.Lmod1: |
884 |
|
shrp r64 = r65, r64, 8 |
885 |
|
shrp r65 = r96, r65, 8 |
886 |
|
shrp r66 = r67, r66, 8 |
887 |
|
shrp r67 = r97, r67, 8 |
888 |
|
shrp r68 = r69, r68, 8 |
889 |
|
shrp r69 = r98, r69, 8 |
890 |
|
shrp r70 = r71, r70, 8 |
891 |
|
shrp r71 = r99, r71, 8 |
892 |
|
shrp r72 = r73, r72, 8 |
893 |
|
shrp r73 = r100, r73, 8 |
894 |
|
shrp r74 = r75, r74, 8 |
895 |
|
shrp r75 = r101, r75, 8 |
896 |
|
shrp r76 = r77, r76, 8 |
897 |
|
shrp r77 = r102, r77, 8 |
898 |
|
shrp r78 = r79, r78, 8 |
899 |
|
shrp r79 = r103, r79, 8 |
900 |
|
shrp r80 = r81, r80, 8 |
901 |
|
shrp r81 = r104, r81, 8 |
902 |
|
shrp r82 = r83, r82, 8 |
903 |
|
shrp r83 = r105, r83, 8 |
904 |
|
shrp r84 = r85, r84, 8 |
905 |
|
shrp r85 = r106, r85, 8 |
906 |
|
shrp r86 = r87, r86, 8 |
907 |
|
shrp r87 = r107, r87, 8 |
908 |
|
shrp r88 = r89, r88, 8 |
909 |
|
shrp r89 = r108, r89, 8 |
910 |
|
shrp r90 = r91, r90, 8 |
911 |
|
shrp r91 = r109, r91, 8 |
912 |
|
shrp r92 = r93, r92, 8 |
913 |
|
shrp r93 = r110, r93, 8 |
914 |
|
shrp r94 = r95, r94, 8 |
915 |
|
shrp r95 = r111, r95, 8 |
916 |
|
.Lber: |
917 |
|
;; |
918 |
|
psad1 r32 = r32, r64 // Here we do the calculation. |
919 |
|
psad1 r33 = r33, r65 // The machine is providing a fast method |
920 |
|
psad1 r34 = r34, r66 // for calculating sad, so we use it |
921 |
|
psad1 r35 = r35, r67 |
922 |
|
psad1 r36 = r36, r68 |
923 |
|
psad1 r37 = r37, r69 |
924 |
|
psad1 r38 = r38, r70 |
925 |
|
psad1 r39 = r39, r71 |
926 |
|
psad1 r40 = r40, r72 |
927 |
|
psad1 r41 = r41, r73 |
928 |
|
psad1 r42 = r42, r74 |
929 |
|
psad1 r43 = r43, r75 |
930 |
|
psad1 r44 = r44, r76 |
931 |
|
psad1 r45 = r45, r77 |
932 |
|
psad1 r46 = r46, r78 |
933 |
|
psad1 r47 = r47, r79 |
934 |
|
psad1 r48 = r48, r80 |
935 |
|
psad1 r49 = r49, r81 |
936 |
|
psad1 r50 = r50, r82 |
937 |
|
psad1 r51 = r51, r83 |
938 |
|
psad1 r52 = r52, r84 |
939 |
|
psad1 r53 = r53, r85 |
940 |
|
psad1 r54 = r54, r86 |
941 |
|
psad1 r55 = r55, r87 |
942 |
|
psad1 r56 = r56, r88 |
943 |
|
psad1 r57 = r57, r89 |
944 |
|
psad1 r58 = r58, r90 |
945 |
|
psad1 r59 = r59, r91 |
946 |
|
psad1 r60 = r60, r92 |
947 |
|
psad1 r61 = r61, r93 |
948 |
|
psad1 r62 = r62, r94 |
949 |
|
psad1 r63 = r63, r95 |
950 |
|
;; |
951 |
|
add r32 = r32, r63 // at last, we have to sum up |
952 |
|
add r33 = r33, r62 // in 5 stages |
953 |
|
add r34 = r34, r61 |
954 |
|
add r35 = r35, r60 |
955 |
|
add r36 = r36, r59 |
956 |
|
add r37 = r37, r58 |
957 |
|
add r38 = r38, r57 |
958 |
|
add r39 = r39, r56 |
959 |
|
add r40 = r40, r55 |
960 |
|
add r41 = r41, r54 |
961 |
|
add r42 = r42, r53 |
962 |
|
add r43 = r43, r52 |
963 |
|
add r44 = r44, r51 |
964 |
|
add r45 = r45, r50 |
965 |
|
add r46 = r46, r49 |
966 |
|
add r47 = r47, r48 |
967 |
|
;; |
968 |
|
add r32 = r32, r47 |
969 |
|
add r33 = r33, r46 |
970 |
|
add r34 = r34, r45 |
971 |
|
add r35 = r35, r44 |
972 |
|
add r36 = r36, r43 |
973 |
|
add r37 = r37, r42 |
974 |
|
add r38 = r38, r41 |
975 |
|
add r39 = r39, r40 |
976 |
|
;; |
977 |
|
add r32 = r32, r39 |
978 |
|
add r33 = r33, r38 |
979 |
|
add r34 = r34, r37 |
980 |
|
add r35 = r35, r36 |
981 |
|
;; |
982 |
|
add r32 = r32, r35 |
983 |
|
add r33 = r33, r34 |
984 |
|
;; |
985 |
|
add r8 = r32, r33 // and store the result in r8 |
986 |
|
mov pr = r2, -1 |
987 |
|
mov ar.pfs = r1 |
988 |
|
br.ret.sptk.many b0 |
989 |
|
.endp sad16_ia64# |
990 |
|
|
991 |
|
|
992 |
|
|
993 |
|
|
994 |
|
.align 16 |
995 |
|
.global sad8_ia64# |
996 |
|
.proc sad8_ia64# |
997 |
|
sad8_ia64: |
998 |
|
alloc r1 = ar.pfs, 3, 21, 0, 0 |
999 |
|
mov r2 = pr |
1000 |
|
dep r14 = r0, r33, 0, 3 // calculate aligned version of ref |
1001 |
|
dep.z r31 = r33, 0, 3 // calculate misalignment of ref |
1002 |
|
;; |
1003 |
|
mov r40 = r34 //(1) calculate multiples of stride |
1004 |
|
shl r41 = r34, 1 //(2) |
1005 |
|
shladd r42 = r34, 1, r34 //(3) |
1006 |
|
shl r43 = r34, 2 //(4) |
1007 |
|
shladd r44 = r34, 2, r34 //(5) |
1008 |
|
;; |
1009 |
|
cmp.eq p16, p17 = 0, r31 // set predicates according to the misalignment of ref |
1010 |
|
cmp.eq p18, p19 = 2, r31 |
1011 |
|
shl r45 = r42, 1 //(6) |
1012 |
|
cmp.eq p20, p21 = 4, r31 |
1013 |
|
cmp.eq p22, p23 = 6, r31 |
1014 |
|
shladd r46 = r42, 1, r34 //(7) |
1015 |
|
cmp.eq p24, p25 = 1, r31 |
1016 |
|
cmp.eq p26, p27 = 3, r31 |
1017 |
|
cmp.eq p28, p29 = 5, r31 |
1018 |
|
;; |
1019 |
|
mov r48 = r14 // calculate memory adresses of data |
1020 |
|
add r33 = r32, r40 |
1021 |
|
add r49 = r14, r40 |
1022 |
|
add r34 = r32, r41 |
1023 |
|
add r50 = r14, r41 |
1024 |
|
add r35 = r32, r42 |
1025 |
|
add r51 = r14, r42 |
1026 |
|
add r36 = r32, r43 |
1027 |
|
add r52 = r14, r43 |
1028 |
|
add r37 = r32, r44 |
1029 |
|
add r53 = r14, r44 |
1030 |
|
add r38 = r32, r45 |
1031 |
|
add r54 = r14, r45 |
1032 |
|
add r39 = r32, r46 |
1033 |
|
add r55 = r14, r46 |
1034 |
|
;; |
1035 |
|
ld8 r32 = [r32] // load everythingund alles wird geladen |
1036 |
|
ld8 r33 = [r33] // cur is located in r32 - r39 |
1037 |
|
ld8 r34 = [r34] // ref in r40 - r47 |
1038 |
|
ld8 r35 = [r35] |
1039 |
|
ld8 r36 = [r36] |
1040 |
|
ld8 r37 = [r37] |
1041 |
|
ld8 r38 = [r38] |
1042 |
|
ld8 r39 = [r39] |
1043 |
|
ld8 r40 = [r48] ,8 |
1044 |
|
ld8 r41 = [r49] ,8 |
1045 |
|
ld8 r42 = [r50] ,8 |
1046 |
|
ld8 r43 = [r51] ,8 |
1047 |
|
ld8 r44 = [r52] ,8 |
1048 |
|
ld8 r45 = [r53] ,8 |
1049 |
|
ld8 r46 = [r54] ,8 |
1050 |
|
ld8 r47 = [r55] ,8 |
1051 |
|
(p16) br.cond.dptk.many .Lber2 // if ref is aligned, we can start the calculation |
1052 |
|
;; |
1053 |
|
ld8 r48 = [r48] // if not, we have to load some more |
1054 |
|
ld8 r49 = [r49] // because of the alignment of ld8 |
1055 |
|
ld8 r50 = [r50] |
1056 |
|
ld8 r51 = [r51] |
1057 |
|
ld8 r52 = [r52] |
1058 |
|
ld8 r53 = [r53] |
1059 |
|
ld8 r54 = [r54] |
1060 |
|
ld8 r55 = [r55] |
1061 |
|
(p24) br.cond.dptk.many .Lmode1 |
1062 |
|
(p18) br.cond.dpnt.many .Lmode2 |
1063 |
|
(p26) br.cond.dpnt.many .Lmode3 |
1064 |
|
(p20) br.cond.dpnt.many .Lmode4 |
1065 |
|
(p28) br.cond.dpnt.many .Lmode5 |
1066 |
|
(p22) br.cond.dpnt.many .Lmode6 |
1067 |
|
;; |
1068 |
|
.Lmode7: // this jump piont is not needed, it is for better understandment |
1069 |
|
shrp r40 = r48, r40, 56 // here we do some preprocessing on the data |
1070 |
|
shrp r41 = r49, r41, 56 // this is because of the alignment problem of ref |
1071 |
|
shrp r42 = r50, r42, 56 |
1072 |
|
shrp r43 = r51, r43, 56 |
1073 |
|
shrp r44 = r52, r44, 56 |
1074 |
|
shrp r45 = r53, r45, 56 |
1075 |
|
shrp r46 = r54, r46, 56 |
1076 |
|
shrp r47 = r55, r47, 56 |
1077 |
|
br.cond.sptk.many .Lber2 |
1078 |
|
;; |
1079 |
|
.Lmode6: |
1080 |
|
shrp r40 = r48, r40, 48 |
1081 |
|
shrp r41 = r49, r41, 48 |
1082 |
|
shrp r42 = r50, r42, 48 |
1083 |
|
shrp r43 = r51, r43, 48 |
1084 |
|
shrp r44 = r52, r44, 48 |
1085 |
|
shrp r45 = r53, r45, 48 |
1086 |
|
shrp r46 = r54, r46, 48 |
1087 |
|
shrp r47 = r55, r47, 48 |
1088 |
|
br.cond.sptk.many .Lber2 |
1089 |
|
;; |
1090 |
|
.Lmode5: |
1091 |
|
shrp r40 = r48, r40, 40 |
1092 |
|
shrp r41 = r49, r41, 40 |
1093 |
|
shrp r42 = r50, r42, 40 |
1094 |
|
shrp r43 = r51, r43, 40 |
1095 |
|
shrp r44 = r52, r44, 40 |
1096 |
|
shrp r45 = r53, r45, 40 |
1097 |
|
shrp r46 = r54, r46, 40 |
1098 |
|
shrp r47 = r55, r47, 40 |
1099 |
|
br.cond.sptk.many .Lber2 |
1100 |
|
;; |
1101 |
|
.Lmode4: |
1102 |
|
shrp r40 = r48, r40, 32 |
1103 |
|
shrp r41 = r49, r41, 32 |
1104 |
|
shrp r42 = r50, r42, 32 |
1105 |
|
shrp r43 = r51, r43, 32 |
1106 |
|
shrp r44 = r52, r44, 32 |
1107 |
|
shrp r45 = r53, r45, 32 |
1108 |
|
shrp r46 = r54, r46, 32 |
1109 |
|
shrp r47 = r55, r47, 32 |
1110 |
|
br.cond.sptk.many .Lber2 |
1111 |
|
;; |
1112 |
|
.Lmode3: |
1113 |
|
shrp r40 = r48, r40, 24 |
1114 |
|
shrp r41 = r49, r41, 24 |
1115 |
|
shrp r42 = r50, r42, 24 |
1116 |
|
shrp r43 = r51, r43, 24 |
1117 |
|
shrp r44 = r52, r44, 24 |
1118 |
|
shrp r45 = r53, r45, 24 |
1119 |
|
shrp r46 = r54, r46, 24 |
1120 |
|
shrp r47 = r55, r47, 24 |
1121 |
|
br.cond.sptk.many .Lber2 |
1122 |
|
;; |
1123 |
|
.Lmode2: |
1124 |
|
shrp r40 = r48, r40, 16 |
1125 |
|
shrp r41 = r49, r41, 16 |
1126 |
|
shrp r42 = r50, r42, 16 |
1127 |
|
shrp r43 = r51, r43, 16 |
1128 |
|
shrp r44 = r52, r44, 16 |
1129 |
|
shrp r45 = r53, r45, 16 |
1130 |
|
shrp r46 = r54, r46, 16 |
1131 |
|
shrp r47 = r55, r47, 16 |
1132 |
|
br.cond.sptk.many .Lber2 |
1133 |
|
;; |
1134 |
|
.Lmode1: |
1135 |
|
shrp r40 = r48, r40, 8 |
1136 |
|
shrp r41 = r49, r41, 8 |
1137 |
|
shrp r42 = r50, r42, 8 |
1138 |
|
shrp r43 = r51, r43, 8 |
1139 |
|
shrp r44 = r52, r44, 8 |
1140 |
|
shrp r45 = r53, r45, 8 |
1141 |
|
shrp r46 = r54, r46, 8 |
1142 |
|
shrp r47 = r55, r47, 8 |
1143 |
|
.Lber2: |
1144 |
|
;; |
1145 |
|
psad1 r32 = r32, r40 // we start calculating sad |
1146 |
|
psad1 r33 = r33, r41 // using th psad1 command of IA64 |
1147 |
|
psad1 r34 = r34, r42 |
1148 |
|
psad1 r35 = r35, r43 |
1149 |
|
psad1 r36 = r36, r44 |
1150 |
|
psad1 r37 = r37, r45 |
1151 |
|
psad1 r38 = r38, r46 |
1152 |
|
psad1 r39 = r39, r47 |
1153 |
|
;; |
1154 |
|
add r32 = r32, r33 // then we sum up everything |
1155 |
|
add r33 = r34, r35 |
1156 |
|
add r34 = r36, r37 |
1157 |
|
add r35 = r38, r39 |
1158 |
|
;; |
1159 |
|
add r32 = r32, r33 |
1160 |
|
add r33 = r34, r35 |
1161 |
|
;; |
1162 |
|
add r8 = r32, r33 // and store the result un r8 |
1163 |
|
mov pr = r2, -1 |
1164 |
|
mov ar.pfs = r1 |
1165 |
|
br.ret.sptk.many b0 |
1166 |
|
.endp sad8_ia64# |