File: values.F90

package info (click to toggle)
adios2 2.10.2%2Bdfsg1-3
  • links: PTS, VCS
  • area: main
  • in suites: sid
  • size: 33,764 kB
  • sloc: cpp: 175,964; ansic: 160,510; f90: 14,630; yacc: 12,668; python: 7,275; perl: 7,126; sh: 2,825; lisp: 1,106; xml: 1,049; makefile: 579; lex: 557
file content (169 lines) | stat: -rw-r--r-- 6,047 bytes parent folder | download | duplicates (2)
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
program adios2_values
    use mpivars
    use adios2
    implicit none
    integer, parameter :: numsteps = 5
    ! ADIOS2 variables
    type(adios2_adios) :: adios

    ! MPI then ADIOS2 initialization
    call init_mpi(12345)
    call adios2_init(adios, app_comm, ierr)

    call writer()
    call reader()

    ! ADIOS2 then MPI finalization
    call adios2_finalize(adios, ierr)
    call finalize_mpi()

contains

subroutine writer
    use mpivars
    use adios2
    implicit none

    type(adios2_variable) :: var_gc, var_gv, var_lc, var_lv, var_gs
    type(adios2_io) :: io
    type(adios2_engine) :: engine
    integer :: step

    ! Application variables
    ! gc = Global Constant (a single value from the entire application, once per run (e.g. NPROC))
    ! gv = Global Value (a single value from the entire application, changes over time)
    ! lc = Local Constant (one value per process, once per run (e.g. RANK))
    ! lv = Local Value (one value per process, changes over time)
    ! gs = a string, same as a global value
    integer :: gc, gv, lc, lv
    character(len=80) :: gs

    call adios2_declare_io (io, adios, 'Values', ierr)

    call adios2_define_variable(var_gc, io, "GlobalConstant", adios2_type_integer4, ierr)
    call adios2_define_variable(var_gv, io, "GlobalValue", adios2_type_integer4, ierr)
    ! Local values will show up in reading as a 1D array of nproc elements
    ! the write side definition is quite cumbersome in Fortran :-(
    ! We have to define it almost like a distributed global array with a special
    ! dimension value to indicate its type
    call adios2_define_variable(var_lc, io, "LocalConstant", adios2_type_integer4, &
                                1, (/ adios2_local_value_dim /), &
                                adios2_null_dims, &
                                adios2_null_dims, &
                                adios2_constant_dims, ierr)

    call adios2_define_variable(var_lv, io, "LocalValue", adios2_type_integer4, &
                                1, (/ adios2_local_value_dim /), &
                                adios2_null_dims, &
                                adios2_null_dims, &
                                adios2_constant_dims, ierr)
                                
    call adios2_define_variable(var_gs, io, "GlobalString", adios2_type_string, ierr)

    call adios2_open(engine, io, "adios2-values-f.bp", adios2_mode_write, ierr)

    ! Computation/output loop
    gc = nproc
    lc = rank
    do step=0,numsteps-1
        gv = step
        lv = nproc*(step)+rank
        write (gs,'(a,i3)') "This is step ", step

        call adios2_begin_step(engine, adios2_step_mode_append, ierr)
        if (step == 0) then
            call adios2_put(engine, var_lc, lc, ierr);
            if (rank == 0) then
                ! could be written from every process but it is useless
                call adios2_put(engine, var_gc, gc, ierr);
            endif
        endif
        if (rank == 0) then
            ! could be written from every process but it is useless
            call adios2_put(engine, var_gv, gv, ierr);
            call adios2_put(engine, var_gs, gs, ierr);
        endif
        call adios2_put(engine, var_lv, lv, ierr);
        call adios2_end_step(engine, ierr)
    enddo

    ! Close the output
    call adios2_close(engine, ierr)

end subroutine writer


subroutine reader
    use mpivars
    implicit none

    type(adios2_variable) :: var_gc, var_gv, var_lc, var_lv
    type(adios2_io) :: io
    type(adios2_engine) :: engine
    integer*8 :: numsteps, i
    integer*4 :: gc
    integer*4, dimension(:), allocatable :: gvs, lcs
    integer*4, dimension(:,:), allocatable :: lvs
    character(len=80)::fmt
    integer*8, dimension(:), allocatable :: shape_lv, shape_lc
    integer :: ndims_lv, ndims_lc

    ! Note, every process reads everything in this example
    
    call adios2_declare_io(io, adios, "ValuesInput", ierr)
    call adios2_open(engine, io, "adios2-values-f.bp", adios2_mode_readRandomAccess, MPI_COMM_SELF, ierr)
    
    call adios2_inquire_variable(var_gc, io, "GlobalConstant", ierr)
    call adios2_get(engine, var_gc, gc , ierr)

    call adios2_inquire_variable(var_gv, io, "GlobalValue", ierr)
    call adios2_variable_steps(numsteps, var_gv, ierr)
    call adios2_set_step_selection(var_gv, 0_8, numsteps, ierr)
    allocate(gvs(numsteps))
    call adios2_get(engine, var_gv, gvs , ierr)

    ! Read Local Values and Local Constants as a 1D array
    ! shape array is allocated inside adios2_variable_shape()

    call adios2_inquire_variable(var_lc, io, "LocalConstant", ierr)
    call adios2_variable_shape(shape_lc, ndims_lc, var_lc, ierr)
    allocate(lcs(shape_lc(1)))
    call adios2_get(engine, var_lc, lcs , ierr)

    call adios2_inquire_variable(var_lv, io, "LocalValue", ierr)
    call adios2_variable_shape(shape_lv, ndims_lv, var_lv, ierr)
    call adios2_set_step_selection(var_lv, 0_8, numsteps, ierr)
    allocate(lvs(shape_lv(1),numsteps))
    call adios2_get(engine, var_lv, lvs , ierr)

    call adios2_close(engine, ierr)

    ! By default, get()s are deferred and content is available AFTER
    ! adios2_close() or adios2_perform_gets()
    ! Use adios2_mode_sync option in adios2_get() to get the content immediately

    if (rank == 0) then
        write(*,'("Number of steps in file = ",i5)') numsteps
        write(*,'("GlobalConstant = ", i5)') gc

        write(fmt,'(a,i5,a)') '(a18,',numsteps,'i4,a2)'
        !write(*,'(a)') fmt
        write(*,fmt) "GlobalValue(s) = [", gvs, " ]"

        write(fmt,'(a,i5,a)') '(a20,',shape_lc(1),'i4,a2)'
        !write(*,'(a)') fmt
        write(*,fmt) "LocalConstant(s) = [", lcs, " ]"

        write(fmt,'(a,i5,a)') '(a6,i3,a4,',shape_lv(1),'i4)'
        !write(*,'(a)') fmt
        write(*,'(a)') "LocalValues = ["
        do i = 1, numsteps
            write(*,fmt) "  step", i-1, ":", lvs(:,i)
        enddo
        write(*,*) "             ]"
    endif

    deallocate(gvs, lcs, lvs)
end subroutine reader

end program adios2_values