Performancebetrachtungen Fortran - C#

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

program matrix
	implicit none
   	real(8), allocatable 		:: a(:,:), b(:,:), c(:,:)
	integer  					:: N = 1000, i
   	real     					:: t0, t1

	allocate( a(N,N), b(N,N), c(N,N) )
   	call random_seed()
   	call random_number(a)
   	call random_number(b)

	call cpu_time(t0)
	do i = 1, 5
   		c = matmul(a,b)
   	end do
   	call cpu_time(t1)
   	write(*,'(a, f10.3)') ' Time for matmul        = ', (t1 - t0) / 5
end program matrix

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:

program monte_carlo_integration
!
!       peform an N dimensional integration of exp(-t**2/2)
!       over the square [0,1] x [0,1] x ... x [0,1]
!       for N dimensions using a Monte Carlo scheme.
!
!
!=========================================================================
!
!  This code is part of the Quetzal Computational Associates Fortran 90
!  Benchmark Suite.
!
!  Copyright (c) 1994 by Quetzal Computational Associates.
!
!  Permission to copy and use without fee all or part of the
!  publications or computer codes in this suite is granted provided 
!  that copies are not made or distributed for direct commercial
!  advantage, this copyright notice and the title of the codes
!  or publications and the fact that they originated in this
!  benchmark suite appear, and notice is given that copying is
!  by permission of Quetzal Computational Associates.  For
!  publications that have been published in journals, the name
!  of the publication and date should appear.  To copy otherwise,
!  or to republish, requires a fee and/or specific permission.
!  Authors of codes in this benchmark suite are exempt from the terms of
!  this copyright notice for their codes only.  Address any
!  questions about this copyright notice to:
!
!         John K. Prentice
!         Quetzal Computational Associates
!         3200 Carlisle N.E.
!         Albuquerque, NM   87110-1664
!         USA
!
!         Phone:  505-889-4543
!         Fax:    505-889-4598
!         E-mail: [EMAIL]quetzal@aip.org[/EMAIL]
!
!=========================================================================
!
    implicit none
    integer, parameter :: problem_dimension = 10 
    integer, parameter :: number_of_trys = 6 
!
    integer :: k, number_of_integration_points
    real :: integral, exact_answer
    real, dimension(:,:), allocatable :: integration_points 
    real, dimension(:), allocatable :: argument
    real :: exact_answer_in_1d = 0.85562439
    integer, dimension(number_of_trys) :: try_size 
    
    real     					:: t0, t1
!
    data try_size/9000, 100, 60000, 423, 100000, 2533/ 
    
    call cpu_time(t0)
    
!
!       loop over different trys
!
    do k = 1, number_of_trys 
      number_of_integration_points = try_size(k) 
!
!       allocate memory 
!
      allocate (integration_points(number_of_integration_points,problem_dimension))
      allocate (argument(number_of_integration_points))
!
!       randomly calculate integration points
!
      call gleich
!
!        do Monte Carlo integration
!
      argument = sum(0.5*integration_points**2,dim=2) 
      integral = sum(exp(-argument)) / real(number_of_integration_points)
!
      exact_answer = exact_answer_in_1d**problem_dimension 
      print *, ' ' 
      print *, 'n = ', problem_dimension, ' number of points = ', &
     &      number_of_integration_points 
      print *, 'exact answer       = ', exact_answer 
      print *, 'Monte Carlo answer = ', integral 
!
      deallocate (integration_points)
      deallocate (argument)
!
    end do 
    
    call cpu_time(t1)
    write(*,'(a, f10.3)') ' Time for montecarlo        = ', t1 - t0
!
contains
!
    subroutine gleich
!
!        this routine by t. t. warnock, cray research analyist at lanl
!        F77 version written about 1980
!
!
    implicit none
!
    real, dimension(number_of_integration_points,problem_dimension) :: bottom, top, radish_value
    integer, dimension(number_of_integration_points,problem_dimension) :: radix_value, spin_value, &
&                                                                         quo, errors
    integer :: kount
