Hieronder vind je een basisvoorbeeld van een Fortran-programma dat automatisch prestatiegegevens verzamelt en analyseert tijdens de uitvoering van de subroutine `bereken_matrixproduct`. Het programma meet de uitvoeringstijd en kan uitgebreid worden voor geheugengebruik. Daarnaast geef ik advies over geschikte profiling-methoden en tools, en hoe je deze kunt integreren. **Voorbeeld Fortran-code met prestatiegegevens verzameling** ```fortran program prestatie_metingen implicit none integer, parameter :: n = 1000 real, allocatable :: A(:,:), B(:,:), C(:,:) real :: start_time, end_time, elapsed_time integer :: i, j ! Allocate matrices allocate(A(n,n), B(n,n), C(n,n)) ! Initialize matrices (bijvoorbeeld met willekeurige waarden) call random_seed() call initialize_matrix(A) call initialize_matrix(B) ! Meet de tijd voor matrixvermenigvuldiging call cpu_time(start_time) call bereken_matrixproduct(A, B, C, n) call cpu_time(end_time) elapsed_time = end_time - start_time print *, 'Uitvoeringstijd (s): ', elapsed_time ! Optioneel: geheugengebruik meten (complexer, afhankelijk van systeem) ! Dit vereist externe tools of systeemcalls deallocate(A, B, C) contains subroutine initialize_matrix(M) real, intent(out) :: M(:,:) integer :: i, j do i = 1, size(M,1) do j = 1, size(M,2) call random_number(M(i,j)) end do end do end subroutine initialize_matrix subroutine bereken_matrixproduct(A, B, C, n) real, intent(in) :: A(:,:), B(:,:) real, intent(out) :: C(:,:) integer, intent(in) :: n integer :: i, j, k do i = 1, n do j = 1, n C(i,j) = 0.0 do k = 1, n C(i,j) = C(i,j) + A(i,k) * B(k,j) end do end do end do end subroutine bereken_matrixproduct end program prestatie_metingen ``` --- ### Advies over profiling-methoden en tools **1. Gebruik van cpu_time (voor tijdmeting):** In het voorbeeld wordt `cpu_time` gebruikt om de tijd te meten die de subroutine in beslag neemt. Dit is eenvoudig en direct, geschikt voor snelle tests. **2. Geheugengebruik meten:** Voor gedetailleerd geheugengebruik zijn externe tools nodig, zoals: - **Valgrind (Linux):** voor geheugenlekken en geheugengebruik. - ** massif:** onderdeel van Valgrind voor geheugengebruik over tijd. - **Linux /proc filesystem:** voor systeminformatie. Deze tools moeten buiten je Fortran-code worden aangeroepen en kunnen via scripts worden geïntegreerd. **3. Profileringstools voor Fortran:** - **gprof:** standaard profiler voor C en Fortran programma's (met compilatie-flag `-pg`). - **Intel VTune Profiler:** krachtige profiler, vooral bij gebruik van Intel Fortran Compiler. - **GNU gprof + -pg:** voeg `-pg` toe bij compilatie en linking, bijvoorbeeld: ```bash gfortran -pg -o mijn_programm main.f90 ./mijn_programm gprof ./mijn_programm gmon.out > profiel.txt ``` - **Score-P / Vampir / Tau:** voor uitgebreide analyse en grafische weergave. **4. Integratie in je project:** - Voeg compilerflags toe voor profilering (`-pg`, `-g`, `-O2`, etc.). - Bouw je programma met deze flags tijdens ontwikkelfases. - Voer het programma uit onder de profiler en verzamel gegevens. - Analyseer de resultaten via de bijbehorende tools, waaronder grafische weergaven en rapporten. **5. Grafische weergave en rapportage:** - Exporteer gegevens uit profiler-rapporten naar CSV of andere formaten. - Gebruik Python (bijvoorbeeld matplotlib) of R voor grafische visualisaties. - Voor PDF-rapporten kun je LaTeX gebruiken of rapportgeneratietools zoals Pandoc. --- ### Samenvatting - Voeg tijdmetingen toe in je Fortran-code met `cpu_time`. - Gebruik externe tools zoals Valgrind, gprof, of Intel VTune voor dieper inzicht. - Automatiseer profiling en analyse met scripts. - Voor visualisatie en rapportage, exporteer gegevens en gebruik externe software. Heeft u nog verdere vragen of hulp bij specifieke tools of implementatie?

