efvec.f

网络带宽测试工具

            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  10.0_l_*Log( 2.0_l_ )
      b =  Max( 10.0_l_*a, Log( 0.9_l_*xmax ) )
      ident(m) = 'Exp'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1,nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Exp( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      eps = 1.0_l_
      Do i = 1, it/3
         eps = eps/beta
      End Do
      a =  1.0_l_ - eps
      b =  1.0_l_ + eps
      ident(m) = 'Log'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Log( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep 
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  Sqrt( 0.5_l_ )
      b =  15.0_l_/16.0_l_
      ident(m) = 'Log'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Log( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep 
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  Sqrt( 0.1_l_ )
      b =  0.9_l_
      ident(m) = 'Log10'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Log10( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  16.0_l_
      b =  240.0_l_
      ident(m) = 'Log'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Log( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep 
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  0.0_l_
      b =  pi/4.0_l_
      ident(m) = 'Tan'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Tan( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  pi*0.875_l_
      b =  1.125_l_*pi
      ident(m) = 'Tan'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Tan( x(i) )
            End Do
            Call ddummy( f, l )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  6.0_l_*pi
      b =  a + pi*0.25_l_
      ident(m) = 'Tan'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Tan( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep 
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  6.0_l_*pi
      b =  a + pi*0.25_l_
      ident(m) = 'Cot'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Cot( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  -0.125_l_
      b =   0.125_l_
      ident(m) = 'Asin'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Asin( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  -0.125_l_
      b =   0.125_l_
      ident(m) = 'Acos'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Acos( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep 
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do
! ---------------------------------------------------------------------
      m = m + 1
      If ( m > maxi ) Go To 900 
      a =  0.75_l_
      b =  1.0_l_
      ident(m) = 'Asin'
      xint(m,1) = a
      xint(m,2) = b
      Do l = 1, nn
         n = narr(l)
         nrep = mrep/n
         Call argx( a, b, n, x )
         t1 = wclock()
         Do j = 1, nrep
!$omp parallel do
            Do i = 1, n
               f(i) = Asin( x(i) )
            End Do
            Call ddummy( f, j )
         End Do
         t2 = wclock() - t1

! --- Correct for overhead.
         ovhd = wclock()
         Do j = 1, nrep
            Call ddummy( f, j )
         End Do
         dt = ( t2 - wclock() + ovhd )/nrep
         If ( dt > 0.0_l_ ) Then
            tab(m,l) = ( factor/dt )*n
         Else
            tab(m,l) = 999.999
         End If
      End Do