nb_kernel202_ia32_sse.intel_syntax.s

来自「最著名最快的分子模拟软件」· S 代码 · 共 2,166 行 · 第 1/5 页

	;# zero iteration counters
	mov eax, 0
	mov [esp + nb202nf_nouter], eax
	mov [esp + nb202nf_ninner], eax


	mov esi, [ebp + nb202nf_argkrf]
	mov edi, [ebp + nb202nf_argcrf]
	movss xmm5, [esi]
	movss xmm6, [edi]
	shufps xmm5, xmm5, 0
	shufps xmm6, xmm6, 0
	movaps [esp + nb202nf_krf], xmm5
	movaps [esp + nb202nf_crf], xmm6
	
	;# assume we have at least one i particle - start directly 
	mov   ecx, [ebp + nb202nf_iinr]       ;# ecx = pointer into iinr[] 	
	mov   ebx, [ecx]	    ;# ebx =ii 

	mov   edx, [ebp + nb202nf_charge]
	movss xmm3, [edx + ebx*4]	
	movss xmm4, xmm3	
	movss xmm5, [edx + ebx*4 + 4]	
	mov esi, [ebp + nb202nf_p_facel]
	movss xmm6, [esi]
	mulss  xmm3, xmm3
	mulss  xmm4, xmm5
	mulss  xmm5, xmm5
	mulss  xmm3, xmm6
	mulss  xmm4, xmm6
	mulss  xmm5, xmm6
	shufps xmm3, xmm3, 0
	shufps xmm4, xmm4, 0
	shufps xmm5, xmm5, 0
	movaps [esp + nb202nf_qqOO], xmm3
	movaps [esp + nb202nf_qqOH], xmm4
	movaps [esp + nb202nf_qqHH], xmm5
	

	;# create constant floating-point factors on stack
	mov eax, 0x3f000000     ;# constant 0.5 in IEEE (hex)
	mov [esp + nb202nf_half], eax
	movss xmm1, [esp + nb202nf_half]
	shufps xmm1, xmm1, 0    ;# splat to all elements
	movaps xmm2, xmm1       
	addps  xmm2, xmm2	;# constant 1.0
	movaps xmm3, xmm2
	addps  xmm2, xmm2	;# constant 2.0
	addps  xmm3, xmm2	;# constant 3.0
	movaps [esp + nb202nf_half],  xmm1
	movaps [esp + nb202nf_three],  xmm3

.nb202nf_threadloop:
        mov   esi, [ebp + nb202nf_count]          ;# pointer to sync counter
        mov   eax, [esi]
.nb202nf_spinlock:
        mov   ebx, eax                          ;# ebx=*count=nn0
        add   ebx, 1                           ;# ebx=nn1=nn0+10
        lock
        cmpxchg [esi], ebx                      ;# write nn1 to *counter,
                                                ;# if it hasnt changed.
                                                ;# or reread *counter to eax.
        pause                                   ;# -> better p4 performance
        jnz .nb202nf_spinlock

        ;# if(nn1>nri) nn1=nri
        mov ecx, [esp + nb202nf_nri]
        mov edx, ecx
        sub ecx, ebx
        cmovle ebx, edx                         ;# if(nn1>nri) nn1=nri
        ;# Cleared the spinlock if we got here.
        ;# eax contains nn0, ebx contains nn1.
        mov [esp + nb202nf_n], eax
        mov [esp + nb202nf_nn1], ebx
        sub ebx, eax                            ;# calc number of outer lists
	mov esi, eax				;# copy n to esi
        jg  .nb202nf_outerstart
        jmp .nb202nf_end
	
.nb202nf_outerstart:
	;# ebx contains number of outer iterations
	add ebx, [esp + nb202nf_nouter]
	mov [esp + nb202nf_nouter], ebx

