← Back to branch summary

~ubuntu-branches/ubuntu/vivid/atlas/vivid

« back to all changes in this revision

Viewing changes to tune/blas/ger/R1CASES/ATL_dgerk_8x1_Cw.c

  • Committer: Package Import Robot
  • Author(s): Sébastien Villemot
  • Date: 2013-06-11 15:58:16 UTC
  • mfrom: (1.1.3 upstream)
  • mto: (2.2.21 experimental)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: package-import@ubuntu.com-20130611155816-b72z8f621tuhbzn0
Tags: upstream-3.10.1
Import upstream version 3.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tune/blas/ger/R1CASES/ATL_dgerk_8x1_Cw.c
 
1
 
 
2
#include "atlas_asm.h"
 
3
#ifndef ATL_GAS_x8664
 
4
   #error "This kernel requires x86-64 assembly!"
 
5
#endif
 
6
/*
 
7
 * Register usage
 
8
 */
 
9
#define M       %rdi  /* already in */
 
10
#define N       %rsi  /* already in */
 
11
#define itmp    %rax  /* tmp used for byte load/use pipeline */
 
12
#define itb     %al
 
13
#define pX      %rdx  /* already in */
 
14
#define pA0     %rcx  /* 8(%rsp) */
 
15
#define Ab      %cl
 
16
#define II      %rbx  /* loaded in loop */
 
17
#define pY      %rbp  /* moved from r9 */
 
18
#define incAn   %r8   /* 16(%rsp) */
 
19
#define mask    %r9
 
20
#define Mr      %r10
 
21
#define mask7   %r11
 
22
#define incX    %r12
 
23
 
 
24
#define y0      %xmm0
 
25
#define x0      %xmm1
 
26
 
 
27
/*
 
28
void ATL_UGERK
 
29
          %rdi        %rsi              %xmm0           %rdx
 
30
   (ATL_CINT M, ATL_CINT N, const TYPE alpha0, const TYPE *X,
 
31
             %rcx            %r8            %r9  8(%rsp)  16(%rsp)
 
32
    ATL_CINT incX, const TYPE *Y, ATL_CINT incY, TYPE *A, ATL_CINT lda)
 
33
 
 
34
*/
 
35
.text
 
36
.global ATL_asmdecor(ATL_UGERK)
 
37
ALIGN64
 
38
ATL_asmdecor(ATL_UGERK):
 
39
 
 
40
/*
 
41
 * Save callee-saved iregs
 
42
 */
 
43
   movq %rbp, -8(%rsp)
 
44
   movq %rbx, -16(%rsp)
 
45
   movq %r12, -24(%rsp)
 
46
#if 0
 
47
   movq %r13, -32(%rsp)
 
48
   movq %r14, -40(%rsp)
 
49
   movq %r15, -48(%rsp)
 
50
#endif
 
51
/*
 
52
 * Load & compute all integer variables
 
53
 */
 
54
   movq 8(%rsp), pA0
 
55
   movq %r8, pY
 
56
   movslq 16(%rsp), incAn       /* incAn = lda */
 
57
   sub  M, incAn                /* incAn = lda - M */
 
58
   shl  $3, incAn               /* incAn = (lda-M)*sizeof */
 
59
   movq $0x3F, mask
 
60
   movq $0x7, mask7
 
61
   not  mask7
 
62
   mov M, incX                  /* incX = M */
 
63
   shl $3, incX                 /* incX = M*sizeof */
 
64
 
 
65
   lea (pY, N, 8), pY           /* pY += N */
 
66
   neg N                        /* N = -N */
 
67
/*
 
68
 * Start N-loop
 
69
 */
 
70
   NLOOP:
 
71
      movb (pA0), itb           /* forced fetch of pA0 */
 
72
      movb itb, (pA0)           /* force cache write coherence message */
 
73
 
 
74
      movddup (pY,N,8), y0      /* y0 = {y0, y0} */
 
75
      mov M, II
 
76
 
 
77
/*
 
78
 *    Align data on CL boundary
 
79
 */
 
80
      test mask, pA0            /* if (pA0 & 0x3F) --> is 64-byte aligned */
 
81
      jz CLALIGNED              /* start aligned loop */
 
82
      LOOPALIGNCL:              /* loop until aligned or out of ops */
 
83
         movsd (pX), x0         /* x0 = {xx, x0} */
 
84
         mulsd y0, x0           /* x0 = {xx, x0*y0} */
 
85
         addsd (pA0), x0        /* x0 = {xx, a00+x0*y0} */
 
86
         movsd x0, (pA0)
 
87
         add $8, pA0
 
88
         add $8, pX
 
89
         sub       $1, II
 
90
         jz MLOOPDONE           /* finish MLOOP if out of M */
 
91
      test mask, pA0            /* if (pA0 & 0x3F) --> is 64-byte aligned */
 
92
      jnz LOOPALIGNCL           /* continue until aligned */
 
93
 
 
94
CLALIGNED:
 
95
      mov II, Mr                /* Mr = remaining iterations */
 
96
      and mask7, II             /* II = ((remaining iter)/8)*8 */
 
97
      jz  ROLLED_DO_MR          /* if nothing left, goto cleanup loop */
 
