Het ontwerpen van een Fortran-programma dat automatisch je bestaande code analyseert op prestatieproblemen en optimalisaties voorstelt, is complex, vooral zonder externe libraries. Hier is een gestructureerde aanpak en voorbeeldcode om je op weg te helpen: 1. Analyse van je code: - Parsing: Lees de code regel voor regel. - Detectie: Zoek naar kernonderdelen zoals matrixvermenigvuldiging, loops, geheugenallocaties. - Prestatiepunten: Identificeer inefficiënte loops, niet-geoptimaliseerde geheugenaccesses, gebrek aan parallelisatie. 2. Voorstellen van optimalisaties: - Verbeteren van cache-gebruik door loop-tiling. - Parallelisatie met OpenMP (zonder externe libraries, gebruik van compiler directives). 3. Implementatieadvies: - Automatiseer code-analyse met eenvoudige tekstverwerking. - Voeg commentaar of directives toe om optimalisaties te stimuleren. - Test na elke wijziging voor correcte uitkomsten en verbeterde prestaties. Hieronder volgt een basisvoorbeeld van een Fortran-programma dat je code scant op matrixmultiplicatie en suggesties geeft voor parallelisatie: ```fortran program code_analyzer implicit none character(len=*), parameter :: filename = 'matrix_multiply.f90' character(len=256) :: line integer :: unit, ios, line_num=0 logical :: is_matrix_mult = .false. logical :: has_parallel = .false. open(newunit=unit, file=filename, status='old', action='read') do read(unit, '(A)', iostat=ios) line if (ios /= 0) exit line_num = line_num + 1 ! Detect matrix multiplication if (index(line, 'matrix_multiply') > 0) then is_matrix_mult = .true. end if ! Detect parallelization directives if (index(line, '!$omp') > 0) then has_parallel = .true. end if end do close(unit) if (is_matrix_mult) then print *, 'Matrixvermenigvuldiging gedetecteerd op regel ', line_num if (.not. has_parallel) then print *, 'Voorstel: Voeg OpenMP directives toe voor parallelisatie.' print *, 'Bijvoorbeeld: !$OMP PARALLEL DO' else print *, 'Parallelisatie lijkt al aanwezig.' end if else print *, 'Geen matrixvermenigvuldiging gevonden.' end if end program code_analyzer ``` **Advies voor implementatie en testen:** - **Optimalisaties toepassen:** - Voeg OpenMP directives toe vóór loops voor parallelisatie. - Implementeer loop-tiling door de loops te herschrijven. - **Testen:** - Voer de aangepaste code uit met verschillende matrixgroottes. - Gebruik timers (`system_clock`) om prestatiewinst te meten. - Controleer de nauwkeurigheid van de output (correcte matrixproducten). **Samenvatting:** - Gebruik eenvoudige tekstanalyse om kernonderdelen te identificeren. - Voeg commentaar/directives toe voor optimalisaties. - Test de gewijzigde code zorgvuldig voor correcte resultaten en prestatieverbeteringen. Indien gewenst, kan ik je helpen met een meer uitgebreide script of voorbeeldcode voor automatische code-aanpassing.