.nb202nf_outer:
	mov   eax, [ebp + nb202nf_shift]      ;# eax = pointer into shift[] 
	mov   ebx, [eax + esi*4]		;# ebx=shift[n] 
	
	lea   ebx, [ebx + ebx*2]    ;# ebx=3*is 
	mov   [esp + nb202nf_is3],ebx    	;# store is3 

	mov   eax, [ebp + nb202nf_shiftvec]   ;# eax = base of shiftvec[] 

	movss xmm0, [eax + ebx*4]
	movss xmm1, [eax + ebx*4 + 4]
	movss xmm2, [eax + ebx*4 + 8] 

	mov   ecx, [ebp + nb202nf_iinr]       ;# ecx = pointer into iinr[] 	
	mov   ebx, [ecx + esi*4]	    ;# ebx =ii 

	lea   ebx, [ebx + ebx*2]	;# ebx = 3*ii=ii3 
	mov   eax, [ebp + nb202nf_pos]    ;# eax = base of pos[]  
	mov   [esp + nb202nf_ii3], ebx	
	
	movaps xmm3, xmm0
	movaps xmm4, xmm1
	movaps xmm5, xmm2
	addss xmm3, [eax + ebx*4]
	addss xmm4, [eax + ebx*4 + 4]
	addss xmm5, [eax + ebx*4 + 8]		
	shufps xmm3, xmm3, 0
	shufps xmm4, xmm4, 0
	shufps xmm5, xmm5, 0
	movaps [esp + nb202nf_ixO], xmm3
	movaps [esp + nb202nf_iyO], xmm4
	movaps [esp + nb202nf_izO], xmm5

	movss xmm3, xmm0
	movss xmm4, xmm1
	movss xmm5, xmm2
	addss xmm0, [eax + ebx*4 + 12]
	addss xmm1, [eax + ebx*4 + 16]
	addss xmm2, [eax + ebx*4 + 20]		
	addss xmm3, [eax + ebx*4 + 24]
	addss xmm4, [eax + ebx*4 + 28]
	addss xmm5, [eax + ebx*4 + 32]		

	shufps xmm0, xmm0, 0
	shufps xmm1, xmm1, 0
	shufps xmm2, xmm2, 0
	shufps xmm3, xmm3, 0
	shufps xmm4, xmm4, 0
	shufps xmm5, xmm5, 0
	movaps [esp + nb202nf_ixH1], xmm0
	movaps [esp + nb202nf_iyH1], xmm1
	movaps [esp + nb202nf_izH1], xmm2
	movaps [esp + nb202nf_ixH2], xmm3
	movaps [esp + nb202nf_iyH2], xmm4
	movaps [esp + nb202nf_izH2], xmm5

	;# clear vctot and i forces 
	xorps xmm4, xmm4
	movaps [esp + nb202nf_vctot], xmm4
	
	mov   eax, [ebp + nb202nf_jindex]
	mov   ecx, [eax + esi*4]	     ;# jindex[n] 
	mov   edx, [eax + esi*4 + 4]	     ;# jindex[n+1] 
	sub   edx, ecx               ;# number of innerloop atoms 

	mov   esi, [ebp + nb202nf_pos]	
	mov   eax, [ebp + nb202nf_jjnr]
	shl   ecx, 2
	add   eax, ecx
	mov   [esp + nb202nf_innerjjnr], eax     ;# pointer to jjnr[nj0] 
	mov   ecx, edx
	sub   edx,  4
	add   ecx, [esp + nb202nf_ninner]
	mov   [esp + nb202nf_ninner], ecx
	add   edx, 0
	mov   [esp + nb202nf_innerk], edx    ;# number of innerloop atoms 
	jge   .nb202nf_unroll_loop
	jmp   .nb202nf_single_check
