Hier is een voorbeeld van een Fortran-programma dat zich richt op dynamische geheugenallocatie en beheer voor het verwerken van grote datasets met kommagetallen. Het bevat functies voor toewijzen, aanpassen van de grootte en vrijmaken van geheugen. Daarnaast geef ik best practices en tips voor geheugenbeheer en profilering. ```fortran program dynamisch_geheugenbeheer implicit none ! Parameters integer, parameter :: max_size = 10000 real, allocatable :: data(:) integer :: size ! Voorbeeld: toewijzen van geheugen call allocate_array(data, max_size) print *, "Gewaardeerde array grootte: ", size(data) ! Voorbeeld: aanpassen van grootte call resize_array(data, 5000) print *, "Gewerkte array na resizing: ", size(data) ! Vul de array met voorbeeldgegevens call fill_array(data) ! Bevrijd het geheugen call free_array(data) print *, "Array vrijgemaakt." contains ! Functie om array te alloceren subroutine allocate_array(arr, n) real, allocatable, intent(out) :: arr(:) integer, intent(in) :: n if (allocated(arr)) then deallocate(arr) end if if (n > 0 .and. n <= max_size) then allocate(arr(n), stat=stat_alloc) if (stat_alloc /= 0) then print *, "Fout bij allocatie!" end if else print *, "Ongeldige grootte voor allocatie." end if end subroutine allocate_array ! Functie om array te heralloceren (grootte aanpassen) subroutine resize_array(arr, new_size) real, allocatable, intent(inout) :: arr(:) integer, intent(in) :: new_size real, allocatable :: temp(:) if (.not. allocated(arr)) then call allocate_array(arr, new_size) else if (new_size <= max_size) then allocate(temp(new_size)) temp = 0.0 ! Kopieer bestaande data indien nodig temp(1:min(size(arr), new_size)) = arr(1:min(size(arr), new_size)) deallocate(arr) arr => temp else print *, "Grootte buiten limiet." end if end if end subroutine resize_array ! Functie om array vrij te maken subroutine free_array(arr) real, allocatable, intent(inout) :: arr(:) if (allocated(arr)) then deallocate(arr) end if end subroutine free_array ! Voorbeeld: vullen met data subroutine fill_array(arr) real, intent(inout) :: arr(:) integer :: i do i = 1, size(arr) arr(i) = i * 0.1 end do end subroutine fill_array end program dynamisch_geheugenbeheer ``` **Best practices voor geheugengebruik en geheugenlekken voorkomen:** - **Gebruik `deallocate` altijd zodra een array niet meer nodig is.** Dit voorkomt geheugenlekken. - **Controleer of een array al is gealloceerd met `allocated()`** voordat je deze deallocateert of heralloceert. - **Gebruik stat=variabele bij allocatie** om fouten te detecteren en te controleren of allocatie succesvol was. - **Herallocate niet onnodig**; herallocatie kost tijd en geheugen. - **Gebruik allocatable arrays in modules** voor betere scope-beheer. **Tips voor profileren en debuggen:** - **Gebruik Fortran profiler tools zoals gprof of Intel VTune** om geheugengebruik en tijd te analyseren. - **Voer regelmatig checks uit met `allocated()`** om geheugenfouten te voorkomen. - **Gebruik debugging tools zoals Valgrind** (hoewel beperkte ondersteuning voor Fortran) om geheugenlekken op te sporen. - **Monitor geheugenverbruik tijdens uitvoering** met systeemtools (bijvoorbeeld `top`, `htop`, of Windows Task Manager). - **Schrijf testcases met kleine datasets** om problemen vroeg te detecteren. Met deze aanpak en tips kun je effectief omgaan met grote datasets en dynamisch geheugen in Fortran.

