SURFEX v8.1
General documentation of Surfex
mpl_recv_mod.F90
Go to the documentation of this file.
1 #ifdef RS6K
2 @process nocheck
3 #endif
4 
5 MODULE mpl_recv_mod
6 
7 !**** MPL_RECV Receive a message
8 
9 ! Purpose.
10 ! --------
11 ! Receive a message from a named source into a buffer.
12 ! The data may be REAL*4, REAL*8,or INTEGER, one dimensional array
13 ! REAL*4,or REAL*8, two dimensional array
14 ! or REAL or INTEGER scalar
15 
16 !** Interface.
17 ! ----------
18 ! CALL MPL_RECV
19 
20 ! Input required arguments :
21 ! -------------------------
22 ! PBUF - buffer to receive the message
23 ! (can be type REAL*4, REAL*8 or INTEGER)
24 
25 ! Input optional arguments :
26 ! -------------------------
27 ! KTAG - message tag
28 ! KCOMM - Communicator number if different from MPI_COMM_WORLD
29 ! KMP_TYPE - buffering type (see MPL_BUFFER_METHOD)
30 ! overrides value provided to MPL_BUFFER_METHOD
31 ! KSOURCE - rank of process sending the message
32 ! default is MPI_ANY_SOURCE
33 ! CDSTRING - Character string for ABORT messages
34 ! used when KERROR is not provided
35 
36 ! Output required arguments :
37 ! -------------------------
38 ! none
39 
40 ! Output optional arguments :
41 ! -------------------------
42 ! KREQUEST - Communication request
43 ! required when buffering type is non-blocking
44 ! KFROM - rank of process sending the message
45 ! KRECVTAG - tag of received message
46 ! KOUNT - number of items in received message
47 ! KERROR - return error code. If not supplied,
48 ! MPL_RECV aborts when an error is detected.
49 ! Author.
50 ! -------
51 ! D.Dent, M.Hamrud ECMWF
52 
53 ! Modifications.
54 ! --------------
55 ! Original: 2000-09-01
56 ! F. Vana 05-Mar-2015 Support for single precision
57 
58 ! ------------------------------------------------------------------
59 
60 USE parkind1 , ONLY : jprd, jpib, jpim, jprm
61 
62 USE mpl_mpif
63 USE mpl_data_module
64 USE mpl_stats_mod
65 USE yommplstats
66 USE mpl_message_mod
67 USE mpl_nproc_mod
68 
69 IMPLICIT NONE
70 
71 PRIVATE
72 
73 INTERFACE mpl_recv
74 MODULE PROCEDURE mpl_recv_real4, mpl_recv_real8, &
75  & mpl_recv_int, mpl_recv_real42, mpl_recv_real43, &
76  & mpl_recv_real82, mpl_recv_real83, mpl_recv_int_scalar, &
77  & mpl_recv_int2, mpl_recv_real4_scalar, &
78  & mpl_recv_real8_scalar, mpl_recv_char_scalar, &
79  & mpl_recv_int8, mpl_recv_char
80 END INTERFACE
81 
82 PUBLIC mpl_recv
83 
84 CONTAINS
85 
86 ! ------------------------------------------------------------------
87 
88 SUBROUTINE mpl_recv_preamb(KMP_TYPER,KCOMMR,KSOURCER,KTAGR,KMP_TYPE,KCOMM,KSOURCE,KTAG,KREQUEST)
89 INTEGER(KIND=JPIM),INTENT(OUT) :: KMP_TYPER,KCOMMR,KSOURCER,KTAGR
90 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KMP_TYPE,KCOMM,KSOURCE,KTAG
91 INTEGER(KIND=JPIM),OPTIONAL :: KREQUEST
92 
93 LOGICAL :: LLABORT=.true.
94 INTEGER(KIND=JPIM) :: ITID
95 
96 itid = oml_my_thread()
97 
98 IF(mpl_numproc < 1) CALL mpl_message(&
99  & cdmessage='MPL_RECV: MPL NOT INITIALISED ',ldabort=llabort)
100 
101 IF(PRESENT(kmp_type)) THEN
102  kmp_typer=kmp_type
103 ELSE
104  kmp_typer=mpl_method
105 ENDIF
106 
107 IF(kmp_typer == jp_non_blocking_standard) THEN
108  IF( .NOT. PRESENT(krequest)) THEN
109  CALL mpl_message(cdmessage='MPL_RECV:KREQUEST MISSING ',ldabort=llabort)
110  ENDIF
111 ENDIF
112 
113 IF(PRESENT(kcomm)) THEN
114  kcommr=kcomm
115 ELSE
116  kcommr=mpl_comm_oml(itid)
117 ENDIF
118 
119 IF(PRESENT(ksource)) THEN
120  IF(ksource < 1 .OR. ksource >mpl_nproc(kcommr)) THEN
121  WRITE(mpl_errunit,*)'MPL_RECV: ERROR KSOURCE=',ksource
122  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL KSOURCE ',ldabort=llabort)
123  ENDIF
124  ksourcer=ksource-1
125 ELSE
126  ksourcer=mpi_any_source
127 ENDIF
128 
129 IF(PRESENT(ktag)) THEN
130  ktagr=ktag
131 ELSE
132  ktagr=mpi_any_tag
133 ENDIF
134 
135 END SUBROUTINE mpl_recv_preamb
136 
137 ! ------------------------------------------------------------------
138 
139 SUBROUTINE mpl_recv_tail(KRECV_STATUS,KTYPE,KFROM,KOUNT,KRECVTAG,KERROR,CDSTRING)
140 
141 
142 #ifdef USE_8_BYTE_WORDS
143  USE mpi4to8, ONLY : &
144  mpi_recv => mpi_recv8, mpi_get_count => mpi_get_count8
145 #endif
146 
147 INTEGER(KIND=JPIM),INTENT(IN) :: KRECV_STATUS(mpi_status_size)
148 INTEGER(KIND=JPIM),INTENT(IN) :: KTYPE
149 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KERROR,KFROM,KRECVTAG,KOUNT
150 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
151 
152 INTEGER(KIND=JPIM) :: IMP_TYPE,ICOMM,IERROR
153 INTEGER(KIND=JPIM) :: IFROM,IRECVTAG,IRECVCOUNT
154 LOGICAL :: LLABORT=.true.
155 
156 ifrom=krecv_status(mpi_source)+1
157 IF(PRESENT(kfrom)) THEN
158  kfrom=ifrom
159 ENDIF
160 CALL mpi_get_count(krecv_status,ktype,irecvcount,ierror)
161 IF(PRESENT(kount)) THEN
162  kount=irecvcount
163 ENDIF
164 IF(lmplstats) CALL mpl_recvstats(irecvcount,ktype)
165 irecvtag=krecv_status(mpi_tag)
166 IF(PRESENT(krecvtag)) THEN
167  krecvtag=irecvtag
168 ENDIF
169 !IF(MPL_OUTPUT > 1 )THEN
170 ! WRITE(MPL_UNIT,'(A,5I8)') ' MPL_RECV ',IRECVCOUNT,IMP_TYPE,IFROM,IRECVTAG,ICOMM
171 !ENDIF
172 IF(PRESENT(kerror)) THEN
173  kerror=ierror
174 ELSE
175  IF(ierror /= 0 ) CALL mpl_message(ierror,'MPL_RECV',cdstring,ldabort=llabort)
176 ENDIF
177 
178 END SUBROUTINE mpl_recv_tail
179 
180 ! ------------------------------------------------------------------
181 
182 SUBROUTINE mpl_recv_real4(PBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
183  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
184 
185 
186 #ifdef USE_8_BYTE_WORDS
187  USE mpi4to8, ONLY : &
188  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
189 #endif
190 
191 
192 REAL(KIND=JPRM) :: PBUF(:)
193 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
194 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
195 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
196 
197 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
198 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
199 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
200 LOGICAL :: LLABORT=.true.
201 INTEGER(KIND=JPIM) :: ITID
202 REAL(KIND=JPRM) :: ZDUM(1)
203 itid = oml_my_thread()
204 
205 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
206 
207 ibuffsize = SIZE(pbuf)
208 
209 #ifndef NAG
210 IF (ibuffsize > 0) THEN
211  IF( (loc(pbuf(ubound(pbuf,1))) - loc(pbuf(lbound(pbuf,1)))) /= 4_jpib*(ibuffsize - 1) ) THEN
212  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
213  ENDIF
214 ENDIF
215 #endif
216 
217 IF(ibuffsize == 0) THEN
218  IF(imp_type == jp_blocking_standard) THEN
219  CALL mpi_recv(zdum(1),1,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
220  ELSEIF(imp_type == jp_blocking_buffered) THEN
221  CALL mpi_recv(zdum(1),1,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
222  ELSEIF(imp_type == jp_non_blocking_standard) THEN
223  CALL mpi_irecv(zdum(1),1,int(mpi_real4),isource,itag,icomm, &
224  & krequest,ierror)
225  ELSE
226  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
227  ENDIF
228 ELSE
229  IF(imp_type == jp_blocking_standard) THEN
230  CALL mpi_recv(pbuf(1),ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
231  ELSEIF(imp_type == jp_blocking_buffered) THEN
232  CALL mpi_recv(pbuf(1),ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
233  ELSEIF(imp_type == jp_non_blocking_standard) THEN
234  CALL mpi_irecv(pbuf(1),ibuffsize,int(mpi_real4),isource,itag,icomm, &
235  & krequest,ierror)
236  ELSE
237  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
238  ENDIF
239 ENDIF
240 
241 IF(imp_type /= jp_non_blocking_standard) THEN
242  CALL mpl_recv_tail(irecv_status,int(mpi_real4),kfrom,kount,krecvtag,kerror,cdstring)
243 ELSE
244  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real4))
245 ENDIF
246 
247 END SUBROUTINE mpl_recv_real4
248 
249 ! ------------------------------------------------------------------
250 
251 SUBROUTINE mpl_recv_real8(PBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
252  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
253 
254 #ifdef USE_8_BYTE_WORDS
255  USE mpi4to8, ONLY : &
256  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
257 #endif
258 
259 ! real_b,intent(in) :: PBUF(:)
260 REAL(KIND=JPRD) :: PBUF(:)
261 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
262 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
263 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
264 
265 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
266 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
267 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
268 LOGICAL :: LLABORT=.true.
269 INTEGER(KIND=JPIM) :: ITID
270 REAL(KIND=JPRD) :: ZDUM(1)
271 itid = oml_my_thread()
272 
273 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
274 
275 ibuffsize = SIZE(pbuf)
276 #ifndef NAG
277 IF (ibuffsize > 0) THEN
278  IF( (loc(pbuf(ubound(pbuf,1))) - loc(pbuf(lbound(pbuf,1)))) /= 8_jpib*(ibuffsize - 1) ) THEN
279  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
280  ENDIF
281 ENDIF
282 #endif
283 
284 IF(ibuffsize == 0) THEN
285  IF(imp_type == jp_blocking_standard) THEN
286  CALL mpi_recv(zdum(1),1,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
287  ELSEIF(imp_type == jp_blocking_buffered) THEN
288  CALL mpi_recv(zdum(1),1,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
289  ELSEIF(imp_type == jp_non_blocking_standard) THEN
290  CALL mpi_irecv(zdum(1),1,int(mpi_real8),isource,itag,icomm, &
291  & krequest,ierror)
292  ELSE
293  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
294  ENDIF
295 ELSE
296  IF(imp_type == jp_blocking_standard) THEN
297  CALL mpi_recv(pbuf(1),ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
298  ELSEIF(imp_type == jp_blocking_buffered) THEN
299  CALL mpi_recv(pbuf(1),ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
300  ELSEIF(imp_type == jp_non_blocking_standard) THEN
301  CALL mpi_irecv(pbuf(1),ibuffsize,int(mpi_real8),isource,itag,icomm, &
302  & krequest,ierror)
303  ELSE
304  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
305  ENDIF
306 ENDIF
307 
308 IF(imp_type /= jp_non_blocking_standard) THEN
309  CALL mpl_recv_tail(irecv_status,int(mpi_real8),kfrom,kount,krecvtag,kerror,cdstring)
310 ELSE
311  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real8))
312 ENDIF
313 
314 END SUBROUTINE mpl_recv_real8
315 
316 ! ------------------------------------------------------------------
317 
318 SUBROUTINE mpl_recv_int(KBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,KOUNT,&
319  &KMP_TYPE,KERROR,KREQUEST,CDSTRING)
320 
321 #ifdef USE_8_BYTE_WORDS
322  USE mpi4to8, ONLY : &
323  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
324 #endif
325 
326 INTEGER(KIND=JPIM) :: KBUF(:)
327 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
328 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
329 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
330 
331 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
332 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
333 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
334 LOGICAL :: LLABORT=.true.
335 INTEGER(KIND=JPIM) :: ITID,IDUM(1)
336 itid = oml_my_thread()
337 
338 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
339 
340 ibuffsize = SIZE(kbuf)
341 #ifndef NAG
342 IF (ibuffsize > 0) THEN
343  IF( (loc(kbuf(ubound(kbuf,1)))-loc(kbuf(lbound(kbuf,1)))) /= 4_jpib*(ibuffsize - 1) ) THEN
344  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
345  ENDIF
346 ENDIF
347 #endif
348 
349 IF(ibuffsize == 0) THEN
350  IF(imp_type == jp_blocking_standard) THEN
351  CALL mpi_recv(idum(1),1,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
352  ELSEIF(imp_type == jp_blocking_buffered) THEN
353  CALL mpi_recv(idum(1),1,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
354  ELSEIF(imp_type == jp_non_blocking_standard) THEN
355  CALL mpi_irecv(idum(1),1,int(mpi_integer),isource,itag,icomm, &
356  & krequest,ierror)
357  ELSE
358  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
359  ENDIF
360 ELSE
361  IF(imp_type == jp_blocking_standard) THEN
362  CALL mpi_recv(kbuf(1),ibuffsize,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
363  ELSEIF(imp_type == jp_blocking_buffered) THEN
364  CALL mpi_recv(kbuf(1),ibuffsize,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
365  ELSEIF(imp_type == jp_non_blocking_standard) THEN
366  CALL mpi_irecv(kbuf(1),ibuffsize,int(mpi_integer),isource,itag,icomm, &
367  & krequest,ierror)
368  ELSE
369  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
370  ENDIF
371 ENDIF
372 IF(imp_type /= jp_non_blocking_standard) THEN
373  CALL mpl_recv_tail(irecv_status,int(mpi_integer),kfrom,kount,krecvtag,kerror,cdstring)
374 ELSE
375  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_integer))
376 ENDIF
377 
378 END SUBROUTINE mpl_recv_int
379 
380 SUBROUTINE mpl_recv_int8(KBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,KOUNT,&
381  &KMP_TYPE,KERROR,KREQUEST,CDSTRING)
382 
383 #ifdef USE_8_BYTE_WORDS
384  USE mpi4to8, ONLY : &
385  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
386 #endif
387 
388 INTEGER(KIND=JPIB) :: KBUF(:)
389 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
390 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
391 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
392 
393 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
394 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
395 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
396 LOGICAL :: LLABORT=.true.
397 INTEGER(KIND=JPIM) :: ITID
398 INTEGER(KIND=JPIB) :: IDUM(1)
399 itid = oml_my_thread()
400 
401 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
402 
403 ibuffsize = SIZE(kbuf)
404 #ifndef NAG
405 IF (ibuffsize > 0) THEN
406  IF( (loc(kbuf(ubound(kbuf,1)))-loc(kbuf(lbound(kbuf,1)))) /= 8_jpib*(ibuffsize - 1) ) THEN
407  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
408  ENDIF
409 ENDIF
410 #endif
411 
412 IF(ibuffsize == 0 ) THEN
413  IF(imp_type == jp_blocking_standard) THEN
414  CALL mpi_recv(idum(1),1,int(mpi_integer8),isource,itag,icomm,irecv_status,ierror)
415  ELSEIF(imp_type == jp_blocking_buffered) THEN
416  CALL mpi_recv(idum(1),1,int(mpi_integer8),isource,itag,icomm,irecv_status,ierror)
417  ELSEIF(imp_type == jp_non_blocking_standard) THEN
418  CALL mpi_irecv(idum(1),1,int(mpi_integer8),isource,itag,icomm, &
419  & krequest,ierror)
420  ELSE
421  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
422  ENDIF
423 ELSE
424  IF(imp_type == jp_blocking_standard) THEN
425  CALL mpi_recv(kbuf(1),ibuffsize,int(mpi_integer8),isource,itag,icomm,irecv_status,ierror)
426  ELSEIF(imp_type == jp_blocking_buffered) THEN
427  CALL mpi_recv(kbuf(1),ibuffsize,int(mpi_integer8),isource,itag,icomm,irecv_status,ierror)
428  ELSEIF(imp_type == jp_non_blocking_standard) THEN
429  CALL mpi_irecv(kbuf(1),ibuffsize,int(mpi_integer8),isource,itag,icomm, &
430  & krequest,ierror)
431  ELSE
432  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
433  ENDIF
434 ENDIF
435 
436 IF(imp_type /= jp_non_blocking_standard) THEN
437  CALL mpl_recv_tail(irecv_status,int(mpi_integer8),kfrom,kount,krecvtag,kerror,cdstring)
438 ELSE
439  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_integer8))
440 ENDIF
441 
442 END SUBROUTINE mpl_recv_int8
443 
444 ! ------------------------------------------------------------------
445 
446 SUBROUTINE mpl_recv_int2(KBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
447  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
448 
449 #ifdef USE_8_BYTE_WORDS
450  USE mpi4to8, ONLY : &
451  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
452 #endif
453 
454 INTEGER(KIND=JPIM) :: KBUF(:,:)
455 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
456 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
457 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
458 
459 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
460 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
461 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
462 LOGICAL :: LLABORT=.true.
463 INTEGER(KIND=JPIM) :: ITID, IDUM(1)
464 itid = oml_my_thread()
465 
466 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
467 
468 ibuffsize = SIZE(kbuf)
469 #ifndef NAG
470 IF (ibuffsize > 0) THEN
471  IF( (loc(kbuf(ubound(kbuf,1),ubound(kbuf,2))) - &
472  & loc(kbuf(lbound(kbuf,1),lbound(kbuf,2)))) /= 4_jpib*(ibuffsize - 1) ) THEN
473  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
474  ENDIF
475 ENDIF
476 #endif
477 
478 IF(ibuffsize == 0 ) THEN
479  IF(imp_type == jp_blocking_standard) THEN
480  CALL mpi_recv(idum(1),1,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
481  ELSEIF(imp_type == jp_blocking_buffered) THEN
482  CALL mpi_recv(idum(1),1,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
483  ELSEIF(imp_type == jp_non_blocking_standard) THEN
484  CALL mpi_irecv(idum(1),1,int(mpi_integer),isource,itag,icomm, &
485  & krequest,ierror)
486  ELSE
487  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
488  ENDIF
489 ELSE
490  IF(imp_type == jp_blocking_standard) THEN
491  CALL mpi_recv(kbuf(1,1),ibuffsize,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
492  ELSEIF(imp_type == jp_blocking_buffered) THEN
493  CALL mpi_recv(kbuf(1,1),ibuffsize,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
494  ELSEIF(imp_type == jp_non_blocking_standard) THEN
495  CALL mpi_irecv(kbuf(1,1),ibuffsize,int(mpi_integer),isource,itag,icomm, &
496  & krequest,ierror)
497  ELSE
498  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
499  ENDIF
500 ENDIF
501 
502 IF(imp_type /= jp_non_blocking_standard) THEN
503  CALL mpl_recv_tail(irecv_status,int(mpi_integer),kfrom,kount,krecvtag,kerror,cdstring)
504 ELSE
505  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_integer))
506 ENDIF
507 
508 END SUBROUTINE mpl_recv_int2
509 
510 ! ------------------------------------------------------------------
511 
512 SUBROUTINE mpl_recv_int_scalar(KINT,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
513  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
514 
515 #ifdef USE_8_BYTE_WORDS
516  USE mpi4to8, ONLY : &
517  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
518 #endif
519 
520 INTEGER(KIND=JPIM) :: KINT
521 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
522 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
523 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
524 
525 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
526 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
527 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
528 LOGICAL :: LLABORT=.true.
529 INTEGER(KIND=JPIM) :: ITID
530 itid = oml_my_thread()
531 
532 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
533 
534 ibuffsize = 1
535 
536 IF(imp_type == jp_blocking_standard) THEN
537  CALL mpi_recv(kint,ibuffsize,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
538 ELSEIF(imp_type == jp_blocking_buffered) THEN
539  CALL mpi_recv(kint,ibuffsize,int(mpi_integer),isource,itag,icomm,irecv_status,ierror)
540 ELSEIF(imp_type == jp_non_blocking_standard) THEN
541  CALL mpi_irecv(kint,ibuffsize,int(mpi_integer),isource,itag,icomm, &
542  & krequest,ierror)
543 ELSE
544  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
545 ENDIF
546 
547 IF(imp_type /= jp_non_blocking_standard) THEN
548  CALL mpl_recv_tail(irecv_status,int(mpi_integer),kfrom,kount,krecvtag,kerror,cdstring)
549 ELSE
550  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_integer))
551 ENDIF
552 
553 END SUBROUTINE mpl_recv_int_scalar
554 
555 ! ------------------------------------------------------------------
556 
557 SUBROUTINE mpl_recv_real4_scalar(PREAL4,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
558  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
559 
560 
561 #ifdef USE_8_BYTE_WORDS
562  USE mpi4to8, ONLY : &
563  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
564 #endif
565 
566 
567 REAL(KIND=JPRM) :: PREAL4
568 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
569 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
570 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
571 
572 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
573 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
574 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
575 LOGICAL :: LLABORT=.true.
576 INTEGER(KIND=JPIM) :: ITID
577 itid = oml_my_thread()
578 
579 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
580 
581 ibuffsize = 1
582 
583 IF(imp_type == jp_blocking_standard) THEN
584  CALL mpi_recv(preal4,ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
585 ELSEIF(imp_type == jp_blocking_buffered) THEN
586  CALL mpi_recv(preal4,ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
587 ELSEIF(imp_type == jp_non_blocking_standard) THEN
588  CALL mpi_irecv(preal4,ibuffsize,int(mpi_real4),isource,itag,icomm, &
589  & krequest,ierror)
590 ELSE
591  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
592 ENDIF
593 
594 IF(imp_type /= jp_non_blocking_standard) THEN
595  CALL mpl_recv_tail(irecv_status,int(mpi_real4),kfrom,kount,krecvtag,kerror,cdstring)
596 ELSE
597  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real4))
598 ENDIF
599 
600 END SUBROUTINE mpl_recv_real4_scalar
601 
602 ! ------------------------------------------------------------------
603 
604 SUBROUTINE mpl_recv_real8_scalar(PREAL8,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
605  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
606 
607 #ifdef USE_8_BYTE_WORDS
608  USE mpi4to8, ONLY : &
609  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
610 #endif
611 
612 REAL(KIND=JPRD) :: PREAL8
613 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
614 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
615 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
616 
617 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
618 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
619 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
620 LOGICAL :: LLABORT=.true.
621 INTEGER(KIND=JPIM) :: ITID
622 itid = oml_my_thread()
623 
624 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
625 
626 ibuffsize = 1
627 
628 IF(imp_type == jp_blocking_standard) THEN
629  CALL mpi_recv(preal8,ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
630 ELSEIF(imp_type == jp_blocking_buffered) THEN
631  CALL mpi_recv(preal8,ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
632 ELSEIF(imp_type == jp_non_blocking_standard) THEN
633  CALL mpi_irecv(preal8,ibuffsize,int(mpi_real8),isource,itag,icomm, &
634  & krequest,ierror)
635 ELSE
636  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
637 ENDIF
638 
639 IF(imp_type /= jp_non_blocking_standard) THEN
640  CALL mpl_recv_tail(irecv_status,int(mpi_real8),kfrom,kount,krecvtag,kerror,cdstring)
641 ELSE
642  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real8))
643 ENDIF
644 
645 END SUBROUTINE mpl_recv_real8_scalar
646 
647 ! ------------------------------------------------------------------
648 
649 SUBROUTINE mpl_recv_real42(PBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
650  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
651 
652 
653 #ifdef USE_8_BYTE_WORDS
654  USE mpi4to8, ONLY : &
655  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
656 #endif
657 
658 
659 REAL(KIND=JPRM) :: PBUF(:,:)
660 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
661 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
662 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
663 
664 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
665 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
666 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
667 LOGICAL :: LLABORT=.true.
668 INTEGER(KIND=JPIM) :: ITID
669 REAL(KIND=JPRM) :: ZDUM(1)
670 itid = oml_my_thread()
671 
672 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
673 
674 ibuffsize = SIZE(pbuf)
675 #ifndef NAG
676 IF (ibuffsize > 0) THEN
677  IF( (loc(pbuf(ubound(pbuf,1),ubound(pbuf,2))) - &
678  & loc(pbuf(lbound(pbuf,1),lbound(pbuf,2)))) /= 4_jpib*(ibuffsize - 1) ) THEN
679  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
680  ENDIF
681 ENDIF
682 #endif
683 
684 IF(ibuffsize == 0) THEN
685  IF(imp_type == jp_blocking_standard) THEN
686  CALL mpi_recv(zdum(1),1,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
687  ELSEIF(imp_type == jp_blocking_buffered) THEN
688  CALL mpi_recv(zdum(1),1,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
689  ELSEIF(imp_type == jp_non_blocking_standard) THEN
690  CALL mpi_irecv(zdum(1),1,int(mpi_real4),isource,itag,icomm, &
691  & krequest,ierror)
692  ELSE
693  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
694  ENDIF
695 ELSE
696  IF(imp_type == jp_blocking_standard) THEN
697  CALL mpi_recv(pbuf(1,1),ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
698  ELSEIF(imp_type == jp_blocking_buffered) THEN
699  CALL mpi_recv(pbuf(1,1),ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
700  ELSEIF(imp_type == jp_non_blocking_standard) THEN
701  CALL mpi_irecv(pbuf(1,1),ibuffsize,int(mpi_real4),isource,itag,icomm, &
702  & krequest,ierror)
703  ELSE
704  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
705  ENDIF
706 ENDIF
707 
708 IF(imp_type /= jp_non_blocking_standard) THEN
709  CALL mpl_recv_tail(irecv_status,int(mpi_real4),kfrom,kount,krecvtag,kerror,cdstring)
710 ELSE
711  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real4))
712 ENDIF
713 
714 END SUBROUTINE mpl_recv_real42
715 
716 SUBROUTINE mpl_recv_real43(PBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
717  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
718 
719 #ifdef USE_8_BYTE_WORDS
720  USE mpi4to8, ONLY : &
721  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
722 #endif
723 
724 REAL(KIND=JPRM) :: PBUF(:,:,:)
725 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
726 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
727 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
728 
729 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
730 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
731 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
732 LOGICAL :: LLABORT=.true.
733 INTEGER(KIND=JPIM) :: ITID
734 itid = oml_my_thread()
735 
736 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
737 
738 ibuffsize = SIZE(pbuf)
739 
740 IF (ibuffsize > 0) THEN
741  IF( (loc(pbuf(ubound(pbuf,1),ubound(pbuf,2),ubound(pbuf,3))) - &
742  & loc(pbuf(lbound(pbuf,1),lbound(pbuf,2),lbound(pbuf,3)))) /= 4_jpib*(ibuffsize - 1) ) THEN
743  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
744  ENDIF
745 ENDIF
746 
747 IF(imp_type == jp_blocking_standard) THEN
748  CALL mpi_recv(pbuf,ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
749 ELSEIF(imp_type == jp_blocking_buffered) THEN
750  CALL mpi_recv(pbuf,ibuffsize,int(mpi_real4),isource,itag,icomm,irecv_status,ierror)
751 ELSEIF(imp_type == jp_non_blocking_standard) THEN
752  CALL mpi_irecv(pbuf,ibuffsize,int(mpi_real4),isource,itag,icomm, &
753  & krequest,ierror)
754 ELSE
755  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
756 ENDIF
757 
758 IF(imp_type /= jp_non_blocking_standard) THEN
759  CALL mpl_recv_tail(irecv_status,int(mpi_real4),kfrom,kount,krecvtag,kerror,cdstring)
760 ELSE
761  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real4))
762 ENDIF
763 
764 END SUBROUTINE mpl_recv_real43
765 
766 
767 ! ------------------------------------------------------------------
768 
769 SUBROUTINE mpl_recv_real82(PBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
770  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
771 
772 #ifdef USE_8_BYTE_WORDS
773  USE mpi4to8, ONLY : &
774  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
775 #endif
776 
777 REAL(KIND=JPRD) :: PBUF(:,:)
778 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
779 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
780 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
781 
782 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
783 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
784 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
785 LOGICAL :: LLABORT=.true.
786 INTEGER(KIND=JPIM) :: ITID
787 REAL(KIND=JPRD) :: ZDUM(1)
788 itid = oml_my_thread()
789 
790 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
791 
792 ibuffsize = SIZE(pbuf)
793 #ifndef NAG
794 IF (ibuffsize > 0) THEN
795  IF( (loc(pbuf(ubound(pbuf,1),ubound(pbuf,2))) - &
796  & loc(pbuf(lbound(pbuf,1),lbound(pbuf,2)))) /= 8_jpib*(ibuffsize - 1) ) THEN
797  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
798  ENDIF
799 ENDIF
800 #endif
801 
802 IF(ibuffsize == 0) THEN
803  IF(imp_type == jp_blocking_standard) THEN
804  CALL mpi_recv(zdum(1),1,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
805  ELSEIF(imp_type == jp_blocking_buffered) THEN
806  CALL mpi_recv(zdum(1),1,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
807  ELSEIF(imp_type == jp_non_blocking_standard) THEN
808  CALL mpi_irecv(zdum(1),1,int(mpi_real8),isource,itag,icomm, &
809  & krequest,ierror)
810  ELSE
811  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
812  ENDIF
813 ELSE
814  IF(imp_type == jp_blocking_standard) THEN
815  CALL mpi_recv(pbuf(1,1),ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
816  ELSEIF(imp_type == jp_blocking_buffered) THEN
817  CALL mpi_recv(pbuf(1,1),ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
818  ELSEIF(imp_type == jp_non_blocking_standard) THEN
819  CALL mpi_irecv(pbuf(1,1),ibuffsize,int(mpi_real8),isource,itag,icomm, &
820  & krequest,ierror)
821  ELSE
822  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
823  ENDIF
824 ENDIF
825 
826 IF(imp_type /= jp_non_blocking_standard) THEN
827  CALL mpl_recv_tail(irecv_status,int(mpi_real8),kfrom,kount,krecvtag,kerror,cdstring)
828 ELSE
829  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real8))
830 ENDIF
831 
832 END SUBROUTINE mpl_recv_real82
833 
834 SUBROUTINE mpl_recv_real83(PBUF,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
835  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
836 
837 #ifdef USE_8_BYTE_WORDS
838  USE mpi4to8, ONLY : &
839  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
840 #endif
841 
842 REAL(KIND=JPRD) :: PBUF(:,:,:)
843 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
844 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
845 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
846 
847 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
848 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
849 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
850 LOGICAL :: LLABORT=.true.
851 INTEGER(KIND=JPIM) :: ITID
852 itid = oml_my_thread()
853 
854 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
855 
856 ibuffsize = SIZE(pbuf)
857 
858 IF (ibuffsize > 0) THEN
859  IF( (loc(pbuf(ubound(pbuf,1),ubound(pbuf,2),ubound(pbuf,3))) - &
860  & loc(pbuf(lbound(pbuf,1),lbound(pbuf,2),lbound(pbuf,3)))) /= 8_jpib*(ibuffsize - 1) ) THEN
861  CALL mpl_message(cdmessage='MPL_RECV: BUFFER NOT CONTIGUOUS ',ldabort=llabort)
862  ENDIF
863 ENDIF
864 
865 IF(imp_type == jp_blocking_standard) THEN
866  CALL mpi_recv(pbuf,ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
867 ELSEIF(imp_type == jp_blocking_buffered) THEN
868  CALL mpi_recv(pbuf,ibuffsize,int(mpi_real8),isource,itag,icomm,irecv_status,ierror)
869 ELSEIF(imp_type == jp_non_blocking_standard) THEN
870  CALL mpi_irecv(pbuf,ibuffsize,int(mpi_real8),isource,itag,icomm, &
871  & krequest,ierror)
872 ELSE
873  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
874 ENDIF
875 
876 IF(imp_type /= jp_non_blocking_standard) THEN
877  CALL mpl_recv_tail(irecv_status,int(mpi_real8),kfrom,kount,krecvtag,kerror,cdstring)
878 ELSE
879  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_real8))
880 ENDIF
881 
882 END SUBROUTINE mpl_recv_real83
883 
884 ! ------------------------------------------------------------------
885 
886 SUBROUTINE mpl_recv_char_scalar(CDCHAR,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
887  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
888 
889 #ifdef USE_8_BYTE_WORDS
890  USE mpi4to8, ONLY : &
891  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
892 #endif
893 
894 CHARACTER*(*) :: CDCHAR
895 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
896 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
897 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
898 
899 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
900 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
901 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
902 LOGICAL :: LLABORT=.true.
903 INTEGER(KIND=JPIM) :: ITID
904 itid = oml_my_thread()
905 
906 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
907 
908 ibuffsize = len(cdchar)
909 
910 IF(imp_type == jp_blocking_standard) THEN
911  CALL mpi_recv(cdchar,ibuffsize,int(mpi_byte),isource,itag,icomm,irecv_status,ierror)
912 ELSEIF(imp_type == jp_blocking_buffered) THEN
913  CALL mpi_recv(cdchar,ibuffsize,int(mpi_byte),isource,itag,icomm,irecv_status,ierror)
914 ELSEIF(imp_type == jp_non_blocking_standard) THEN
915  CALL mpi_irecv(cdchar,ibuffsize,int(mpi_byte),isource,itag,icomm, &
916  & krequest,ierror)
917 ELSE
918  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
919 ENDIF
920 
921 IF(imp_type /= jp_non_blocking_standard) THEN
922  CALL mpl_recv_tail(irecv_status,int(mpi_byte),kfrom,kount,krecvtag,kerror,cdstring)
923 ELSE
924  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_byte))
925 ENDIF
926 
927 END SUBROUTINE mpl_recv_char_scalar
928 
929 SUBROUTINE mpl_recv_char(CDCHAR,KSOURCE,KTAG,KCOMM,KFROM,KRECVTAG,&
930  &KOUNT,KMP_TYPE,KERROR,KREQUEST,CDSTRING)
931 
932 #ifdef USE_8_BYTE_WORDS
933  USE mpi4to8, ONLY : &
934  mpi_recv => mpi_recv8, mpi_irecv => mpi_irecv8
935 #endif
936 
937 CHARACTER*(*) :: CDCHAR(:)
938 INTEGER(KIND=JPIM),INTENT(IN),OPTIONAL :: KTAG,KCOMM,KMP_TYPE,KSOURCE
939 INTEGER(KIND=JPIM),INTENT(OUT),OPTIONAL :: KREQUEST,KERROR,KFROM,KRECVTAG,KOUNT
940 CHARACTER*(*),INTENT(IN),OPTIONAL :: CDSTRING
941 
942 INTEGER(KIND=JPIM) :: IBUFFSIZE,IMP_TYPE,ICOMM,IERROR
943 INTEGER(KIND=JPIM) :: ISOURCE,ITAG
944 INTEGER(KIND=JPIM) :: IRECV_STATUS(mpi_status_size)
945 LOGICAL :: LLABORT=.true.
946 INTEGER(KIND=JPIM) :: ITID
947 itid = oml_my_thread()
948 
949 CALL mpl_recv_preamb(imp_type,icomm,isource,itag,kmp_type,kcomm,ksource,ktag,krequest)
950 
951 ibuffsize = len(cdchar) * SIZE(cdchar)
952 
953 IF(imp_type == jp_blocking_standard) THEN
954  CALL mpi_recv(cdchar,ibuffsize,int(mpi_byte),isource,itag,icomm,irecv_status,ierror)
955 ELSEIF(imp_type == jp_blocking_buffered) THEN
956  CALL mpi_recv(cdchar,ibuffsize,int(mpi_byte),isource,itag,icomm,irecv_status,ierror)
957 ELSEIF(imp_type == jp_non_blocking_standard) THEN
958  CALL mpi_irecv(cdchar,ibuffsize,int(mpi_byte),isource,itag,icomm, &
959  & krequest,ierror)
960 ELSE
961  CALL mpl_message(cdmessage='MPL_RECV:ILLEGAL MP_TYPE ',ldabort=llabort)
962 ENDIF
963 
964 IF(imp_type /= jp_non_blocking_standard) THEN
965  CALL mpl_recv_tail(irecv_status,int(mpi_byte),kfrom,kount,krecvtag,kerror,cdstring)
966 ELSE
967  IF(lmplstats) CALL mpl_recvstats(ibuffsize,int(mpi_byte))
968 ENDIF
969 
970 END SUBROUTINE mpl_recv_char
971 
972 ! ------------------------------------------------------------------
973 
974 END MODULE mpl_recv_mod
mpl_recv_mod::mpl_recv_real4_scalar
subroutine mpl_recv_real4_scalar(PREAL4, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:559
mpl_recv_mod::mpl_recv
Definition: mpl_recv_mod.F90:73
mpl_message_mod::mpl_message
subroutine, public mpl_message(KERROR, CDMESSAGE, CDSTRING, LDABORT)
Definition: mpl_message_mod.F90:54
mpl_data_module::jp_blocking_buffered
integer(kind=jpim), parameter jp_blocking_buffered
Definition: mpl_data_module.F90:61
parkind1::jpim
integer, parameter jpim
Definition: parkind1.F90:13
parkind1::jprd
integer, parameter jprd
Definition: parkind1.F90:39
mpl_stats_mod::mpl_recvstats
subroutine, public mpl_recvstats(ICOUNT, ITYPE)
Definition: mpl_stats_mod.F90:271
mpl_mpif
Definition: mpl_mpif.F90:1
mpl_nproc_mod
Definition: mpl_nproc_mod.F90:1
mpl_data_module::mpl_numproc
integer(kind=jpim) mpl_numproc
Definition: mpl_data_module.F90:40
mpl_stats_mod
Definition: mpl_stats_mod.F90:1
yommplstats::lmplstats
logical lmplstats
Definition: yommplstats.F90:17
mpl_message_mod
Definition: mpl_message_mod.F90:1
mpl_data_module::jp_non_blocking_standard
integer(kind=jpim), parameter jp_non_blocking_standard
Definition: mpl_data_module.F90:64
mpl_recv_mod::mpl_recv_preamb
subroutine mpl_recv_preamb(KMP_TYPER, KCOMMR, KSOURCER, KTAGR, KMP_TYPE, KCOMM, KSOURCE, KTAG, KREQUEST)
Definition: mpl_recv_mod.F90:89
mpl_data_module::mpl_comm_oml
integer(kind=jpim), dimension(:), allocatable mpl_comm_oml
Definition: mpl_data_module.F90:43
mpl_data_module::jp_blocking_standard
integer(kind=jpim), parameter jp_blocking_standard
Definition: mpl_data_module.F90:60
mpl_data_module::mpl_errunit
integer(kind=jpim) mpl_errunit
Definition: mpl_data_module.F90:40
mpl_recv_mod::mpl_recv_int2
subroutine mpl_recv_int2(KBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:448
mpl_recv_mod::mpl_recv_tail
subroutine mpl_recv_tail(KRECV_STATUS, KTYPE, KFROM, KOUNT, KRECVTAG, KERROR, CDSTRING)
Definition: mpl_recv_mod.F90:140
mpl_recv_mod::mpl_recv_char_scalar
subroutine mpl_recv_char_scalar(CDCHAR, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:888
mpl_recv_mod::mpl_recv_int
subroutine mpl_recv_int(KBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:320
parkind1::jprm
integer, parameter jprm
Definition: parkind1.F90:30
mpl_recv_mod::mpl_recv_real42
subroutine mpl_recv_real42(PBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:651
mpl_recv_mod::mpl_recv_real4
subroutine mpl_recv_real4(PBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:184
mpl_recv_mod::mpl_recv_real8_scalar
subroutine mpl_recv_real8_scalar(PREAL8, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:606
mpl_data_module
Definition: mpl_data_module.F90:1
mpl_data_module::mpl_method
integer(kind=jpim) mpl_method
Definition: mpl_data_module.F90:39
mpl_nproc_mod::mpl_nproc
integer(kind=jpim) function, public mpl_nproc(KCOMM)
Definition: mpl_nproc_mod.F90:28
mpl_recv_mod::mpl_recv_int8
subroutine mpl_recv_int8(KBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:382
mpl_recv_mod
Definition: mpl_recv_mod.F90:5
parkind1::jpib
integer, parameter jpib
Definition: parkind1.F90:14
mpl_recv_mod::mpl_recv_real83
subroutine mpl_recv_real83(PBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:836
mpl_recv_mod::mpl_recv_real8
subroutine mpl_recv_real8(PBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:253
mpl_recv_mod::mpl_recv_real43
subroutine mpl_recv_real43(PBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:718
mpl_recv_mod::mpl_recv_int_scalar
subroutine mpl_recv_int_scalar(KINT, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:514
mpl_recv_mod::mpl_recv_real82
subroutine mpl_recv_real82(PBUF, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:771
mpl_recv_mod::mpl_recv_char
subroutine mpl_recv_char(CDCHAR, KSOURCE, KTAG, KCOMM, KFROM, KRECVTAG, KOUNT, KMP_TYPE, KERROR, KREQUEST, CDSTRING)
Definition: mpl_recv_mod.F90:931
Generated on Tue Jan 16 2018 16:23:21 for SURFEX v8.1 by   doxygen 1.8.13