.nb202nf_unroll_loop:	
	;# quad-unroll innerloop here 
	mov   edx, [esp + nb202nf_innerjjnr]     ;# pointer to jjnr[k] 

	mov   eax, [edx]	
	mov   ebx, [edx + 4] 
	mov   ecx, [edx + 8]
	mov   edx, [edx + 12]         ;# eax-edx=jnr1-4 
	
	add dword ptr [esp + nb202nf_innerjjnr],  16 ;# advance pointer (unrolled 4) 

	mov esi, [ebp + nb202nf_pos]       ;# base of pos[] 

	lea   eax, [eax + eax*2]     ;# replace jnr with j3 
	lea   ebx, [ebx + ebx*2]	
	lea   ecx, [ecx + ecx*2]     ;# replace jnr with j3 
	lea   edx, [edx + edx*2]	
	
	;# move j coordinates to local temp variables 
	movlps xmm2, [esi + eax*4]
	movlps xmm3, [esi + eax*4 + 12]
	movlps xmm4, [esi + eax*4 + 24]

	movlps xmm5, [esi + ebx*4]
	movlps xmm6, [esi + ebx*4 + 12]
	movlps xmm7, [esi + ebx*4 + 24]

	movhps xmm2, [esi + ecx*4]
	movhps xmm3, [esi + ecx*4 + 12]
	movhps xmm4, [esi + ecx*4 + 24]

	movhps xmm5, [esi + edx*4]
	movhps xmm6, [esi + edx*4 + 12]
	movhps xmm7, [esi + edx*4 + 24]

	;# current state: 	
	;# xmm2= jxOa  jyOa  jxOc  jyOc 
	;# xmm3= jxH1a jyH1a jxH1c jyH1c 
	;# xmm4= jxH2a jyH2a jxH2c jyH2c 
	;# xmm5= jxOb  jyOb  jxOd  jyOd 
	;# xmm6= jxH1b jyH1b jxH1d jyH1d 
	;# xmm7= jxH2b jyH2b jxH2d jyH2d 
	
	movaps xmm0, xmm2
	movaps xmm1, xmm3
	unpcklps xmm0, xmm5	;# xmm0= jxOa  jxOb  jyOa  jyOb 
	unpcklps xmm1, xmm6	;# xmm1= jxH1a jxH1b jyH1a jyH1b 
	unpckhps xmm2, xmm5	;# xmm2= jxOc  jxOd  jyOc  jyOd 
	unpckhps xmm3, xmm6	;# xmm3= jxH1c jxH1d jyH1c jyH1d 
	movaps xmm5, xmm4
	movaps   xmm6, xmm0
	unpcklps xmm4, xmm7	;# xmm4= jxH2a jxH2b jyH2a jyH2b 		
	unpckhps xmm5, xmm7	;# xmm5= jxH2c jxH2d jyH2c jyH2d 
	movaps   xmm7, xmm1
	movlhps  xmm0, xmm2	;# xmm0= jxOa  jxOb  jxOc  jxOd 
	movaps [esp + nb202nf_jxO], xmm0
	movhlps  xmm2, xmm6	;# xmm2= jyOa  jyOb  jyOc  jyOd 
	movaps [esp + nb202nf_jyO], xmm2
	movlhps  xmm1, xmm3
	movaps [esp + nb202nf_jxH1], xmm1
	movhlps  xmm3, xmm7
	movaps   xmm6, xmm4
	movaps [esp + nb202nf_jyH1], xmm3
	movlhps  xmm4, xmm5
	movaps [esp + nb202nf_jxH2], xmm4
	movhlps  xmm5, xmm6
	movaps [esp + nb202nf_jyH2], xmm5

	movss  xmm0, [esi + eax*4 + 8]
	movss  xmm1, [esi + eax*4 + 20]
	movss  xmm2, [esi + eax*4 + 32]

	movss  xmm3, [esi + ecx*4 + 8]
	movss  xmm4, [esi + ecx*4 + 20]
	movss  xmm5, [esi + ecx*4 + 32]

	movhps xmm0, [esi + ebx*4 + 4]
	movhps xmm1, [esi + ebx*4 + 16]
	movhps xmm2, [esi + ebx*4 + 28]
	
	movhps xmm3, [esi + edx*4 + 4]
	movhps xmm4, [esi + edx*4 + 16]
	movhps xmm5, [esi + edx*4 + 28]
	
	shufps xmm0, xmm3, 204  ;# constant 11001100
	shufps xmm1, xmm4, 204  ;# constant 11001100
	shufps xmm2, xmm5, 204  ;# constant 11001100
	movaps [esp + nb202nf_jzO],  xmm0
	movaps [esp + nb202nf_jzH1],  xmm1
	movaps [esp + nb202nf_jzH2],  xmm2

	movaps xmm0, [esp + nb202nf_ixO]
	movaps xmm1, [esp + nb202nf_iyO]
	movaps xmm2, [esp + nb202nf_izO]
	movaps xmm3, [esp + nb202nf_ixO]
	movaps xmm4, [esp + nb202nf_iyO]
	movaps xmm5, [esp + nb202nf_izO]
	subps  xmm0, [esp + nb202nf_jxO]
	subps  xmm1, [esp + nb202nf_jyO]
	subps  xmm2, [esp + nb202nf_jzO]
	subps  xmm3, [esp + nb202nf_jxH1]
	subps  xmm4, [esp + nb202nf_jyH1]
	subps  xmm5, [esp + nb202nf_jzH1]
	mulps  xmm0, xmm0
	mulps  xmm1, xmm1
	mulps  xmm2, xmm2
	mulps  xmm3, xmm3
	mulps  xmm4, xmm4
	mulps  xmm5, xmm5
	addps  xmm0, xmm1
	addps  xmm0, xmm2
	addps  xmm3, xmm4
	addps  xmm3, xmm5
	movaps [esp + nb202nf_rsqOO], xmm0
	movaps [esp + nb202nf_rsqOH1], xmm3

	movaps xmm0, [esp + nb202nf_ixO]
	movaps xmm1, [esp + nb202nf_iyO]
	movaps xmm2, [esp + nb202nf_izO]
	movaps xmm3, [esp + nb202nf_ixH1]
	movaps xmm4, [esp + nb202nf_iyH1]
	movaps xmm5, [esp + nb202nf_izH1]
	subps  xmm0, [esp + nb202nf_jxH2]
	subps  xmm1, [esp + nb202nf_jyH2]
	subps  xmm2, [esp + nb202nf_jzH2]
	subps  xmm3, [esp + nb202nf_jxO]
	subps  xmm4, [esp + nb202nf_jyO]
	subps  xmm5, [esp + nb202nf_jzO]
	mulps  xmm0, xmm0
	mulps  xmm1, xmm1
	mulps  xmm2, xmm2
	mulps  xmm3, xmm3
	mulps  xmm4, xmm4
	mulps  xmm5, xmm5
	addps  xmm0, xmm1
	addps  xmm0, xmm2
	addps  xmm3, xmm4
	addps  xmm3, xmm5
	movaps [esp + nb202nf_rsqOH2], xmm0
	movaps [esp + nb202nf_rsqH1O], xmm3

	movaps xmm0, [esp + nb202nf_ixH1]
	movaps xmm1, [esp + nb202nf_iyH1]
	movaps xmm2, [esp + nb202nf_izH1]
	movaps xmm3, [esp + nb202nf_ixH1]
	movaps xmm4, [esp + nb202nf_iyH1]
	movaps xmm5, [esp + nb202nf_izH1]
	subps  xmm0, [esp + nb202nf_jxH1]
	subps  xmm1, [esp + nb202nf_jyH1]
	subps  xmm2, [esp + nb202nf_jzH1]
	subps  xmm3, [esp + nb202nf_jxH2]
	subps  xmm4, [esp + nb202nf_jyH2]
	subps  xmm5, [esp + nb202nf_jzH2]
	mulps  xmm0, xmm0
	mulps  xmm1, xmm1
	mulps  xmm2, xmm2
	mulps  xmm3, xmm3
	mulps  xmm4, xmm4
	mulps  xmm5, xmm5
	addps  xmm0, xmm1
	addps  xmm0, xmm2
	addps  xmm3, xmm4
	addps  xmm3, xmm5
	movaps [esp + nb202nf_rsqH1H1], xmm0
	movaps [esp + nb202nf_rsqH1H2], xmm3

	movaps xmm0, [esp + nb202nf_ixH2]
	movaps xmm1, [esp + nb202nf_iyH2]
	movaps xmm2, [esp + nb202nf_izH2]
	movaps xmm3, [esp + nb202nf_ixH2]
	movaps xmm4, [esp + nb202nf_iyH2]
	movaps xmm5, [esp + nb202nf_izH2]
	subps  xmm0, [esp + nb202nf_jxO]
	subps  xmm1, [esp + nb202nf_jyO]
	subps  xmm2, [esp + nb202nf_jzO]
	subps  xmm3, [esp + nb202nf_jxH1]
	subps  xmm4, [esp + nb202nf_jyH1]
	subps  xmm5, [esp + nb202nf_jzH1]
	mulps  xmm0, xmm0
	mulps  xmm1, xmm1
	mulps  xmm2, xmm2
	mulps  xmm3, xmm3
	mulps  xmm4, xmm4
	mulps  xmm5, xmm5
	addps  xmm0, xmm1
	addps  xmm0, xmm2
	addps  xmm4, xmm3
	addps  xmm4, xmm5
	movaps [esp + nb202nf_rsqH2O], xmm0
	movaps [esp + nb202nf_rsqH2H1], xmm4

	movaps xmm0, [esp + nb202nf_ixH2]
	movaps xmm1, [esp + nb202nf_iyH2]
	movaps xmm2, [esp + nb202nf_izH2]
	subps  xmm0, [esp + nb202nf_jxH2]
	subps  xmm1, [esp + nb202nf_jyH2]
	subps  xmm2, [esp + nb202nf_jzH2]
	mulps xmm0, xmm0
	mulps xmm1, xmm1
	mulps xmm2, xmm2
	addps xmm0, xmm1
	addps xmm0, xmm2
	movaps [esp + nb202nf_rsqH2H2], xmm0
		
	;# start doing invsqrt use rsq values in xmm0, xmm4 
	rsqrtps xmm1, xmm0
	rsqrtps xmm5, xmm4
	movaps  xmm2, xmm1
	movaps  xmm6, xmm5
	mulps   xmm1, xmm1
	mulps   xmm5, xmm5
	movaps  xmm3, [esp + nb202nf_three]
	movaps  xmm7, xmm3
	mulps   xmm1, xmm0
	mulps   xmm5, xmm4
	subps   xmm3, xmm1
	subps   xmm7, xmm5
	mulps   xmm3, xmm2
	mulps   xmm7, xmm6
	mulps   xmm3, [esp + nb202nf_half] ;# rinvH2H2 
	mulps   xmm7, [esp + nb202nf_half] ;# rinvH2H1 
	movaps  [esp + nb202nf_rinvH2H2], xmm3
	movaps  [esp + nb202nf_rinvH2H1], xmm7
	
	rsqrtps xmm1, [esp + nb202nf_rsqOO]
	rsqrtps xmm5, [esp + nb202nf_rsqOH1]
	movaps  xmm2, xmm1
	movaps  xmm6, xmm5
	mulps   xmm1, xmm1
	mulps   xmm5, xmm5
	movaps  xmm3, [esp + nb202nf_three]
	movaps  xmm7, xmm3
	mulps   xmm1, [esp + nb202nf_rsqOO]
	mulps   xmm5, [esp + nb202nf_rsqOH1]
	subps   xmm3, xmm1
	subps   xmm7, xmm5
	mulps   xmm3, xmm2
	mulps   xmm7, xmm6
	mulps   xmm3, [esp + nb202nf_half] 
	mulps   xmm7, [esp + nb202nf_half]
	movaps  [esp + nb202nf_rinvOO], xmm3
	movaps  [esp + nb202nf_rinvOH1], xmm7
	
	rsqrtps xmm1, [esp + nb202nf_rsqOH2]
	rsqrtps xmm5, [esp + nb202nf_rsqH1O]
	movaps  xmm2, xmm1
	movaps  xmm6, xmm5
	mulps   xmm1, xmm1
	mulps   xmm5, xmm5
	movaps  xmm3, [esp + nb202nf_three]
	movaps  xmm7, xmm3
	mulps   xmm1, [esp + nb202nf_rsqOH2]
	mulps   xmm5, [esp + nb202nf_rsqH1O]
	subps   xmm3, xmm1
	subps   xmm7, xmm5
	mulps   xmm3, xmm2
	mulps   xmm7, xmm6
	mulps   xmm3, [esp + nb202nf_half] 
	mulps   xmm7, [esp + nb202nf_half]
	movaps  [esp + nb202nf_rinvOH2], xmm3
	movaps  [esp + nb202nf_rinvH1O], xmm7
	
	rsqrtps xmm1, [esp + nb202nf_rsqH1H1]
	rsqrtps xmm5, [esp + nb202nf_rsqH1H2]
	movaps  xmm2, xmm1
	movaps  xmm6, xmm5
	mulps   x