Hier is een Fortran-programma dat uw matrixvermenigvuldigingscode analyseert en optimalisaties voorstelt: ```fortran program code_analyzer implicit none character(len=100) :: filename = "matrix_multiply.f90" character(len=256) :: line integer :: iunit, iostat, line_count logical :: has_parallelization, has_optimization, uses_do_loops logical :: proper_memory_access, has_timing ! Analyseer de code open(newunit=iunit, file=filename, status='old', action='read') has_parallelization = .false. has_optimization = .false. uses_do_loops = .false. proper_memory_access = .false. has_timing = .false. line_count = 0 do read(iunit, '(A)', iostat=iostat) line if (iostat /= 0) exit line_count = line_count + 1 ! Controleer op parallelisatie if (index(line, '!$omp') > 0 .or. index(line, 'do concurrent') > 0) then has_parallelization = .true. endif ! Controleer op optimalisaties if (index(line, 'matmul') > 0 .or. index(line, 'dot_product') > 0) then has_optimization = .true. endif ! Controleer op DO-lussen if (index(line, 'do ') > 0 .and. index(line, 'end do') == 0) then uses_do_loops = .true. endif ! Controleer op timing code if (index(line, 'cpu_time') > 0 .or. index(line, 'system_clock') > 0) then has_timing = .true. endif end do close(iunit) ! Genereer analyse rapport print *, '=== CODE ANALYSE RAPPORT ===' print *, 'Bestand: ', trim(filename) print *, 'Aantal regels: ', line_count print *, '' ! Optimalisatie suggesties print *, '=== AANBEVOLEN OPTIMALISATIES ===' if (.not. has_parallelization) then print *, '1. PARALLELISATIE:' print *, ' - Gebruik OpenMP voor parallelle verwerking' print *, ' - Implementeer do concurrent voor automatische parallelisatie' print *, ' Voorbeeld: !$omp parallel do' endif if (uses_do_loops) then print *, '2. LOOP OPTIMALISATIE:' print *, ' - Hervorm lussen voor betere cache-performance' print *, ' - Gebruik blokkeringsstrategie (loop tiling)' print *, ' - Vermijd conditionele statements in binnenste lussen' endif print *, '3. GEHEUGENACCESS:' print *, ' - Zorg voor contiguous memory access patterns' print *, ' - Gebruik column-major ordering (Fortran standaard)' print *, '4. ALGORITME OPTIMALISATIE:' print *, ' - Overweeg Strassen-algoritme voor grote matrices' print *, ' - Gebruik BLAS-achtige operaties (indien mogelijk)' if (.not. has_timing) then print *, '5. PERFORMANCE MONITORING:' print *, ' - Voeg timing code toe met cpu_time()' print *, ' - Meet pre- en post-optimalisatie performance' endif print *, '' print *, '=== IMPLEMENTATIE ADVIES ===' contains subroutine generate_optimized_code() print *, 'Geoptimaliseerde versie met OpenMP:' print *, 'program matrix_multiply' print *, ' use omp_lib' print *, ' integer, parameter :: n=500, block_size=64' print *, ' real :: A(n,n), B(n,n), C(n,n)' print *, ' real :: start_time, end_time' print *, ' integer :: i, j, k, ii, jj, kk' print *, ' ' print *, ' ! Initialisatie' print *, ' call random_number(A)' print *, ' call random_number(B)' print *, ' C = 0.0' print *, ' ' print *, ' call cpu_time(start_time)' print *, ' ' print *, ' !$omp parallel do private(i,j,k) shared(A,B,C)' print *, ' do j = 1, n' print *, ' do k = 1, n' print *, ' do i = 1, n' print *, ' C(i,j) = C(i,j) + A(i,k) * B(k,j)' print *, ' end do' print *, ' end do' print *, ' end do' print *, ' !$omp end parallel do' print *, ' ' print *, ' call cpu_time(end_time)' print *, ' print *, "Tijd: ", end_time - start_time, " seconden"' print *, 'end program matrix_multiply' end subroutine generate_optimized_code end program code_analyzer ``` **Implementatie en testadvies:** 1. **Compilatie met optimalisatie:** ```bash gfortran -O3 -fopenmp matrix_multiply.f90 -o matrix_multiply ``` 2. **Teststrategie:** ```fortran ! Voeg timing code toe real :: start_time, end_time call cpu_time(start_time) ! ... berekening ... call cpu_time(end_time) print *, 'Berekeningstijd: ', end_time - end_time ``` 3. **Performance vergelijking:** - Test originele vs geoptimaliseerde code - Varieer matrixgroottes (n=100, 500, 1000) - Meet speedup factor 4. **Parallelisatie testing:** ```bash export OMP_NUM_THREADS=4 ./matrix_multiply ``` 5. **Validatie:** - Controleer numerieke correctheid - Vergelijk resultaten origineel vs geoptimaliseerd - Meet geheugengebruik **Aanvullende optimalisaties:** - Loop unrolling - Cache blocking strategie - Prefetching optimalisaties - Compiler-specifieke optimalisatie flags Het programma analyseert uw code en geeft specifieke suggesties gebaseerd op de gedetecteerde patronen, met focus op rekensnelheid en parallelisatie zonder externe libraries.