!
    integer, dimension(25) :: radix, spin 
    real, dimension(25) :: radish 
!
    data radix/2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,&
&              61, 67, 71, 73, 79, 83, 89, 97/ 
    data radish/2., 3., 5., 7., 11., 13., 17., 19., 23., 29., 31., 37., 41.,  &
&               43., 47., 53., 59., 61., 67., 71., 73., 79., 83., 89., 97./ 
    data spin/1, 2, 1, 5, 3, 8, 2, 7, 18, 11, 18, 3, 17, 24, 40, 15, 40, 49,  &
&             12, 30, 40, 70, 9, 39, 82/ 
!
    top = 0. 
    bottom = 1. 
    do kount = 1,number_of_integration_points
        radish_value(kount,1:problem_dimension) = radish(1:problem_dimension)
        spin_value(kount,1:problem_dimension) = spin(1:problem_dimension)
        radix_value(kount,1:problem_dimension) = radix(1:problem_dimension)
        quo(kount,1:problem_dimension) = kount
    enddo
!
10  where (quo /= 0)
        top = top * radish_value + mod(quo * spin_value, radix_value)
        bottom = bottom * radish_value
        quo = quo / radix_value
        errors = 1
    elsewhere
        errors = 0
    end where
    if (sum(errors) > 0) go to 10
!
    integration_points = top/bottom 
!
    end subroutine gleich 
!
end program monte_carlo_integration

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

Vorwärts-Schleife (leerer Rumpf):

00000000  push        ebp
00000001  mov         ebp,esp
00000003  xor         eax,eax                   ; Zähler auf 0 setzen
00000005  test        ecx,ecx                   ; Flags des Schleifenende bitweise ANDen
00000007  jle         0000000E                  ; Wenn test <= 0 ans Ende der Methode springen
00000009  inc         eax                       ; Zähler inkrementieren
0000000a  cmp         eax,ecx                   ; Zähler mit dem Schleifenende vergleichen
0000000c  jl          00000009                  ; Wenn Zähler kleiner Schleifenende -> weitere Iteration
0000000e  pop         ebp                       ; Rücksprung aus der Methode


Rückwärts-Schleife

00000000  push        ebp
00000001  mov         ebp,esp
00000003  dec         ecx                       ; n - 1 durchführen
00000004  mov         eax,ecx                   ; n - 1 der Zählvariable zuweisen
00000006  test        eax,eax                   ; Flags des Zählers bitweise ANDen
00000008  jl          0000000D                  ; Wenn test? < 0 ans Ende der Methode springen
0000000a  dec         eax                       ; Zähler dekrementieren
0000000b  jns         0000000A                  ; Weitere Iteration wenn Zähler >= 0 (no sign).
0000000d  pop         ebp                       ; Rücksprung aus der Methode

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:

Vorwärtsschleife -> Range-Check-Elimination wird angewandt

00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  xor         edx,edx 
00000005  mov         eax,dword ptr [ecx+4] 
00000008  test        eax,eax 
0000000a  jle         00000015 
0000000c  mov         dword ptr [ecx+edx*4+8],edx 
00000010  inc         edx  
00000011  cmp         eax,edx 
00000013  jg          0000000C 
00000015  pop         ebp  
00000016  ret              


Vorwärtsschleife -> keine Range-Check-Elimination

00000000  push        ebp  
00000001  mov         ebp,esp 
00000003  push        esi  
00000004  mov         esi,dword ptr [ecx+4] 
00000007  xor         eax,eax 
00000009  test        esi,esi 
0000000b  jle         0000001D 
0000000d  mov         edx,dword ptr [ecx+4] 
00000010  cmp         eax,edx 
00000012  jae         00000020 
00000014  mov         dword ptr [ecx+eax*4+8],eax 
00000018  inc         eax  
00000019  cmp         eax,esi 
0000001b  jl          00000010 
0000001d  pop         esi  
0000001e  pop         ebp  
0000001f  ret              
00000020  call        792AC2B4 
00000025  int         3