nb_kernel410_x86_64_sse.s

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

        movaps %xmm3,%xmm6
        mulps  nb410_r(%rsp),%xmm6
        addps  %xmm5,%xmm6

    ## increment vctot (sum in xmm12)
        addps  %xmm5,%xmm12

        ## xmm6=(vcoul+fijC*r)
        subps  %xmm6,%xmm7
        movaps %xmm7,%xmm6

    ## update dvdasum
    addps  nb410_dvdasum(%rsp),%xmm7
    movaps %xmm7,nb410_dvdasum(%rsp)

        ## update j atoms dvdaj
        movhlps %xmm6,%xmm7
        movaps  %xmm6,%xmm5
        movaps  %xmm7,%xmm4
        shufps $0x1,%xmm5,%xmm5
        shufps $0x1,%xmm4,%xmm4

        ## xmm6=dvdaj1 xmm5=dvdaj2 xmm7=dvdaj3 xmm4=dvdaj4
        addss  (%rsi,%rax,4),%xmm6
        addss  (%rsi,%rbx,4),%xmm5
        addss  (%rsi,%rcx,4),%xmm7
        addss  (%rsi,%rdx,4),%xmm4
        movss  %xmm6,(%rsi,%rax,4)
        movss  %xmm5,(%rsi,%rbx,4)
        movss  %xmm7,(%rsi,%rcx,4)
        movss  %xmm4,(%rsi,%rdx,4)

    subps  %xmm3,%xmm9
    mulps  %xmm0,%xmm9 ## fscal

    movaps  %xmm9,%xmm10
    movaps  %xmm9,%xmm11

    mulps   nb410_dx(%rsp),%xmm9
    mulps   nb410_dy(%rsp),%xmm10
    mulps   nb410_dz(%rsp),%xmm11

        ## accumulate i forces
    addps %xmm9,%xmm13
    addps %xmm10,%xmm14
    addps %xmm11,%xmm15

        movq nb410_faction(%rbp),%rsi
        ## the fj's - start by accumulating x & y forces from memory 
        movlps (%rsi,%r8,4),%xmm0 ## x1 y1 - -
        movlps (%rsi,%r10,4),%xmm1 ## x3 y3 - -
        movhps (%rsi,%r9,4),%xmm0 ## x1 y1 x2 y2
        movhps (%rsi,%r11,4),%xmm1 ## x3 y3 x4 y4

    movaps %xmm9,%xmm8
    unpcklps %xmm10,%xmm9 ## x1 y1 x2 y2
    unpckhps %xmm10,%xmm8 ## x3 y3 x4 y4

    ## update fjx and fjy
        addps  %xmm9,%xmm0
        addps  %xmm8,%xmm1

        movlps %xmm0,(%rsi,%r8,4)
        movlps %xmm1,(%rsi,%r10,4)
        movhps %xmm0,(%rsi,%r9,4)
        movhps %xmm1,(%rsi,%r11,4)

    ## xmm11: fjz1 fjz2 fjz3 fjz4
    pshufd $1,%xmm11,%xmm10 ## fjz2 - - -
    movhlps %xmm11,%xmm9     ## fjz3 - - -
    pshufd $3,%xmm11,%xmm8  ## fjz4 - - -

        addss  8(%rsi,%r8,4),%xmm11
        addss  8(%rsi,%r9,4),%xmm10
        addss  8(%rsi,%r10,4),%xmm9
        addss  8(%rsi,%r11,4),%xmm8
        movss  %xmm11,8(%rsi,%r8,4)
        movss  %xmm10,8(%rsi,%r9,4)
        movss  %xmm9,8(%rsi,%r10,4)
        movss  %xmm8,8(%rsi,%r11,4)

        ## should we do one more iteration? 
        subl $4,nb410_innerk(%rsp)
        jl    _nb_kernel410_x86_64_sse.nb410_finish_inner
        jmp   _nb_kernel410_x86_64_sse.nb410_unroll_loop
_nb_kernel410_x86_64_sse.nb410_finish_inner: 
        ## check if at least two particles remain 
        addl $4,nb410_innerk(%rsp)
        movl  nb410_innerk(%rsp),%edx
        andl  $2,%edx
        jnz   _nb_kernel410_x86_64_sse.nb410_dopair
        jmp   _nb_kernel410_x86_64_sse.nb410_checksingle