Hier is een uitgebreid Fortran-programma dat dynamische geheugenallocatie demonstreert voor grote datasets met kommagetallen: ```fortran program dynamisch_geheugen_beheer implicit none ! Constanten definiëren integer, parameter :: MAX_GROOTTE = 10000 integer, parameter :: DP = kind(1.0d0) ! Dynamische arrays real(DP), allocatable, dimension(:) :: dataset real(DP), allocatable, dimension(:,:) :: matrix_data ! Hulpmiddelen integer :: i, status, huidige_grootte real(DP) :: gemiddelde, som print *, '=== Dynamisch Geheugenbeheer in Fortran ===' ! 1. INITIËLE TOEWIJZING call wijs_geheugen_toe(dataset, MAX_GROOTTE) ! 2. DATA INITIALISEREN call initialiseer_dataset(dataset) ! 3. BEWERKINGEN UITVOEREN call bereken_statistieken(dataset) ! 4. GROOTTE AANPASSEN call pas_grootte_aan(dataset, 5000) ! 5. MATRIX TOEWIJZEN EN BEWERKEN call wijs_matrix_toe(matrix_data, 100, 100) call verwerk_matrix(matrix_data) ! 6. GEHEUGEN VRIJMAKEN call maak_geheugen_vrij(dataset, matrix_data) print *, 'Programma succesvol voltooid!' contains ! TOEWIJZINGSFUNCTIES subroutine wijs_geheugen_toe(arr, grootte) real(DP), allocatable, dimension(:), intent(out) :: arr integer, intent(in) :: grootte if (allocated(arr)) then deallocate(arr, stat=status) if (status /= 0) then print *, 'Waarschuwing: Kon geheugen niet vrijmaken voor hertoewijzing' return endif endif allocate(arr(grootte), stat=status) if (status /= 0) then print *, 'Fout: Geheugentoewijzing mislukt voor grootte ', grootte stop endif print *, 'Geheugen succesvol toegewezen voor ', grootte, ' elementen' end subroutine wijs_geheugen_toe subroutine wijs_matrix_toe(mat, rijen, kolommen) real(DP), allocatable, dimension(:,:), intent(out) :: mat integer, intent(in) :: rijen, kolommen if (allocated(mat)) deallocate(mat) allocate(mat(rijen, kolommen), stat=status) if (status /= 0) then print *, 'Fout: Matrixtoewijzing mislukt' stop endif print *, 'Matrix toegewezen: ', rijen, 'x', kolommen end subroutine wijs_matrix_toe ! DATA INITIALISATIE subroutine initialiseer_dataset(arr) real(DP), dimension(:), intent(inout) :: arr integer :: i do i = 1, size(arr) arr(i) = sin(real(i, DP) * 0.1_DP) + cos(real(i, DP) * 0.05_DP) end do print *, 'Dataset geïnitialiseerd met ', size(arr), ' elementen' end subroutine initialiseer_dataset ! BEWERKINGEN subroutine bereken_statistieken(arr) real(DP), dimension(:), intent(in) :: arr real(DP) :: som, gemiddelde integer :: n n = size(arr) som = sum(arr) gemiddelde = som / real(n, DP) print *, 'Statistieken:' print *, ' Aantal elementen: ', n print *, ' Som: ', som print *, ' Gemiddelde: ', gemiddelde end subroutine bereken_statistieken ! GROOTTE AANPASSEN subroutine pas_grootte_aan(arr, nieuwe_grootte) real(DP), allocatable, dimension(:), intent(inout) :: arr integer, intent(in) :: nieuwe_grootte real(DP), allocatable, dimension(:) :: temp_arr integer :: kopieer_grootte if (.not. allocated(arr)) then print *, 'Waarschuwing: Array niet toegewezen' return endif ! Tijdelijke kopie maken kopieer_grootte = min(size(arr), nieuwe_grootte) allocate(temp_arr(kopieer_grootte)) temp_arr(1:kopieer_grootte) = arr(1:kopieer_grootte) ! Origineel vrijmaken en opnieuw toewijzen deallocate(arr) allocate(arr(nieuwe_grootte)) ! Data terugkopiëren arr(1:kopieer_grootte) = temp_arr(1:kopieer_grootte) ! Eventuele nieuwe elementen initialiseren if (nieuwe_grootte > kopieer_grootte) then arr(kopieer_grootte+1:nieuwe_grootte) = 0.0_DP endif deallocate(temp_arr) print *, 'Array grootte aangepast van ', kopieer_grootte, ' naar ', nieuwe_grootte end subroutine pas_grootte_aan ! MATRIX BEWERKINGEN subroutine verwerk_matrix(mat) real(DP), dimension(:,:), intent(inout) :: mat integer :: i, j ! Matrix vullen met betekenisvolle data do j = 1, size(mat, 2) do i = 1, size(mat, 1) mat(i,j) = exp(-0.01_DP * real(i*j, DP)) end do end do print *, 'Matrix verwerkt: norm = ', sqrt(sum(mat**2)) end subroutine verwerk_matrix ! GEHEUGEN VRIJMAKEN subroutine maak_geheugen_vrij(arr, mat) real(DP), allocatable, dimension(:), intent(inout) :: arr real(DP), allocatable, dimension(:,:), intent(inout) :: mat if (allocated(arr)) then deallocate(arr) print *, 'Array geheugen vrijgegeven' endif if (allocated(mat)) then deallocate(mat) print *, 'Matrix geheugen vrijgegeven' endif end subroutine maak_geheugen_vrij end program dynamisch_geheugen_beheer ``` ## BEST PRACTICES VOOR GEHEUGENBEHEER: ### 1. Geheugenlekken voorkomen: ```fortran ! ALTIJD controleren op toewijzing voor vrijmaken if (allocated(mijn_array)) then deallocate(mijn_array, stat=status) if (status /= 0) print *, 'Waarschuwing: vrijmaken mislukt' endif ! Gebruik INTENT(INOUT) voor aanpasbare arrays in subroutines subroutine verwerk_data(arr) real(DP), allocatable, dimension(:), intent(inout) :: arr ! ... code ... end subroutine ``` ### 2. Geheugengebruik optimaliseren: ```fortran ! Gebruik CONTIGUOUS voor betere prestaties real(DP), allocatable, contiguous :: geoptimaliseerde_array(:) ! Minimaliseer herhaalde toewijzingen if (nieuwe_grootte /= size(bestaande_array)) then call pas_grootte_aan(bestaande_array, nieuwe_grootte) endif ``` ## PROFILING EN DEBUGGING: ### 1. Compiler-opties voor debugging: ```bash gfortran -g -fcheck=all -fbacktrace programma.f90 -o programma ifort -g -check all -traceback programma.f90 -o programma ``` ### 2. Geheugengebruik monitoren: ```fortran subroutine toon_geheugen_info(arr) real(DP), dimension(:), intent(in) :: arr integer :: bytes_gebruikt bytes_gebruikt = size(arr) * storage_size(arr) / 8 print *, 'Geheugengebruik: ', bytes_gebruikt, ' bytes' print *, 'Aantal elementen: ', size(arr) end subroutine ``` ### 3. Valgrind voor geheugencontrole: ```bash valgrind --leak-check=full --track-origins=yes ./programma ``` ### 4. Foutafhandeling: ```fortran ! Robuuste toewijzing allocate(mijn_array(grootte), stat=status) if (status /= 0) then print *, 'Kritieke fout: onvoldoende geheugen' error stop 'Geheugentoewijzing mislukt' endif ``` ### 5. Tools voor profiling: - **gprof**: Prestatie-analyse - **Intel VTune**: Geavanceerde geheugenanalyse - **Fortran Compiler intrinsieken**: `malloc()` tracking Dit programma en de bijbehorende best practices zorgen voor efficiënt geheugenbeheer en helpen geheugenlekken en -problemen te voorkomen bij het verwerken van grote datasets.