Ignore:
Timestamp:
Mar 4, 2013 5:31:38 AM (8 years ago)
Author:
raasch
Message:

New:
---

Porting of FFT-solver for serial runs to GPU using CUDA FFT,
preprocessor lines in transpose routines rearranged, so that routines can also
be used in serial (non-parallel) mode,
transpositions also carried out in serial mode, routines fftx, fftxp replaced
by calls of fft_x, fft_x replaced by fft_x_1d in the 1D-decomposition routines
(Makefile, Makefile_check, fft_xy, poisfft, poisfft_hybrid, transpose, new: cuda_fft_interfaces)

--stdin argument for mpiexec on lckyuh, -y and -Y settings output to header (mrun)

Changed:


Module array_kind renamed precision_kind
(check_open, data_output_3d, fft_xy, modules, user_data_output_3d)

some format changes for coupled atmosphere-ocean runs (header)
small changes in code formatting (microphysics, prognostic_equations)

Errors:


bugfix: default value (0) assigned to coupling_start_time (modules)
bugfix: initial time for preruns of coupled runs is output as -coupling_start_time (data_output_profiles)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • palm/trunk/SOURCE/transpose.f90

    r1093 r1106  
    2020! Current revisions:
    2121! -----------------
    22 !
     22! preprocessor lines rearranged so that routines can also be used in serial
     23! (non-parallel) mode
    2324!
    2425! Former revisions:
     
    8485             work(nnx*nny*nnz)
    8586
    86 #if defined( __parallel )
    87 
    8887!
    8988!-- Rearrange indices of input array in order to make data to be send
     
    10099!$OMP  END PARALLEL
    101100
    102 !
    103 !-- Transpose array
    104     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
    105     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
    106     CALL MPI_ALLTOALL( f_inv(nys_x,nzb_x,0), sendrecvcount_xy, MPI_REAL, &
    107                        work(1),              sendrecvcount_xy, MPI_REAL, &
    108                        comm1dy, ierr )
    109     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
    110 
    111 !
    112 !-- Reorder transposed array
     101    IF ( numprocs /= 1 )  THEN
     102
     103#if defined( __parallel )
     104!
     105!--    Transpose array
     106       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
     107       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
     108       CALL MPI_ALLTOALL( f_inv(nys_x,nzb_x,0), sendrecvcount_xy, MPI_REAL, &
     109                          work(1),              sendrecvcount_xy, MPI_REAL, &
     110                          comm1dy, ierr )
     111       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
     112
     113!
     114!--    Reorder transposed array
    113115!$OMP  PARALLEL PRIVATE ( i, j, k, l, m, ys )
    114116!$OMP  DO
    115     DO  l = 0, pdims(2) - 1
    116        m  = l * ( nxr_y - nxl_y + 1 ) * ( nzt_y - nzb_y + 1 ) * &
    117                 ( nyn_x - nys_x + 1 )
    118        ys = 0 + l * ( nyn_x - nys_x + 1 )
    119        DO  i = nxl_y, nxr_y
    120           DO  k = nzb_y, nzt_y
    121              DO  j = ys, ys + nyn_x - nys_x
    122                 m = m + 1
    123                 f_out(j,i,k) = work(m)
    124              ENDDO
    125           ENDDO
    126        ENDDO
    127     ENDDO
    128 !$OMP  END PARALLEL
    129 
     117       DO  l = 0, pdims(2) - 1
     118          m  = l * ( nxr_y - nxl_y + 1 ) * ( nzt_y - nzb_y + 1 ) * &
     119                   ( nyn_x - nys_x + 1 )
     120          ys = 0 + l * ( nyn_x - nys_x + 1 )
     121          DO  i = nxl_y, nxr_y
     122             DO  k = nzb_y, nzt_y
     123                DO  j = ys, ys + nyn_x - nys_x
     124                   m = m + 1
     125                   f_out(j,i,k) = work(m)
     126                ENDDO
     127             ENDDO
     128          ENDDO
     129       ENDDO
     130!$OMP  END PARALLEL
    130131#endif
     132
     133    ELSE
     134
     135!
     136!--    Reorder transposed array
     137!$OMP  PARALLEL PRIVATE ( i, j, k )
     138!$OMP  DO
     139       DO  k = nzb_y, nzt_y
     140          DO  i = nxl_y, nxr_y
     141             DO  j = 0, ny
     142                f_out(j,i,k) = f_inv(j,k,i)
     143             ENDDO
     144          ENDDO
     145       ENDDO
     146!$OMP  END PARALLEL
     147
     148    ENDIF
    131149
    132150 END SUBROUTINE transpose_xy
     
    158176             work(nnx*nny*nnz)
    159177
    160 #if defined( __parallel )
    161178
    162179!
     
    164181!-- reordered locally and therefore no transposition has to be done.
    165182    IF ( pdims(1) /= 1 )  THEN
     183
     184#if defined( __parallel )
    166185!
    167186!--    Reorder input array for transposition
     
    203222       ENDDO
    204223!$OMP  END PARALLEL
     224#endif
     225
    205226    ELSE
     227
    206228!
    207229!--    Reorder the array in a way that the z index is in first position
     
    229251
    230252    ENDIF
    231 
    232 
    233 #endif
    234253
    235254 END SUBROUTINE transpose_xz
     
    261280             work(nnx*nny*nnz)
    262281
     282    IF ( numprocs /= 1 )  THEN
     283
    263284#if defined( __parallel )
    264 
    265 !
    266 !-- Reorder input array for transposition
     285!
     286!--    Reorder input array for transposition
    267287!$OMP  PARALLEL PRIVATE ( i, j, k, l, m, ys )
    268288!$OMP  DO
    269     DO  l = 0, pdims(2) - 1
    270        m  = l * ( nxr_y - nxl_y + 1 ) * ( nzt_y - nzb_y + 1 ) * &
    271                 ( nyn_x - nys_x + 1 )
    272        ys = 0 + l * ( nyn_x - nys_x + 1 )
     289       DO  l = 0, pdims(2) - 1
     290          m  = l * ( nxr_y - nxl_y + 1 ) * ( nzt_y - nzb_y + 1 ) * &
     291                   ( nyn_x - nys_x + 1 )
     292          ys = 0 + l * ( nyn_x - nys_x + 1 )
     293          DO  i = nxl_y, nxr_y
     294             DO  k = nzb_y, nzt_y
     295                DO  j = ys, ys + nyn_x - nys_x
     296                   m = m + 1
     297                   work(m) = f_in(j,i,k)
     298                ENDDO
     299             ENDDO
     300          ENDDO
     301       ENDDO
     302!$OMP  END PARALLEL
     303
     304!
     305!--    Transpose array
     306       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
     307       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
     308       CALL MPI_ALLTOALL( work(1),              sendrecvcount_xy, MPI_REAL, &
     309                          f_inv(nys_x,nzb_x,0), sendrecvcount_xy, MPI_REAL, &
     310                          comm1dy, ierr )
     311       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
     312#endif
     313
     314    ELSE
     315
     316!
     317!--    Reorder array f_in the same way as ALLTOALL did it
     318!$OMP  PARALLEL PRIVATE ( i, j, k )
     319!$OMP  DO
    273320       DO  i = nxl_y, nxr_y
    274321          DO  k = nzb_y, nzt_y
    275              DO  j = ys, ys + nyn_x - nys_x
    276                 m = m + 1
    277                 work(m) = f_in(j,i,k)
    278              ENDDO
    279           ENDDO
    280        ENDDO
    281     ENDDO
    282 !$OMP  END PARALLEL
    283 
    284 !
    285 !-- Transpose array
    286     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
    287     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
    288     CALL MPI_ALLTOALL( work(1),              sendrecvcount_xy, MPI_REAL, &
    289                        f_inv(nys_x,nzb_x,0), sendrecvcount_xy, MPI_REAL, &
    290                        comm1dy, ierr )
    291     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
     322             DO  j = 0, ny
     323                f_inv(j,k,i) = f_in(j,i,k)
     324             ENDDO
     325          ENDDO
     326       ENDDO
     327!$OMP  END PARALLEL
     328
     329    ENDIF
    292330
    293331!
     
    303341    ENDDO
    304342!$OMP  END PARALLEL
    305 
    306 #endif
    307343
    308344 END SUBROUTINE transpose_yx
     
    402438             work(nnx*nny*nnz)
    403439
    404 #if defined( __parallel )
    405 
    406440!
    407441!-- Rearrange indices of input array in order to make data to be send
     
    424458!-- of the data is necessary and no transposition has to be done.
    425459    IF ( pdims(1) == 1 )  THEN
     460
    426461!$OMP  PARALLEL PRIVATE ( i, j, k )
    427462!$OMP  DO
     
    434469       ENDDO
    435470!$OMP  END PARALLEL
    436        RETURN
    437     ENDIF
    438 
    439 !
    440 !-- Transpose array
    441     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
    442     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
    443     CALL MPI_ALLTOALL( f_inv(nxl_y,nzb_y,0), sendrecvcount_yz, MPI_REAL, &
    444                        work(1),              sendrecvcount_yz, MPI_REAL, &
    445                        comm1dx, ierr )
    446     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
    447 
    448 !
    449 !-- Reorder transposed array
     471
     472    ELSE
     473
     474#if defined( __parallel )
     475!
     476!--    Transpose array
     477       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
     478       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
     479       CALL MPI_ALLTOALL( f_inv(nxl_y,nzb_y,0), sendrecvcount_yz, MPI_REAL, &
     480                          work(1),              sendrecvcount_yz, MPI_REAL, &
     481                          comm1dx, ierr )
     482       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
     483
     484!
     485!--    Reorder transposed array
    450486!$OMP  PARALLEL PRIVATE ( i, j, k, l, m, zs )
    451487!$OMP  DO
    452     DO  l = 0, pdims(1) - 1
    453        m  = l * ( nyn_z - nys_z + 1 ) * ( nzt_y - nzb_y + 1 ) * &
    454                 ( nxr_z - nxl_z + 1 )
    455        zs = 1 + l * ( nzt_y - nzb_y + 1 )
    456        DO  j = nys_z, nyn_z
    457           DO  k = zs, zs + nzt_y - nzb_y
    458              DO  i = nxl_z, nxr_z
    459                 m = m + 1
    460                 f_out(i,j,k) = work(m)
    461              ENDDO
    462           ENDDO
    463        ENDDO
    464     ENDDO
    465 !$OMP  END PARALLEL
    466 
     488       DO  l = 0, pdims(1) - 1
     489          m  = l * ( nyn_z - nys_z + 1 ) * ( nzt_y - nzb_y + 1 ) * &
     490                   ( nxr_z - nxl_z + 1 )
     491          zs = 1 + l * ( nzt_y - nzb_y + 1 )
     492          DO  j = nys_z, nyn_z
     493             DO  k = zs, zs + nzt_y - nzb_y
     494                DO  i = nxl_z, nxr_z
     495                   m = m + 1
     496                   f_out(i,j,k) = work(m)
     497                ENDDO
     498             ENDDO
     499          ENDDO
     500       ENDDO
     501!$OMP  END PARALLEL
    467502#endif
     503
     504   ENDIF
    468505
    469506 END SUBROUTINE transpose_yz
     
    490527    INTEGER ::  i, j, k, l, m, xs
    491528   
    492     REAL ::  f_in(1:nz,nys:nyn,nxl:nxr), f_inv(nys:nyn,nxl:nxr,1:nz), &
    493              f_out(0:nx,nys_x:nyn_x,nzb_x:nzt_x),                     &
     529    REAL ::  f_in(1:nz,nys:nyn,nxl:nxr), f_out(0:nx,nys_x:nyn_x,nzb_x:nzt_x), &
    494530             work(nnx*nny*nnz)
    495531
    496 #if defined( __parallel )
     532    !$acc declare create ( f_inv )
     533    REAL ::  f_inv(nys:nyn,nxl:nxr,1:nz)
     534
    497535
    498536!
     
    501539!$OMP  PARALLEL PRIVATE ( i, j, k )
    502540!$OMP  DO
     541    !$acc kernels present( f_in )
     542    !$acc loop
    503543    DO  k = 1,nz
    504544       DO  i = nxl, nxr
     545          !$acc loop vector( 32 )
    505546          DO  j = nys, nyn
    506547             f_inv(j,i,k) = f_in(k,j,i)
     
    516557!-- of the data is necessary and no transposition has to be done.
    517558    IF ( pdims(1) == 1 )  THEN
    518 !$OMP  PARALLEL PRIVATE ( i, j, k )
    519 !$OMP  DO
     559
     560!$OMP  PARALLEL PRIVATE ( i, j, k )
     561!$OMP  DO
     562       !$acc kernels present( f_out )
     563       !$acc loop
    520564       DO  k = 1, nz
    521565          DO  i = nxl, nxr
     566             !$acc loop vector( 32 )
    522567             DO  j = nys, nyn
    523568                f_out(i,j,k) = f_inv(j,i,k)
     
    526571       ENDDO
    527572!$OMP  END PARALLEL
    528        RETURN
     573
     574    ELSE
     575
     576#if defined( __parallel )
     577!
     578!--    Transpose array
     579       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
     580       IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
     581       CALL MPI_ALLTOALL( f_inv(nys,nxl,1), sendrecvcount_zx, MPI_REAL, &
     582                          work(1),          sendrecvcount_zx, MPI_REAL, &
     583                          comm1dx, ierr )
     584       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
     585
     586!
     587!--    Reorder transposed array
     588!$OMP  PARALLEL PRIVATE ( i, j, k, l, m, xs )
     589!$OMP  DO
     590       DO  l = 0, pdims(1) - 1
     591          m  = l * ( nzt_x - nzb_x + 1 ) * nnx * ( nyn_x - nys_x + 1 )
     592          xs = 0 + l * nnx
     593          DO  k = nzb_x, nzt_x
     594             DO  i = xs, xs + nnx - 1
     595                DO  j = nys_x, nyn_x
     596                   m = m + 1
     597                   f_out(i,j,k) = work(m)
     598                ENDDO
     599             ENDDO
     600          ENDDO
     601       ENDDO
     602!$OMP  END PARALLEL
     603#endif
     604
    529605    ENDIF
    530 
    531 !
    532 !-- Transpose array
    533     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'start' )
    534     IF ( collective_wait )  CALL MPI_BARRIER( comm2d, ierr )
    535     CALL MPI_ALLTOALL( f_inv(nys,nxl,1), sendrecvcount_zx, MPI_REAL, &
    536                        work(1),          sendrecvcount_zx, MPI_REAL, &
    537                        comm1dx, ierr )
    538     CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
    539 
    540 !
    541 !-- Reorder transposed array
    542 !$OMP  PARALLEL PRIVATE ( i, j, k, l, m, xs )
    543 !$OMP  DO
    544     DO  l = 0, pdims(1) - 1
    545        m  = l * ( nzt_x - nzb_x + 1 ) * nnx * ( nyn_x - nys_x + 1 )
    546        xs = 0 + l * nnx
    547        DO  k = nzb_x, nzt_x
    548           DO  i = xs, xs + nnx - 1
    549              DO  j = nys_x, nyn_x
    550                 m = m + 1
    551                 f_out(i,j,k) = work(m)
    552              ENDDO
    553           ENDDO
    554        ENDDO
    555     ENDDO
    556 !$OMP  END PARALLEL
    557 
    558 #endif
    559606
    560607 END SUBROUTINE transpose_zx
     
    586633             work(nnx*nny*nnz)
    587634
    588 #if defined( __parallel )
    589 
    590635!
    591636!-- If the PE grid is one-dimensional along y, the array has only to be
    592637!-- reordered locally and therefore no transposition has to be done.
    593638    IF ( pdims(1) /= 1 )  THEN
     639
     640#if defined( __parallel )
    594641!
    595642!--    Reorder input array for transposition
     
    619666                          comm1dx, ierr )
    620667       CALL cpu_log( log_point_s(32), 'mpi_alltoall', 'stop' )
    621 
    622 !
    623 !--    Reorder transposed array in a way that the y index is in first position
    624 !$OMP  PARALLEL PRIVATE ( i, j, k )
    625 !$OMP  DO
    626        DO  j = 0, ny
    627           DO  k = nzb_y, nzt_y
    628              DO  i = nxl_y, nxr_y
    629                 f_out(j,i,k) = f_inv(i,k,j)
    630              ENDDO
    631           ENDDO
    632        ENDDO
    633 !$OMP  END PARALLEL
     668#endif
     669
    634670    ELSE
    635671!
    636 !--    Reorder the array in a way that the y index is in first position
     672!--    Reorder the array in the same way like ALLTOALL did it
    637673!$OMP  PARALLEL PRIVATE ( i, j, k )
    638674!$OMP  DO
     
    645681       ENDDO
    646682!$OMP  END PARALLEL
    647 !
    648 !--    Move data to output array
    649 !$OMP  PARALLEL PRIVATE ( i, j, k )
    650 !$OMP  DO
    651        DO  k = nzb_y, nzt_y
    652           DO  i = nxl_y, nxr_y
    653              DO  j = 0, ny
    654                 f_out(j,i,k) = f_inv(i,k,j)
    655              ENDDO
    656           ENDDO
    657        ENDDO
    658 !$OMP  END PARALLEL
    659683
    660684    ENDIF
    661685
    662 #endif
     686!
     687!-- Reorder transposed array in a way that the y index is in first position
     688!$OMP  PARALLEL PRIVATE ( i, j, k )
     689!$OMP  DO
     690    DO  k = nzb_y, nzt_y
     691       DO  i = nxl_y, nxr_y
     692          DO  j = 0, ny
     693             f_out(j,i,k) = f_inv(i,k,j)
     694          ENDDO
     695       ENDDO
     696    ENDDO
     697!$OMP  END PARALLEL
    663698
    664699 END SUBROUTINE transpose_zy
Note: See TracChangeset for help on using the changeset viewer.