_nb_kernel410_x86_64_sse.nb410_dopair: 
        movq  nb410_innerjjnr(%rsp),%rcx

        movl  (%rcx),%eax
        movl  4(%rcx),%ebx
        addq $8,nb410_innerjjnr(%rsp)

        ## load isaj
        movq nb410_invsqrta(%rbp),%rsi
        movss (%rsi,%rax,4),%xmm2
        movss (%rsi,%rbx,4),%xmm6
    unpcklps %xmm6,%xmm2

        mulps  nb410_isai(%rsp),%xmm2

        movaps %xmm2,nb410_isaprod(%rsp)
        movaps %xmm2,%xmm1
        mulps nb410_gbtsc(%rsp),%xmm1
        movaps %xmm1,nb410_gbscale(%rsp)

    mulps nb410_iq(%rsp),%xmm2
        movq nb410_charge(%rbp),%rsi     ## base of charge[] 
        movss (%rsi,%rax,4),%xmm3
        movss (%rsi,%rbx,4),%xmm6
    unpcklps %xmm6,%xmm3


        mulps %xmm2,%xmm3
        movaps %xmm3,nb410_qq(%rsp)

     ## vdw parameters
        movq nb410_type(%rbp),%rsi
        movl (%rsi,%rax,4),%r12d
        movl (%rsi,%rbx,4),%r13d
        shll %r12d
        shll %r13d
    movl nb410_ntia(%rsp),%edi
        addl %edi,%r12d
        addl %edi,%r13d

        movq nb410_vdwparam(%rbp),%rsi
        movlps (%rsi,%r12,4),%xmm3
        movhps (%rsi,%r13,4),%xmm3

    xorps %xmm7,%xmm7
        movaps %xmm3,%xmm0
        shufps $136,%xmm7,%xmm0 ## 10001000
        shufps $221,%xmm7,%xmm3 ## 11011101

    movaps %xmm0,nb410_c6(%rsp)
    movaps %xmm3,nb410_c12(%rsp)

        movq nb410_pos(%rbp),%rsi        ## base of pos[] 

        lea  (%rax,%rax,2),%r8     ## j3
        lea  (%rbx,%rbx,2),%r9

        ## move four coordinates to xmm0-xmm2   
        movlps (%rsi,%r8,4),%xmm4       ## x1 y1 - - 
        movlps (%rsi,%r9,4),%xmm5       ## x2 y2 - - 

        movss 8(%rsi,%r8,4),%xmm6       ## z1 - - - 
        movss 8(%rsi,%r9,4),%xmm7       ## z2 - - - 

    unpcklps %xmm5,%xmm4 ## x1 x2 y1 y2
    movhlps  %xmm4,%xmm5 ## y1 y2 -  -
    unpcklps %xmm7,%xmm6 ## z1 z2 -  -

        ## calc dr 
        subps nb410_ix(%rsp),%xmm4
        subps nb410_iy(%rsp),%xmm5
        subps nb410_iz(%rsp),%xmm6

        ## store dr 
        movaps %xmm4,nb410_dx(%rsp)
        movaps %xmm5,nb410_dy(%rsp)
        movaps %xmm6,nb410_dz(%rsp)

        ## square it 
        mulps %xmm4,%xmm4
        mulps %xmm5,%xmm5
        mulps %xmm6,%xmm6
        addps %xmm5,%xmm4
        addps %xmm6,%xmm4
        ## rsq in xmm4 

        rsqrtps %xmm4,%xmm5
        ## lookup seed in xmm5 
        movaps %xmm5,%xmm2
        mulps %xmm5,%xmm5
        movaps nb410_three(%rsp),%xmm1
        mulps %xmm4,%xmm5       ## rsq*lu*lu                    
        movaps nb410_half(%rsp),%xmm0
        subps %xmm5,%xmm1       ## 30-rsq*lu*lu 
        mulps %xmm2,%xmm1
        mulps %xmm1,%xmm0       ## xmm0=rinv 
        mulps %xmm0,%xmm4       ## xmm4=r
        movaps %xmm4,nb410_r(%rsp)
        mulps nb410_gbscale(%rsp),%xmm4

    ## truncate and convert to integers
    cvttps2dq %xmm4,%xmm5

    ## convert back to float
    cvtdq2ps  %xmm5,%xmm6

    ## multiply by 4
    pslld   $2,%xmm5

    ## move to integer registers
    movd    %xmm5,%r12d
    pshufd $1,%xmm5,%xmm5
    movd    %xmm5,%r13d

    ## calculate eps
    subps     %xmm6,%xmm4
    movaps    %xmm4,%xmm1 ##eps

        movq nb410_GBtab(%rbp),%rsi

    movaps %xmm0,%xmm9 ## rinv
    mulps  %xmm9,%xmm9 ## rinvsq
    movaps %xmm9,%xmm10 ## rinvsq
    mulps  %xmm10,%xmm10 ## rinv4
    mulps  %xmm9,%xmm10 ## rinv6
    movaps %xmm10,%xmm11
    mulps  %xmm11,%xmm11 ## rinv12

    ## load table data
        movlps (%rsi,%r12,4),%xmm4  ## Y1 F1
        movlps (%rsi,%r13,4),%xmm5  ## Y2 F2
    unpcklps %xmm5,%xmm4        ## Y1 Y2 F1 F2
    movhlps  %xmm4,%xmm5        ## F1 F2

    mulps  nb410_c6(%rsp),%xmm10      ## vvdw6=c6*rinv6
        mulps  nb410_c12(%rsp),%xmm11     ## vvdw12=c12*rinv12     

        movaps %xmm11,%xmm9
        subps  %xmm10,%xmm11    ## Vvdw=Vvdw12-Vvdw6

    ## add potential to vvdwtot 
        addps  nb410_Vvdwtot(%rsp),%xmm11
    movlps %xmm11,nb410_Vvdwtot(%rsp)

        movlps 8(%rsi,%r12,4),%xmm6      ## G1 H1
        movlps 8(%rsi,%r13,4),%xmm7      ## G2 H2
    unpcklps %xmm7,%xmm6             ## G1 G2
    movhlps  %xmm6,%xmm7             ## H1 H2
    ## table data ready in xmm4-xmm7

    mulps  %xmm1,%xmm7  ## Heps
        mulps  %xmm1,%xmm6      ## xmm6=Geps 
        mulps  %xmm1,%xmm7      ## Heps2 
        addps  %xmm6,%xmm5
        addps  %xmm7,%xmm5      ## xmm5=Fp      
        addps  %xmm7,%xmm7      ## two*Heps2 
        movaps nb410_qq(%rsp),%xmm3

        addps  %xmm6,%xmm7
        addps  %xmm5,%xmm7 ## xmm7=FF 
        mulps  %xmm1,%xmm5 ## xmm5=eps*Fp 
        addps  %xmm4,%xmm5 ## xmm5=VV 
        mulps  %xmm3,%xmm5 ## vcoul=qq*VV  
        mulps  %xmm7,%xmm3 ## fijC=FF*qq 
        ## at this point xmm5 contains vcoul and xmm3 fijC

    ## LJ forces
    mulps  nb410_six(%rsp),%xmm10
    mulps  nb410_twelve(%rsp),%xmm9
    subps  %xmm10,%xmm9
    mulps  %xmm0,%xmm9 ## (12*vnb12-6*vnb6)*rinv

    ## zero upper part of vcoul 
    xorps %xmm2,%xmm2
    movlhps %xmm2,%xmm5

        movq nb410_dvda(%rbp),%rsi

        ## Calculate dVda
        xorps  %xmm7,%xmm7
        mulps nb410_gbscale(%rsp),%xmm3
        movaps %xmm3,%xmm6
        mulps  nb410_r(%rsp),%xmm6
        addps  %xmm5,%xmm6

    xorps  %xmm4,%xmm4
    ## increment vctot (sum in xmm12)
        addps  %xmm5,%xmm12

        ## xmm6=(vcoul+fijC*r)
        subps  %xmm6,%xmm7
        movaps %xmm7,%xmm6

    ## zero upper half of dvda
    movlhps %xmm4,%xmm7

    ## update dvdasum
    addps  nb410_dvdasum(%rsp),%xmm7
    movaps %xmm7,nb410_dvdasum(%rsp)

        ## update j atoms dvdaj
        movaps  %xmm6,%xmm5
        shufps $0x1,%xmm5,%xmm5

        ## xmm6=dvdaj1 xmm5=dvdaj2 xmm7=dvdaj3 xmm4=dvdaj4
        addss  (%rsi,%rax,4),%xmm6
        addss  (%rsi,%rbx,4),%xmm5
        movss  %xmm6,(%rsi,%rax,4)
        movss  %xmm5,(%rsi,%rbx,4)

    xorps %xmm7,%xmm7

    subps  %xmm3,%xmm9
    mulps  %xmm0,%xmm9 ## fscal

    movaps  %xmm9,%xmm10
    movaps  %xmm9,%xmm11

    mulps   nb410_dx(%rsp),%xmm9
    mulps   nb410_dy(%rsp),%xmm10
    mulps   nb410_dz(%rsp),%xmm11

    movlhps  %xmm7,%xmm9
    movlhps  %xmm7,%xmm10
    movlhps  %xmm7,%xmm11

        ## accumulate i forces
    addps %xmm9,%xmm13
    addps %xmm10,%xmm14
    addps %xmm11,%xmm15

        movq nb410_faction(%rbp),%rsi
        ## the fj's - start by accumulating x & y forces from memory 
        movlps (%rsi,%r8,4),%xmm0 ## x1 y1 - -
        movhps (%rsi,%r9,4),%xmm0 ## x1 y1 x2 y2

    unpcklps %xmm10,%xmm9 ## x1 y1 x2 y2
    addps    %xmm9,%xmm0

        movlps %xmm0,(%rsi,%r8,4)
        movhps %xmm0,(%rsi,%r9,4)

    ## z forces
    pshufd $1,%xmm11,%xmm8
    addss  8(%rsi,%r8,4),%xmm11
    addss  8(%rsi,%r9,4),%xmm8
    movss  %xmm11,8(%rsi,%r8,4)
    movss  %xmm8,8(%rsi,%r9,4)