98
      sub II, Mr                /* Mr = # of iter left after II (mul8) done */
 
99
 
 
100
      sub $8, II                /* stop 1 iter early; if not enough its left */
 
101
      jbe ROLLED_ADD8           /* handle everything in rolled loop */
 
102
 
 
103
/*
 
104
 *    This loop starts at a 64-byte cache line boundary
 
105
 */
 
106
      movapd (pX), x0           /* x0 = {x1, x0}, pipelined out of loop */
 
107
      MLOOP:
 
108
         movb 64(pA0), itb      /* forced fetch of pA0 */
 
109
         movb itb, 64(pA0)      /* force cache write coherence message */
 
110
         mulpd y0, x0           /* x0 = {x1*y0, x0*y0} */
 
111
         addpd (pA0), x0        /* x0 = {a10+x1*y0, a00+x0*y0} */
 
112
         movapd x0, (pA0)
 
113
 
 
114
         movapd 16(pX),x0       /* x0 = {x1, x0} */
 
115
         mulpd y0, x0           /* x0 = {x1*y0, x0*y0} */
 
116
         addpd 16(pA0), x0      /* x0 = {a10+x1*y0, a00+x0*y0} */
 
117
         movapd x0, 16(pA0)
 
118
 
 
119
         movapd 32(pX),x0       /* x0 = {x1, x0} */
 
120
         mulpd y0, x0           /* x0 = {x1*y0, x0*y0} */
 
121
         addpd 32(pA0), x0        /* x0 = {a10+x1*y0, a00+x0*y0} */
 
122
         movapd x0, 32(pA0)
 
123
 
 
124
         movapd 48(pX),x0       /* x0 = {x1, x0} */
 
125
         add    $64, pX
 
126
         mulpd y0, x0           /* x0 = {x1*y0, x0*y0} */
 
127
         addpd 48(pA0), x0      /* x0 = {a10+x1*y0, a00+x0*y0} */
 
128
         movapd x0, 48(pA0)
 
129
 
 
130
         movapd (pX),x0 /* x0 = {x1, x0}, SW pipelined */
 
131
         add    $64, pA0
 
132
      sub       $8, II
 
133
      jnz MLOOP
 
134
/*
 
135
 *    Drain preloading pipe
 
136
 */
 
137
      mulpd y0, x0           /* x0 = {x1*y0, x0*y0} */
 
138
      addpd (pA0), x0        /* x0 = {a10+x1*y0, a00+x0*y0} */
 
139
      movapd x0, (pA0)
 
140
 
 
141
      movapd 16(pX),x0          /* x0 = {x1, x0} */
 
142
      mulpd y0, x0              /* x0 = {x1*y0, x0*y0} */
 
143
      addpd 16(pA0), x0         /* x0 = {a10+x1*y0, a00+x0*y0} */
 
144
      movapd x0, 16(pA0)
 
145
 
 
146
      movapd 32(pX),x0         /* x0 = {x1, x0} */
 
147
      mulpd y0, x0              /* x0 = {x1*y0, x0*y0} */
 
148
      addpd 32(pA0), x0         /* x0 = {a10+x1*y0, a00+x0*y0} */
 
149
      movapd x0, 32(pA0)
 
150
 
 
151
      movapd 48(pX),x0          /* x0 = {x1, x0} */
 
152
      mulpd y0, x0              /* x0 = {x1*y0, x0*y0} */
 
153
      addpd 48(pA0), x0         /* x0 = {a10+x1*y0, a00+x0*y0} */
 
154
      movapd x0, 48(pA0)
 
155
         add $64, pX
 
156
         add $64, pA0
 
157
      test Mr, Mr
 
158
      jnz  ROLLED_DO_MR
 
159
 
 
160
MLOOPDONE:
 
161
      sub incX, pX
 
162
      add incAn, pA0
 
163
   add $1, N
 
164
   jnz NLOOP
 
165
 
 
166
/*
 
167
 * EPILOGUE: restore registers and return
 
168
 */
 
169
   movq -8(%rsp), %rbp
 
170
   movq -16(%rsp), %rbx
 
171
   movq -24(%rsp), %r12
 
172
#if 0
 
173
   movq %r13, -32(%rsp), %r13
 
174
   movq %r14, -40(%rsp), %r14
 
175
   movq %r15, -48(%rsp), %r15
 
176
#endif
 
177
   ret
 
178
 
 
179
ROLLED_ADD8:
 
180
   lea 8(II, Mr), II
 
181
   jmp MLOOP_ROLLED
 
182
ROLLED_DO_MR:
 
183
   mov Mr, II
 
184
MLOOP_ROLLED:
 
185
   movsd (pX), x0       /* x0 = {xx, x0} */
 
186
   mulsd y0, x0         /* x0 = {xx, x0*y0} */
 
187
   addsd (pA0), x0      /* x0 = {xx, a00+x0*y0} */
 
188
   movsd x0, (pA0)
 
189
   add $8, pX
 
190
   add $8, pA0          /* pA0++ */
 
191
sub  $1, II
 
192
jnz MLOOP_ROLLED
 
193
jmp MLOOPDONE