Hier is een Fortran-programma met prestatieprofilering voor uw matrixproduct subroutine, inclusief advies over tools en integratie: ```fortran program prestatie_analyse use, intrinsic :: iso_fortran_env, only: dp => real64, int64 implicit none ! Prestatiegegevens structuur type prestatie_data real(dp) :: uitvoeringstijd integer(int64) :: geheugengebruik integer :: matrix_grootte character(len=20) :: timestamp end type prestatie_data ! Variabelen real(dp), allocatable :: A(:,:), B(:,:), C(:,:) type(prestatie_data) :: metingen(100) integer :: n, i, meting_teller real(dp) :: start_tijd, eind_tijd character(len=30) :: rapport_bestand ! Initialisatie meting_teller = 0 rapport_bestand = 'prestatie_rapport.txt' ! Test verschillende matrixgroottes do n = 100, 1000, 100 meting_teller = meting_teller + 1 ! Alloceer geheugen allocate(A(n,n), B(n,n), C(n,n)) ! Initialiseer matrices call random_number(A) call random_number(B) C = 0.0_dp ! Meet uitvoeringstijd call cpu_time(start_tijd) call bereken_matrixproduct(A, B, C, n) call cpu_time(eind_tijd) ! Verzamel gegevens metingen(meting_teller)%uitvoeringstijd = eind_tijd - start_tijd metingen(meting_teller)%geheugengebruik = 3 * n * n * storage_size(A)/8 ! bytes metingen(meting_teller)%matrix_grootte = n call datum_tijd(metingen(meting_teller)%timestamp) ! Vrijgeven geheugen deallocate(A, B, C) end do ! Genereer rapport call genereer_rapport(metingen, meting_teller, rapport_bestand) ! Grafische weergave (via extern script) call system('python maak_grafieken.py ' // rapport_bestand) contains subroutine bereken_matrixproduct(A, B, C, n) real(dp), intent(in) :: A(n,n), B(n,n) real(dp), intent(out) :: C(n,n) integer, intent(in) :: n integer :: i, j, k ! Eenvoudige matrixvermenigvuldiging do concurrent (i = 1:n, j = 1:n) C(i,j) = 0.0_dp do k = 1:n C(i,j) = C(i,j) + A(i,k) * B(k,j) end do end do end subroutine bereken_matrixproduct subroutine datum_tijd(timestamp) character(len=*), intent(out) :: timestamp integer :: values(8) call date_and_time(values=values) write(timestamp, '(I4,"-",I2.2,"-",I2.2," ",I2.2,":",I2.2)') & values(1), values(2), values(3), values(5), values(6) end subroutine datum_tijd subroutine genereer_rapport(metingen, aantal, bestandsnaam) type(prestatie_data), intent(in) :: metingen(:) integer, intent(in) :: aantal character(len=*), intent(in) :: bestandsnaam integer :: i, unit open(newunit=unit, file=bestandsnaam, status='replace') write(unit, *) 'PRESTATIERAPPORT MATRIXVERMENIGVULDIGING' write(unit, *) '========================================' write(unit, *) do i = 1, aantal write(unit, '(A,I4,A)') 'Meting ', i, ':' write(unit, '(A,I6)') ' Matrixgrootte: ', metingen(i)%matrix_grootte write(unit, '(A,F10.6,A)') ' Uitvoeringstijd: ', metingen(i)%uitvoeringstijd, ' seconden' write(unit, '(A,F10.2,A)') ' Geheugengebruik: ', & metingen(i)%geheugengebruik/1048576.0_dp, ' MB' write(unit, '(A,A)') ' Tijdstip: ', trim(metingen(i)%timestamp) write(unit, *) end do close(unit) end subroutine genereer_rapport end program prestatie_analyse ``` **Python script voor grafieken (maak_grafieken.py):** ```python import matplotlib.pyplot as plt import numpy as np import sys def lees_rapport(bestandsnaam): groottes, tijden, geheugen = [], [], [] with open(bestandsnaam, 'r') as f: for line in f: if 'Matrixgrootte:' in line: groottes.append(int(line.split()[-1])) elif 'Uitvoeringstijd:' in line: tijden.append(float(line.split()[-2])) elif 'Geheugengebruik:' in line: geheugen.append(float(line.split()[-2])) return groottes, tijden, geheugen def maak_grafieken(groottes, tijden, geheugen): fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5)) # Tijd vs grootte ax1.plot(groottes, tijden, 'bo-') ax1.set_xlabel('Matrix grootte') ax1.set_ylabel('Uitvoeringstijd (s)') ax1.set_title('Uitvoeringstijd vs Matrixgrootte') ax1.grid(True) # Geheugen vs grootte ax2.plot(groottes, geheugen, 'ro-') ax2.set_xlabel('Matrix grootte') ax2.set_ylabel('Geheugengebruik (MB)') ax2.set_title('Geheugengebruik vs Matrixgrootte') ax2.grid(True) plt.tight_layout() plt.savefig('prestatie_grafieken.pdf', format='pdf') plt.savefig('prestatie_grafieken.png') plt.close() if __name__ == "__main__": if len(sys.argv) > 1: g, t, m = lees_rapport(sys.argv[1]) maak_grafieken(g, t, m) ``` ## Aanbevolen Profiling Tools voor Fortran: ### 1. **gprof** (GNU Profiler) ```bash gfortran -pg programma.f90 -o programma ./programma gprof programma gmon.out > prestatie_analyse.txt ``` ### 2. **Intel VTune Profiler** - Uitgebreide hardware-gebaseerde profiling - Cache-analyse en vectorisatie metrics ### 3. **Score-P** (Scalable Performance Measurement) - Geavanceerde instrumentatie - Ondersteuning voor parallelle code ### 4. **TAU** (Tuning and Analysis Utilities) - Uitgebreide performance analysis - Parallelle applicatie support ## Integratieadvies: 1. **Compileer met debugging flags:** ```bash gfortran -g -O2 -fopenmp programma.f90 -o programma ``` 2. **Gebruik build system integration:** ```makefile PROFILE_FLAGS = -pg -g OPT_FLAGS = -O3 -march=native profiel: programma.f90 gfortran $(PROFILE_FLAGS) $(OPT_FLAGS) $< -o $@ ``` 3. **Automatiseer met scripts:** ```bash #!/bin/bash # auto_profiel.sh for size in 100 200 300 400 500; do echo "Running size $size" ./programma $size >> resultaten_$size.txt done ``` 4. **Overweeg real-time monitoring:** ```fortran ! Voor real-time monitoring use, intrinsic :: iso_c_binding interface function get_memory_usage() bind(C) use, intrinsic :: iso_c_binding integer(c_long) :: get_memory_usage end function end interface ``` Dit geeft u een complete oplossing voor prestatie-analyse met automatische rapportage en visualisatie!