_nb_kernel410_x86_64_sse.nb410_checksingle:     
        movl  nb410_innerk(%rsp),%edx
        andl  $1,%edx
        jnz    _nb_kernel410_x86_64_sse.nb410_dosingle
        jmp    _nb_kernel410_x86_64_sse.nb410_updateouterdata
_nb_kernel410_x86_64_sse.nb410_dosingle: 
        movq nb410_charge(%rbp),%rsi
        movq nb410_invsqrta(%rbp),%rdx
        movq nb410_pos(%rbp),%rdi
        movq  nb410_innerjjnr(%rsp),%rcx
        movl  (%rcx),%eax

        ## load isaj
        movq nb410_invsqrta(%rbp),%rsi
        movss (%rsi,%rax,4),%xmm3
        movaps nb410_isai(%rsp),%xmm2
        mulss  %xmm3,%xmm2

        movss %xmm2,nb410_isaprod(%rsp)
        movaps %xmm2,%xmm1
        mulss nb410_gbtsc(%rsp),%xmm1
        movss %xmm1,nb410_gbscale(%rsp)

    mulss nb410_iq(%rsp),%xmm2
        movq nb410_charge(%rbp),%rsi     ## base of charge[] 

        movss (%rsi,%rax,4),%xmm3
        mulss %xmm2,%xmm3
        movss %xmm3,nb410_qq(%rsp)

    ## vdw parameters
        movq nb410_type(%rbp),%rsi
        movl (%rsi,%rax,4),%r12d
        shll %r12d
    movl nb410_ntia(%rsp),%edi
        addl %edi,%r12d

        movq nb410_vdwparam(%rbp),%rsi
        movss (%rsi,%r12,4),%xmm0
        movss 4(%rsi,%r12,4),%xmm3
    movaps %xmm0,nb410_c6(%rsp)
    movaps %xmm3,nb410_c12(%rsp)

        movq nb410_pos(%rbp),%rsi        ## base of pos[] 

        lea  (%rax,%rax,2),%r8     ## jnr 

        ## move four coordinates to xmm0-xmm2   
        movss (%rsi,%r8,4),%xmm4
        movss 4(%rsi,%r8,4),%xmm5
        movss 8(%rsi,%r8,4),%xmm6

        ## calc dr 
        subss nb410_ix(%rsp),%xmm4
        subss nb410_iy(%rsp),%xmm5
        subss nb410_iz(%rsp),%xmm6

        ## store dr 
        movaps %xmm4,nb410_dx(%rsp)
        movaps %xmm5,nb410_dy(%rsp)
        movaps %xmm6,nb410_dz(%rsp)

        ## square it 
        mulss %xmm4,%xmm4
        mulss %xmm5,%xmm5
        mulss %xmm6,%xmm6
        addss %xmm5,%xmm4
        addss %xmm6,%xmm4
        ## rsq in xmm4 

        rsqrtss %xmm4,%xmm5
        ## lookup seed in xmm5 
        movaps %xmm5,%xmm2
        mulss %xmm5,%xmm5
        movaps nb410_three(%rsp),%xmm1
        mulss %xmm4,%xmm5       ## rsq*lu*lu                    
        movaps nb410_half(%rsp),%xmm0
        subss %xmm5,%xmm1       ## 30-rsq*lu*lu 
        mulss %xmm2,%xmm1
        mulss %xmm1,%xmm0       ## xmm0=rinv 
        mulss %xmm0,%xmm4       ## xmm4=r
        movaps %xmm4,nb410_r(%rsp)
        mulss nb410_gbscale(%rsp),%xmm4

    ## truncate and convert to integers
    cvttss2si %xmm4,%r12d

    ## convert back to float
    cvtsi2ss  %r12d,%xmm6

    ## multiply by 4
    shll  $2,%r12d

    ## calculate eps
    subss     %xmm6,%xmm4
    movaps    %xmm4,%xmm1 ##eps

        movq nb410_GBtab(%rbp),%rsi

    movaps %xmm0,%xmm9 ## rinv
    mulss  %xmm9,%xmm9 ## rinvsq
    movaps %xmm9,%xmm10 ## rinvsq
    mulss  %xmm10,%xmm10 ## rinv4
    mulss  %xmm9,%xmm10 ## rinv6
    movaps %xmm10,%xmm11
    mulss  %xmm11,%xmm11 ## rinv12

    ## load table data
        movss (%rsi,%r12,4),%xmm4
        movss 4(%rsi,%r12,4),%xmm5
        movss 8(%rsi,%r12,4),%xmm6
        movss 12(%rsi,%r12,4),%xmm7
    ## table data ready in xmm4-xmm7

    mulss  nb410_c6(%rsp),%xmm10      ## vvdw6=c6*rinv6
        mulss  nb410_c12(%rsp),%xmm11     ## vvdw12=c12*rinv12     

        movaps %xmm11,%xmm9
        subss  %xmm10,%xmm11    ## Vvdw=Vvdw12-Vvdw6

    ## add potential to vvdwtot 
        addss  nb410_Vvdwtot(%rsp),%xmm11
    movss %xmm11,nb410_Vvdwtot(%rsp)

    mulss  %xmm1,%xmm7  ## Heps
        mulss  %xmm1,%xmm6      ## xmm6=Geps 
        mulss  %xmm1,%xmm7      ## Heps2 
        addss  %xmm6,%xmm5
        addss  %xmm7,%xmm5      ## xmm5=Fp      
        addss  %xmm7,%xmm7      ## two*Heps2 
        movss  nb410_qq(%rsp),%xmm3
        addss  %xmm6,%xmm7
        addss  %xmm5,%xmm7 ## xmm7=FF 
        mulss  %xmm1,%xmm5 ## xmm5=eps*Fp 
        addss  %xmm4,%xmm5 ## xmm5=VV 
        mulss  %xmm3,%xmm5 ## vcoul=qq*VV  
        mulss  %xmm7,%xmm3 ## fijC=FF*qq 
        ## at this point xmm5 contains vcoul and xmm3 fijC

    ## LJ forces
    mulss  nb410_six(%rsp),%xmm10
    mulss  nb410_twelve(%rsp),%xmm9
    subss  %xmm10,%xmm9
    mulss  %xmm0,%xmm9 ## (12*vnb12-6*vnb6)*rinv

        movq nb410_dvda(%rbp),%rsi

        ## Calculate dVda
        xorps  %xmm7,%xmm7
        mulss nb410_gbscale(%rsp),%xmm3
        movaps %xmm3,%xmm6
        mulss  nb410_r(%rsp),%xmm6
        addss  %xmm5,%xmm6

    ## increment vctot (sum in xmm12)
        addss  %xmm5,%xmm12