Home

Context Navigation

pmc_parent_mod.f90 @ 4854

Last change on this file since 4854 was 4830, checked in by Giersch, 4 years ago
Reformatted to follow PALM coding standard
Property svn:keywords set to `Id`
File size: 38.8 KB

Line
1	!> @file pmc_parent_mod.f90
2	!--------------------------------------------------------------------------------------------------!
3	! This file is part of the PALM model system.
4	!
5	! PALM is free software: you can redistribute it and/or modify it under the terms of the GNU General
6	! Public License as published by the Free Software Foundation, either version 3 of the License, or
7	! (at your option) any later version.
8	!
9	! PALM is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
10	! implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
11	! Public License for more details.
12	!
13	! You should have received a copy of the GNU General Public License along with PALM. If not, see
14	! <http://www.gnu.org/licenses/>.
15	!
16	! Copyright 1997-2021 Leibniz Universitaet Hannover
17	!--------------------------------------------------------------------------------------------------!
18	!
19	!
20	! Current revisions:
21	! -----------------
22	!
23	!
24	! Former revisions:
25	! -----------------
26	! $Id: pmc_parent_mod.f90 4830 2021-01-06 11:25:45Z suehring $
27	! Reformatted to follow PALM coding standard
28	!
29	! 4828 2021-01-05 11:21:41Z Giersch
30	! pmc_s_set_2d_index_list revised for accelerating the code. Subroutine
31	! description added.
32	!
33	! 4649 2020-08-25 12:11:17Z raasch
34	! File re-formatted to follow the PALM coding standard
35	!
36	!
37	! 4629 2020-07-29 09:37:56Z raasch
38	! Support for MPI Fortran77 interface (mpif.h) removed
39	!
40	! 4360 2020-01-07 11:25:50Z suehring
41	!
42	!
43	! 4213 2019-09-02 14:25:56Z suehring
44	! Allocate array for index_list_2d also for zero-size arrays, in order to avoid errors when array
45	! bound checks are enabled
46	!
47	! 4212 2019-09-02 14:23:05Z suehring
48	! Corrected "Former revisions" section
49	!
50	! 3962 2019-05-08 19:40:33Z suehring
51	! Bugfixes in initial settings of child and parent communication patterns.
52	!
53	! 3655 2019-01-07 16:51:22Z knoop
54	! Explicit kind settings
55	!
56	! 1762 2016-02-25 12:31:13Z hellstea
57	! Initial revision by K. Ketelsen
58	!
59	! Authors:
60	! --------
61	!> @author Klaus Ketelsen (no affiliation)
62	!
63	! Description:
64	! ------------
65	!> Parent part of Palm Model Coupler
66	!--------------------------------------------------------------------------------------------------!
67	MODULE pmc_parent
68
69	#if defined( __parallel )
70	USE, INTRINSIC :: ISO_C_BINDING
71
72	USE MPI
73
74	USE kinds
75
76	USE pmc_general, &
77	ONLY: arraydef, &
78	childdef, &
79	da_namedef, &
80	da_namelen, &
81	pedef, &
82	pmc_g_setname, &
83	pmc_max_array, &
84	pmc_max_models
85
86	USE pmc_handle_communicator, &
87	ONLY: m_model_comm, &
88	m_model_rank, &
89	m_model_npes, &
90	m_to_child_comm, &
91	m_world_rank, &
92	pmc_parent_for_child
93
94	USE pmc_mpi_wrapper, &
95	ONLY: pmc_alloc_mem, &
96	pmc_bcast, &
97	pmc_time
98
99
100	IMPLICIT NONE
101
102	INTEGER :: next_array_in_list = 0 !<
103
104	TYPE childindexdef
105	INTEGER :: nrpoints !<
106
107	INTEGER, DIMENSION(:,:), ALLOCATABLE :: index_list_2d !<
108	END TYPE childindexdef
109
110	TYPE(childdef), DIMENSION(pmc_max_models) :: children !<
111
112	TYPE(childindexdef), DIMENSION(pmc_max_models) :: indchildren !<
113
114	SAVE
115
116	PRIVATE
117
118	!
119	!-- Public functions
120	PUBLIC pmc_parent_for_child
121
122	!
123	!-- Public variables, constants and types
124	PUBLIC children, &
125	pmc_parentinit, &
126	pmc_s_clear_next_array_list, &
127	pmc_s_fillbuffer, &
128	pmc_s_getdata_from_buffer, &
129	pmc_s_getnextarray, &
130	pmc_s_setind_and_allocmem, &
131	pmc_s_set_active_data_array, &
132	pmc_s_set_dataarray, &
133	pmc_s_set_2d_index_list, &
134	pmc_s_get_child_npes
135
136	INTERFACE pmc_parentinit
137	MODULE PROCEDURE pmc_parentinit
138	END INTERFACE pmc_parentinit
139
140	INTERFACE pmc_s_set_2d_index_list
141	MODULE PROCEDURE pmc_s_set_2d_index_list
142	END INTERFACE pmc_s_set_2d_index_list
143
144	INTERFACE pmc_s_clear_next_array_list
145	MODULE PROCEDURE pmc_s_clear_next_array_list
146	END INTERFACE pmc_s_clear_next_array_list
147
148	INTERFACE pmc_s_getnextarray
149	MODULE PROCEDURE pmc_s_getnextarray
150	END INTERFACE pmc_s_getnextarray
151
152	INTERFACE pmc_s_set_dataarray
153	MODULE PROCEDURE pmc_s_set_dataarray_2d
154	MODULE PROCEDURE pmc_s_set_dataarray_3d
155	MODULE PROCEDURE pmc_s_set_dataarray_ip2d
156	END INTERFACE pmc_s_set_dataarray
157
158	INTERFACE pmc_s_setind_and_allocmem
159	MODULE PROCEDURE pmc_s_setind_and_allocmem
160	END INTERFACE pmc_s_setind_and_allocmem
161
162	INTERFACE pmc_s_fillbuffer
163	MODULE PROCEDURE pmc_s_fillbuffer
164	END INTERFACE pmc_s_fillbuffer
165
166	INTERFACE pmc_s_getdata_from_buffer
167	MODULE PROCEDURE pmc_s_getdata_from_buffer
168	END INTERFACE pmc_s_getdata_from_buffer
169
170	INTERFACE pmc_s_set_active_data_array
171	MODULE PROCEDURE pmc_s_set_active_data_array
172	END INTERFACE pmc_s_set_active_data_array
173
174	INTERFACE pmc_s_get_child_npes
175	MODULE PROCEDURE pmc_s_get_child_npes
176	END INTERFACE pmc_s_get_child_npes
177
178
179	CONTAINS
180
181
182	!--------------------------------------------------------------------------------------------------!
183	! Description:
184	! ------------
185	!> If this thread is intended as parent, initialize parent part of parent-client data transfer
186	!--------------------------------------------------------------------------------------------------!
187	SUBROUTINE pmc_parentinit
188
189	INTEGER(iwp) :: childid !<
190	INTEGER(iwp) :: i !<
191	INTEGER(iwp) :: istat !<
192	INTEGER(iwp) :: j !<
193
194
195	DO i = 1, SIZE( pmc_parent_for_child ) - 1
196	childid = pmc_parent_for_child( i )
197
198	children(childid)%model_comm = m_model_comm
199	children(childid)%inter_comm = m_to_child_comm(childid)
200
201	!
202	!-- Get rank and size
203	CALL MPI_COMM_RANK( children(childid)%model_comm, children(childid)%model_rank, istat )
204	CALL MPI_COMM_SIZE( children(childid)%model_comm, children(childid)%model_npes, istat )
205	CALL MPI_COMM_REMOTE_SIZE( children(childid)%inter_comm, children(childid)%inter_npes, &
206	istat )
207
208	!
209	!-- Intra communicator is used for MPI_GET
210	CALL MPI_INTERCOMM_MERGE( children(childid)%inter_comm, .FALSE., &
211	children(childid)%intra_comm, istat )
212	CALL MPI_COMM_RANK( children(childid)%intra_comm, children(childid)%intra_rank, istat )
213
214	ALLOCATE( children(childid)%pes(children(childid)%inter_npes) )
215
216	!
217	!-- Allocate array of TYPE arraydef for all child PEs to store information of the transfer array
218	DO j = 1, children(childid)%inter_npes
219	ALLOCATE( children(childid)%pes(j)%array_list(pmc_max_array) )
220	ENDDO
221
222	CALL get_da_names_from_child( childid )
223	ENDDO
224
225	END SUBROUTINE pmc_parentinit
226
227
228	!--------------------------------------------------------------------------------------------------!
229	! Description:
230	! ------------
231	!> thread 0 transfers the index list, which contains all parent grid cells involved in
232	!> parent client data transfer to the thread, on which this grid cell is located
233	!--------------------------------------------------------------------------------------------------!
234	SUBROUTINE pmc_s_set_2d_index_list( childid, index_list )
235
236	INTEGER(iwp) :: ian !<
237	INTEGER(iwp) :: i !<
238	INTEGER(iwp) :: ip !<
239	INTEGER(iwp) :: istat !<
240	INTEGER(iwp) :: max_cells !<
241
242	INTEGER(iwp), INTENT(IN) :: childid !<
243
244	INTEGER(iwp), DIMENSION(:,:), INTENT(INOUT) :: index_list !<
245
246	INTEGER(iwp), DIMENSION(:), ALLOCATABLE :: cells_on_pe !<
247
248	INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE :: lo_ind_list !<
249
250
251	IF ( m_model_rank == 0 ) THEN
252	!
253	!-- Compute maximum number of grid cells located on one parent thread
254	ALLOCATE( cells_on_pe(0:m_model_npes-1) )
255	cells_on_pe = 0
256
257	DO i = 1, SIZE( index_list, 2 )
258	cells_on_pe(index_list(6,i )) = cells_on_pe(index_list(6,i ))+1
259	ENDDO
260
261	max_cells = MAXVAL( cells_on_pe )
262
263	!
264	!-- Allocate temp array for thread dependent transfer of index_list
265	ALLOCATE( lo_ind_list(SIZE( index_list,1 ),max_cells) )
266
267	DO ip = 0, m_model_npes-1
268	!
269	!-- Split into parent processes
270	ian = 0
271
272	DO i = 1, SIZE( index_list, 2 )
273	IF ( index_list(6,i) == ip ) THEN
274	ian = ian+1
275	lo_ind_list(:,ian) = index_list(:,i)
276	ENDIF
277	ENDDO
278
279	!
280	!-- Send data to other parent processes
281	IF ( ip == 0 ) THEN
282	indchildren(childid)%nrpoints = ian
283	!
284	!-- Allocate array for index_list_2d. Note, the array will also be allocated in case
285	!-- ian = 0, in order to avoid errors when array bounds are checked.
286	ALLOCATE( indchildren(childid)%index_list_2d(6,1:ian) )
287	IF ( ian > 0 ) THEN
288	indchildren(childid)%index_list_2d(:,1:ian) = lo_ind_list(:,1:ian)
289	ENDIF
290	ELSE
291	CALL MPI_SEND( ian, 1, MPI_INTEGER, ip, 1000, m_model_comm, istat )
292	IF ( ian > 0 ) THEN
293	CALL MPI_SEND( lo_ind_list, 6*ian, MPI_INTEGER, ip, 1001, m_model_comm, istat )
294	ENDIF
295	ENDIF
296	ENDDO
297
298	DEALLOCATE( lo_ind_list )
299	DEALLOCATE( cells_on_pe )
300	ELSE
301	CALL MPI_RECV( indchildren(childid)%nrpoints, 1, MPI_INTEGER, 0, 1000, m_model_comm, &
302	MPI_STATUS_IGNORE, istat )
303	ian = indchildren(childid)%nrpoints
304	!
305	!-- Allocate array for index_list_2d. Note, the array will also be allocated in case ian=0, in
306	!-- order to avoid errors when array bounds are checked.
307	ALLOCATE( indchildren(childid)%index_list_2d(6,1:ian) )
308	IF ( ian > 0 ) THEN
309	CALL MPI_RECV( indchildren(childid)%index_list_2d, 6*ian, MPI_INTEGER, 0, 1001, &
310	m_model_comm, MPI_STATUS_IGNORE, istat)
311	ENDIF
312	ENDIF
313
314	CALL set_pe_index_list( children(childid), indchildren(childid)%index_list_2d, &
315	indchildren(childid)%nrpoints )
316
317	END SUBROUTINE pmc_s_set_2d_index_list
318
319
320	!--------------------------------------------------------------------------------------------------!
321	! Description:
322	! ------------
323	!> Before creating an array list with arrays schedule for parent client transfer
324	!> make sure that the list is empty
325	!--------------------------------------------------------------------------------------------------!
326	SUBROUTINE pmc_s_clear_next_array_list
327
328	next_array_in_list = 0
329
330	END SUBROUTINE pmc_s_clear_next_array_list
331
332
333	LOGICAL FUNCTION pmc_s_getnextarray( childid, myname )
334
335	!
336	!-- Althoug there are no linked lists any more in PMC, this call still looks like working with a list
337	CHARACTER(LEN=*), INTENT(OUT) :: myname !<
338
339	INTEGER(iwp), INTENT(IN) :: childid !<
340
341	TYPE(pedef), POINTER :: ape !<
342
343	TYPE(arraydef), POINTER :: ar !<
344
345
346	next_array_in_list = next_array_in_list + 1
347
348	!
349	!-- Array names are the same on all children processes, so take first process to get the name
350	ape => children(childid)%pes(1)
351
352	IF ( next_array_in_list > ape%nr_arrays ) THEN
353	!
354	!-- All arrays are done
355	pmc_s_getnextarray = .FALSE.
356	RETURN
357	ENDIF
358
359	ar => ape%array_list(next_array_in_list)
360	myname = ar%name
361
362	!
363	!-- Return true if there is still an array in the list
364	pmc_s_getnextarray = .TRUE.
365
366	END FUNCTION pmc_s_getnextarray
367
368
369	!--------------------------------------------------------------------------------------------------!
370	! Description:
371	! ------------
372	!> add 2D real array to list of arrays scheduled for parent-client transfer
373	!--------------------------------------------------------------------------------------------------!
374	SUBROUTINE pmc_s_set_dataarray_2d( childid, array, array_2 )
375
376	INTEGER(iwp) :: nrdims !<
377
378	INTEGER(iwp), INTENT(IN) :: childid !<
379
380	INTEGER(iwp), DIMENSION(4) :: dims !<
381
382	REAL(wp), INTENT(IN), DIMENSION(:,:), POINTER :: array !<
383
384	REAL(wp), INTENT(IN), DIMENSION(:,:), POINTER, OPTIONAL :: array_2 !<
385
386	TYPE(C_PTR) :: array_adr !<
387	TYPE(C_PTR) :: second_adr !<
388
389
390	dims = 1
391	nrdims = 2
392	dims(1) = SIZE( array, 1 )
393	dims(2) = SIZE( array, 2 )
394	array_adr = C_LOC( array )
395
396	IF ( PRESENT( array_2 ) ) THEN
397	second_adr = C_LOC( array_2 )
398	CALL pmc_s_setarray( childid, nrdims, dims, array_adr, second_adr = second_adr )
399	ELSE
400	CALL pmc_s_setarray( childid, nrdims, dims, array_adr )
401	ENDIF
402
403	END SUBROUTINE pmc_s_set_dataarray_2d
404
405
406	!--------------------------------------------------------------------------------------------------!
407	! Description:
408	! ------------
409	!> add 2D integer array to list of arrays scheduled for parent-client transfer
410	!--------------------------------------------------------------------------------------------------!
411	SUBROUTINE pmc_s_set_dataarray_ip2d( childid, array )
412
413	INTEGER(iwp) :: nrdims !<
414
415	INTEGER(iwp), DIMENSION(4) :: dims !<
416
417	INTEGER(iwp), INTENT(IN) :: childid !<
418
419	INTEGER(idp), INTENT(IN), DIMENSION(:,:), POINTER :: array !<
420
421	TYPE(C_PTR) :: array_adr !<
422
423
424	dims = 1
425	nrdims = 2
426	dims(1) = SIZE( array, 1 )
427	dims(2) = SIZE( array, 2 )
428	array_adr = C_LOC( array )
429
430	CALL pmc_s_setarray( childid, nrdims, dims, array_adr , dimkey = 22 )
431
432	END SUBROUTINE pmc_s_set_dataarray_ip2d
433
434
435	!--------------------------------------------------------------------------------------------------!
436	! Description:
437	! ------------
438	!> add 3D real array to list of arrays scheduled for parent-client transfer
439	!--------------------------------------------------------------------------------------------------!
440	SUBROUTINE pmc_s_set_dataarray_3d( childid, array, nz_cl, nz, array_2 )
441
442	INTEGER(iwp) :: nrdims !<
443
444	INTEGER(iwp), INTENT(IN) :: childid !<
445	INTEGER(iwp), INTENT(IN) :: nz !<
446	INTEGER(iwp), INTENT(IN) :: nz_cl !<
447
448	INTEGER(iwp), DIMENSION(4) :: dims !<
449
450	REAL(wp), INTENT(IN), DIMENSION(:,:,:), POINTER :: array !<
451
452	REAL(wp), INTENT(IN), DIMENSION(:,:,:), POINTER, OPTIONAL :: array_2 !<
453
454	TYPE(C_PTR) :: array_adr !<
455	TYPE(C_PTR) :: second_adr !<
456
457
458	nrdims = 3
459	dims(1) = SIZE( array, 1 )
460	dims(2) = SIZE( array, 2 )
461	dims(3) = SIZE( array, 3 )
462	dims(4) = nz_cl+dims(1)-nz ! Works for first dimension 1:nz and 0:nz+1
463
464	array_adr = C_LOC( array )
465	!
466	!-- In PALM's pointer version, two indices have to be stored internally.
467	!-- The active address of the data array is set in swap_timelevel.
468	IF ( PRESENT( array_2 ) ) THEN
469	second_adr = C_LOC( array_2 )
470	CALL pmc_s_setarray( childid, nrdims, dims, array_adr, second_adr = second_adr )
471	ELSE
472	CALL pmc_s_setarray( childid, nrdims, dims, array_adr )
473	ENDIF
474
475	END SUBROUTINE pmc_s_set_dataarray_3d
476
477
478	!--------------------------------------------------------------------------------------------------!
479	! Description:
480	! ------------
481	!> Naming convention for appendices: _pc -> parent to child transfer
482	!> _cp -> child to parent transfer
483	!> send -> parent to child transfer
484	!> recv -> child to parent transfer
485	!>
486	!> @todo: Missing subroutine description.
487	!--------------------------------------------------------------------------------------------------!
488	SUBROUTINE pmc_s_setind_and_allocmem( childid )
489
490	USE control_parameters, &
491	ONLY: message_string
492
493	INTEGER(iwp) :: arlen !<
494	INTEGER(iwp) :: i !<
495	INTEGER(iwp) :: ierr !<
496	INTEGER(iwp) :: j !<
497	INTEGER(iwp) :: lo_nr_arrays !< store number of arrays in local variiab le
498	INTEGER(iwp) :: myindex !<
499	INTEGER(iwp) :: total_npes !< Total Number of PEs Parent and Child
500	INTEGER(idp) :: bufsize !< size of MPI data window
501
502	INTEGER(iwp), INTENT(IN) :: childid !<
503
504	INTEGER(KIND=MPI_ADDRESS_KIND) :: winsize !<
505
506	INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE :: myindex_s !<
507	INTEGER(iwp), DIMENSION(:,:), ALLOCATABLE :: myindex_r !<
508
509	REAL(wp),DIMENSION(:), POINTER, SAVE :: base_array_cp !< base array for child to parent transfer
510	REAL(wp),DIMENSION(:), POINTER, SAVE :: base_array_pc !< base array for parent to child transfer
511
512	TYPE(C_PTR) :: base_ptr !<
513
514	TYPE(pedef), POINTER :: ape !<
515
516	TYPE(arraydef), POINTER :: ar !<
517
518
519	call MPI_COMM_SIZE( children(childid)%intra_comm, total_npes, ierr )
520	!
521	!-- Parent to child direction
522	myindex = 1
523	bufsize = 8
524
525	!
526	!-- All Child processes get the same number of arrays.
527	!-- Therfore the number of arrays form the first Child process can be used for Dimension.
528	lo_nr_arrays = children(childid)%pes(1)%nr_arrays
529
530	ALLOCATE( myindex_s(lo_nr_arrays,0:total_npes-1) )
531	ALLOCATE( myindex_r(lo_nr_arrays,0:total_npes-1) )
532
533	myindex_s = 0
534
535	!
536	!-- First stride: compute size and set index
537	DO i = 1, children(childid)%inter_npes
538	ape => children(childid)%pes(i)
539	DO j = 1, ape%nr_arrays
540	ar => ape%array_list(j)
541	IF ( ar%nrdims == 2 ) THEN
542	arlen = ape%nrele
543	ELSEIF ( ar%nrdims == 3 ) THEN
544	arlen = ape%nrele * ar%a_dim(4)
545	ELSE
546	arlen = -1
547	ENDIF
548	ar%sendindex = myindex
549
550	!
551	!-- Using intra communicator for MPU_Alltoall, the numbers of the child processes are after
552	!-- the parent ones.
553	myindex_s(j,i-1+children(childid)%model_npes) = myindex
554
555	myindex = myindex + arlen
556	bufsize = bufsize + arlen
557	ar%sendsize = arlen
558	ENDDO
559	ENDDO
560
561	!
562	!-- Using MPI_Alltoall to send indices from Parent to Child
563	!-- The data comming back from the child processes are ignored.
564	CALL MPI_ALLTOALL( myindex_s, lo_nr_arrays, MPI_INTEGER, myindex_r, lo_nr_arrays, MPI_INTEGER, &
565	children(childid)%intra_comm, ierr )
566
567	!
568	!-- Using MPI_Alltoall to receive indices from Child
569	myindex_s = 0
570	myindex_r = 0
571
572	CALL MPI_ALLTOALL( myindex_s, lo_nr_arrays, MPI_INTEGER, myindex_r, lo_nr_arrays, MPI_INTEGER, &
573	children(childid)%intra_comm, ierr )
574
575	!
576	!-- Create RMA (One Sided Communication) window for data buffer parent to child transfer.
577	!-- The buffer of MPI_GET (counterpart of transfer) can be PE-local, i.e. it can but must not be
578	!-- part of the MPI RMA window. Only one RMA window is required to prepare the data for:
579	!-- parent -> child transfer on the parent side
580	!-- and for:
581	!-- child -> parent transfer on the child side
582	CALL pmc_alloc_mem( base_array_pc, bufsize )
583	children(childid)%totalbuffersize = bufsize * wp
584
585	winsize = bufsize * wp
586	CALL MPI_WIN_CREATE( base_array_pc, winsize, wp, MPI_INFO_NULL, children(childid)%intra_comm, &
587	children(childid)%win_parent_child, ierr )
588
589	!
590	!-- Open window to set data
591	CALL MPI_WIN_FENCE( 0, children(childid)%win_parent_child, ierr )
592
593	!
594	!-- Second stride: set buffer pointer
595	DO i = 1, children(childid)%inter_npes
596	ape => children(childid)%pes(i)
597	DO j = 1, ape%nr_arrays
598	ar => ape%array_list(j)
599	ar%sendbuf = C_LOC( base_array_pc(ar%sendindex) )
600	IF ( ar%sendindex + ar%sendsize > bufsize ) THEN
601	WRITE( message_string, '(a,i4,4i7,1x,a)' ) 'parent buffer too small ',i , &
602	ar%sendindex, ar%sendsize, ar%sendindex + ar%sendsize, bufsize, TRIM( ar%name )
603	CALL message( 'pmc_s_setind_and_allocmem', 'PA0429', 3, 2, 0, 6, 0 )
604	ENDIF
605	ENDDO
606	ENDDO
607
608	!
609	!-- Child to parent direction
610	bufsize = 8
611
612	!
613	!-- First stride: compute size and set index
614	DO i = 1, children(childid)%inter_npes
615	ape => children(childid)%pes(i)
616	DO j = 1, ape%nr_arrays
617	ar => ape%array_list(j)
618	!
619	!-- Receive index from child
620	IF ( ar%nrdims == 3 ) THEN
621	bufsize = MAX( bufsize, INT( ape%nrele * ar%a_dim(4), MPI_ADDRESS_KIND ) )
622	ELSE
623	bufsize = MAX( bufsize, INT( ape%nrele, MPI_ADDRESS_KIND ) )
624	ENDIF
625	ar%recvindex = myindex_r(j,i-1+children(childid)%model_npes)
626	ENDDO
627	ENDDO
628
629	DEALLOCATE( myindex_s )
630	DEALLOCATE( myindex_r )
631
632	!
633	!-- Create RMA (one sided communication, RMA = Remote Memory Access) data buffer.
634	!-- The buffer for MPI_GET can be PE local, i.e. it can but must not be part of the MPI RMA window.
635	CALL pmc_alloc_mem( base_array_cp, bufsize, base_ptr )
636	children(childid)%totalbuffersize = bufsize * wp
637
638	CALL MPI_BARRIER( children(childid)%intra_comm, ierr )
639
640	!
641	!-- Second stride: set buffer pointer
642	DO i = 1, children(childid)%inter_npes
643	ape => children(childid)%pes(i)
644	DO j = 1, ape%nr_arrays
645	ar => ape%array_list(j)
646	ar%recvbuf = base_ptr
647	ENDDO
648	ENDDO
649
650	END SUBROUTINE pmc_s_setind_and_allocmem
651
652
653	!--------------------------------------------------------------------------------------------------!
654	! Description:
655	! ------------
656	!> Fill buffer in RMA window to enable the client to fetch the dat with MPI_Get
657	!--------------------------------------------------------------------------------------------------!
658	SUBROUTINE pmc_s_fillbuffer( childid, waittime, particle_transfer )
659
660	INTEGER(iwp) :: ierr !<
661	INTEGER(iwp) :: ij !<
662	INTEGER(iwp) :: ip !<
663	INTEGER(iwp) :: j !<
664	INTEGER(iwp) :: myindex !<
665
666	INTEGER(iwp), INTENT(IN) :: childid !<
667
668	INTEGER(iwp), DIMENSION(1) :: buf_shape !<
669
670	INTEGER(idp), POINTER, DIMENSION(:) :: ibuf !<
671
672	INTEGER(idp), POINTER, DIMENSION(:,:) :: idata_2d !<
673
674	LOGICAL :: lo_ptrans !<
675
676	LOGICAL, INTENT(IN), OPTIONAL :: particle_transfer !<
677
678	REAL(wp) :: t1 !<
679	REAL(wp) :: t2 !<
680
681	REAL(wp), INTENT(OUT), OPTIONAL :: waittime !<
682
683	REAL(wp), POINTER, DIMENSION(:) :: buf !<
684
685	REAL(wp), POINTER, DIMENSION(:,:) :: data_2d !<
686
687	REAL(wp), POINTER, DIMENSION(:,:,:) :: data_3d !<
688
689	TYPE(pedef), POINTER :: ape !<
690
691	TYPE(arraydef), POINTER :: ar !<
692
693	!
694	!-- Synchronization of the model is done in pmci_synchronize. Therefor the RMA window can be filled
695	!-- without sychronization at this point and a barrier is not necessary.
696	!-- Please note that waittime has to be set in pmc_s_fillbuffer AND pmc_c_getbuffer.
697	IF ( PRESENT( waittime ) ) THEN
698	t1 = pmc_time()
699	CALL MPI_BARRIER( children(childid)%intra_comm, ierr )
700	t2 = pmc_time()
701	waittime = t2 - t1
702	ENDIF
703
704	lo_ptrans = .FALSE.
705	IF ( PRESENT( particle_transfer ) ) lo_ptrans = particle_transfer
706
707	DO ip = 1, children(childid)%inter_npes
708	ape => children(childid)%pes(ip)
709	DO j = 1, ape%nr_arrays
710	ar => ape%array_list(j)
711	myindex = 1
712	IF ( ar%dimkey == 2 .AND. .NOT.lo_ptrans ) THEN ! PALM 2D REAL*8 Array
713	buf_shape(1) = ape%nrele
714	CALL C_F_POINTER( ar%sendbuf, buf, buf_shape )
715	CALL C_F_POINTER( ar%data, data_2d, ar%a_dim(1:2) )
716	DO ij = 1, ape%nrele
717	buf(myindex) = data_2d(ape%locind(ij)%j,ape%locind(ij)%i)
718	myindex = myindex + 1
719	ENDDO
720	ELSEIF ( ar%dimkey == 3 .AND. .NOT.lo_ptrans ) THEN ! PALM 3D REAL*8 Array
721	buf_shape(1) = ape%nrele*ar%a_dim(4)
722	CALL C_F_POINTER( ar%sendbuf, buf, buf_shape )
723	CALL C_F_POINTER( ar%data, data_3d, ar%a_dim(1:3) )
724	DO ij = 1, ape%nrele
725	buf(myindex:myindex+ar%a_dim(4)-1) = &
726	data_3d(1:ar%a_dim(4),ape%locind(ij)%j,ape%locind(ij)%i)
727	myindex = myindex + ar%a_dim(4)
728	ENDDO
729	ELSEIF ( ar%dimkey == 22 .AND. lo_ptrans ) THEN ! 2D INTEGER*8 Array for particle Transfer
730	buf_shape(1) = ape%nrele
731	CALL C_F_POINTER( ar%sendbuf, ibuf, buf_shape )
732	CALL C_F_POINTER( ar%data, idata_2d, ar%a_dim(1:2) )
733	DO ij = 1, ape%nrele
734	ibuf(myindex) = idata_2d(ape%locind(ij)%j,ape%locind(ij)%i)
735	myindex = myindex + 1
736	ENDDO
737	ENDIF
738	ENDDO
739	ENDDO
740
741	!
742	!-- Buffer is filled
743	CALL MPI_BARRIER( children(childid)%intra_comm, ierr )
744
745	END SUBROUTINE pmc_s_fillbuffer
746
747
748	!--------------------------------------------------------------------------------------------------!
749	! Description:
750	! ------------
751	!> Get client data from RMM window
752	!--------------------------------------------------------------------------------------------------!
753	SUBROUTINE pmc_s_getdata_from_buffer( childid, waittime , particle_transfer, child_process_nr )
754
755	INTEGER(iwp) :: ierr !<
756	INTEGER(iwp) :: ij !<
757	INTEGER(iwp) :: ip !<
758	INTEGER(iwp) :: ip_start !<
759	INTEGER(iwp) :: ip_end !<
760	INTEGER(iwp) :: j !<
761	INTEGER(iwp) :: myindex !<
762	INTEGER(iwp) :: nr !<
763	INTEGER(iwp) :: target_pe !<
764
765	INTEGER(iwp), INTENT(IN) :: childid !<
766
767	INTEGER(iwp), INTENT(IN), OPTIONAL :: child_process_nr !<
768
769	INTEGER(KIND=MPI_ADDRESS_KIND) :: target_disp !<
770
771	INTEGER(iwp), DIMENSION(1) :: buf_shape !<
772
773	INTEGER(idp), POINTER, DIMENSION(:) :: ibuf !<
774
775	INTEGER(idp), POINTER, DIMENSION(:,:) :: idata_2d !<
776
777	LOGICAL :: lo_ptrans !<
778
779	LOGICAL, INTENT(IN), OPTIONAL :: particle_transfer !<
780
781	REAL(wp) :: t1 !<
782	REAL(wp) :: t2 !<
783
784	REAL(wp), INTENT(OUT), OPTIONAL :: waittime !<
785
786	REAL(wp), POINTER, DIMENSION(:) :: buf !<
787
788	REAL(wp), POINTER, DIMENSION(:,:) :: data_2d !<
789
790	REAL(wp), POINTER, DIMENSION(:,:,:) :: data_3d !<
791
792	TYPE(pedef), POINTER :: ape !<
793
794	TYPE(arraydef), POINTER :: ar !<
795
796
797	t1 = pmc_time()
798
799	IF( PRESENT( child_process_nr ) ) THEN
800	ip_start = child_process_nr
801	ip_end = child_process_nr
802	ELSE
803	ip_start = 1
804	ip_end = children(childid)%inter_npes
805	END IF
806
807	lo_ptrans = .FALSE.
808	IF ( PRESENT( particle_transfer ) ) lo_ptrans = particle_transfer
809
810	IF(ip_start == 1) THEN
811	!
812	!-- Wait for child to fill buffer
813	CALL MPI_BARRIER( children(childid)%intra_comm, ierr )
814	t2 = pmc_time() - t1
815	IF ( PRESENT( waittime ) ) waittime = t2
816
817	CALL MPI_BARRIER( children(childid)%intra_comm, ierr )
818	ENDIF
819
820	DO ip = ip_start, ip_end
821	ape => children(childid)%pes(ip)
822	DO j = 1, ape%nr_arrays
823	ar => ape%array_list(j)
824
825	IF ( ar%recvindex < 0 ) CYCLE
826
827	IF ( ar%dimkey == 2 .AND. .NOT. lo_ptrans ) THEN
828	nr = ape%nrele
829	ELSEIF ( ar%dimkey == 3 .AND. .NOT. lo_ptrans ) THEN
830	nr = ape%nrele * ar%a_dim(4)
831	ELSE IF ( ar%dimkey == 22 .AND. lo_ptrans) THEN
832	nr = ape%nrele
833	ELSE
834	CYCLE ! Particle arrays are not transfered here
835	ENDIF
836
837	buf_shape(1) = nr
838
839	IF(lo_ptrans) THEN
840	CALL C_F_POINTER( ar%recvbuf, ibuf, buf_shape )
841	ELSE
842	CALL C_F_POINTER( ar%recvbuf, buf, buf_shape )
843	ENDIF
844
845	!
846	!-- MPI passive target RMA
847	IF ( nr > 0 ) THEN
848	target_disp = ar%recvindex - 1
849	!
850	!-- Child processes are located behind parent process
851	target_pe = ip - 1 + m_model_npes
852	CALL MPI_WIN_LOCK( MPI_LOCK_SHARED, target_pe, 0, children(childid)%win_parent_child, &
853	ierr )
854	IF ( lo_ptrans ) THEN
855	CALL MPI_GET( ibuf, nr * 8, MPI_BYTE, target_pe, target_disp, nr * 8, &
856	!There is no MPI_INTEGER8 datatype
857	MPI_BYTE, children(childid)%win_parent_child, ierr )
858	ELSE
859	CALL MPI_GET( buf, nr, MPI_REAL, target_pe, target_disp, nr, MPI_REAL, &
860	children(childid)%win_parent_child, ierr )
861	ENDIF
862	CALL MPI_WIN_UNLOCK( target_pe, children(childid)%win_parent_child, ierr )
863	ENDIF
864
865	myindex = 1
866
867	IF ( ar%dimkey == 2 .AND. .NOT. lo_ptrans ) THEN
868	CALL C_F_POINTER( ar%data, data_2d, ar%a_dim(1:2) )
869	DO ij = 1, ape%nrele
870	data_2d(ape%locind(ij)%j,ape%locind(ij)%i) = buf(myindex)
871	myindex = myindex + 1
872	ENDDO
873	ELSE IF ( ar%dimkey == 3 .AND. .NOT. lo_ptrans ) THEN
874	CALL C_F_POINTER( ar%data, data_3d, ar%a_dim(1:3) )
875	DO ij = 1, ape%nrele
876	data_3d(1:ar%a_dim(4),ape%locind(ij)%j,ape%locind(ij)%i) = &
877	buf(myindex:myindex+ar%a_dim(4)-1)
878	myindex = myindex + ar%a_dim(4)
879	ENDDO
880	ELSE IF ( ar%dimkey == 22 .AND. lo_ptrans) THEN
881	CALL C_F_POINTER( ar%data, idata_2d, ar%a_dim(1:2) )
882	DO ij = 1, ape%nrele
883	idata_2d(ape%locind(ij)%j,ape%locind(ij)%i) = ibuf(myindex)
884	myindex = myindex + 1
885	ENDDO
886	ENDIF
887	ENDDO
888	ENDDO
889
890	END SUBROUTINE pmc_s_getdata_from_buffer
891
892
893	!--------------------------------------------------------------------------------------------------!
894	! Description:
895	! ------------
896	!> broadcast name of transfer arrays from child thread 0 to parent threads
897	!--------------------------------------------------------------------------------------------------!
898	SUBROUTINE get_da_names_from_child( childid )
899
900	!
901	!-- Get data array description and name from child
902	INTEGER(iwp), INTENT(IN) :: childid !<
903
904	TYPE(da_namedef) :: myname !<
905
906
907	DO
908	CALL pmc_bcast( myname%couple_index, 0, comm=m_to_child_comm(childid) )
909
910	IF ( myname%couple_index == -1 ) EXIT
911
912	CALL pmc_bcast( myname%parentdesc, 0, comm=m_to_child_comm(childid) )
913	CALL pmc_bcast( myname%nameonparent, 0, comm=m_to_child_comm(childid) )
914	CALL pmc_bcast( myname%childdesc, 0, comm=m_to_child_comm(childid) )
915	CALL pmc_bcast( myname%nameonchild, 0, comm=m_to_child_comm(childid) )
916
917	CALL pmc_g_setname( children(childid), myname%couple_index, myname%nameonparent )
918	ENDDO
919
920	END SUBROUTINE get_da_names_from_child
921
922
923	!--------------------------------------------------------------------------------------------------!
924	! Description:
925	! ------------
926	!> @todo: Missing subroutine description.
927	!--------------------------------------------------------------------------------------------------!
928	SUBROUTINE pmc_s_setarray( childid, nrdims, dims, array_adr, second_adr, dimkey )
929
930	!
931	!-- Set array for child inter process 0
932	INTEGER(iwp) :: i !< local counter
933
934	INTEGER(iwp), INTENT(IN) :: childid !<
935	INTEGER(iwp), INTENT(IN) :: nrdims !<
936
937	INTEGER(iwp), INTENT(IN), OPTIONAL :: dimkey !<
938
939	INTEGER(iwp), INTENT(IN), DIMENSION(:) :: dims !<
940
941	TYPE(C_PTR), INTENT(IN) :: array_adr !<
942
943	TYPE(C_PTR), INTENT(IN), OPTIONAL :: second_adr !<
944
945	TYPE(pedef), POINTER :: ape !<
946
947	TYPE(arraydef), POINTER :: ar !<
948
949
950	DO i = 1, children(childid)%inter_npes
951	ape => children(childid)%pes(i)
952	ar => ape%array_list(next_array_in_list)
953	ar%nrdims = nrdims
954	ar%dimkey = nrdims
955
956	IF( PRESENT( dimkey ) ) ar%dimkey = dimkey
957	ar%a_dim = dims
958	ar%data = array_adr
959	IF ( PRESENT( second_adr ) ) THEN
960	ar%po_data(1) = array_adr
961	ar%po_data(2) = second_adr
962	ELSE
963	ar%po_data(1) = C_NULL_PTR
964	ar%po_data(2) = C_NULL_PTR
965	ENDIF
966	ENDDO
967
968	END SUBROUTINE pmc_s_setarray
969
970
971	!--------------------------------------------------------------------------------------------------!
972	! Description:
973	! ------------
974	!> @todo: Missing subroutine description.
975	!--------------------------------------------------------------------------------------------------!
976	SUBROUTINE pmc_s_set_active_data_array( childid, iactive )
977
978	INTEGER(iwp) :: ip !<
979	INTEGER(iwp) :: j !<
980
981	INTEGER(iwp), INTENT(IN) :: childid !<
982	INTEGER(iwp), INTENT(IN) :: iactive !<
983
984	TYPE(pedef), POINTER :: ape !<
985
986	TYPE(arraydef), POINTER :: ar !<
987
988	DO ip = 1, children(childid)%inter_npes
989	ape => children(childid)%pes(ip)
990	DO j = 1, ape%nr_arrays
991	ar => ape%array_list(j)
992	IF ( MOD( ar%dimkey, 10 ) == 2 ) CYCLE !Not for 2D array
993	IF ( iactive == 1 .OR. iactive == 2 ) THEN
994	ar%data = ar%po_data(iactive)
995	ENDIF
996	ENDDO
997	ENDDO
998
999	END SUBROUTINE pmc_s_set_active_data_array
1000
1001
1002	!--------------------------------------------------------------------------------------------------!
1003	! Description:
1004	! ------------
1005	!> @todo: Missing function description.
1006	!--------------------------------------------------------------------------------------------------!
1007	INTEGER FUNCTION pmc_s_get_child_npes( child_id )
1008
1009	INTEGER(iwp),INTENT(IN) :: child_id !<
1010
1011	pmc_s_get_child_npes = children(child_id)%inter_npes
1012
1013	RETURN
1014
1015	END FUNCTION pmc_s_get_child_npes
1016
1017
1018	!--------------------------------------------------------------------------------------------------!
1019	! Description:
1020	! ------------
1021	!> @todo: Missing subroutine description.
1022	!--------------------------------------------------------------------------------------------------!
1023	SUBROUTINE set_pe_index_list( mychild, index_list, nrp )
1024
1025	INTEGER(iwp) :: i !<
1026	INTEGER(iwp) :: ierr !<
1027	INTEGER(iwp) :: ind !<
1028	INTEGER(iwp) :: indwin !<
1029	INTEGER(iwp) :: indwin2 !<
1030	INTEGER(iwp) :: i2 !<
1031	INTEGER(iwp) :: j !<
1032	INTEGER(iwp) :: rempe !<
1033
1034	TYPE(childdef), INTENT(INOUT) :: mychild !<
1035
1036	INTEGER(iwp), DIMENSION(mychild%inter_npes) :: remind !<
1037
1038	INTEGER(iwp), INTENT(IN) :: nrp !<
1039
1040	INTEGER(iwp), INTENT(IN), DIMENSION(:,:) :: index_list !<
1041
1042	INTEGER(KIND=MPI_ADDRESS_KIND) :: winsize !<
1043
1044	INTEGER(iwp), DIMENSION(:), POINTER :: remindw !<
1045	INTEGER(iwp), DIMENSION(:), POINTER :: rldef !<
1046
1047	TYPE(pedef), POINTER :: ape !<
1048
1049
1050	!
1051	!-- First, count entries for every remote child process
1052	DO i = 1, mychild%inter_npes
1053	ape => mychild%pes(i)
1054	ape%nrele = 0
1055	ENDDO
1056
1057	!
1058	!-- Loop over number of coarse grid cells
1059	DO j = 1, nrp
1060	rempe = index_list(5,j) + 1 ! Process number on remote process
1061	ape => mychild%pes(rempe)
1062	ape%nrele = ape%nrele + 1 ! Increment number of elements for this child process
1063	ENDDO
1064
1065	DO i = 1, mychild%inter_npes
1066	ape => mychild%pes(i)
1067	ALLOCATE( ape%locind(ape%nrele) )
1068	ENDDO
1069
1070	remind = 0
1071
1072	!
1073	!-- Second, create lists
1074	!-- Loop over number of coarse grid cells
1075	DO j = 1, nrp
1076	rempe = index_list(5,j) + 1
1077	ape => mychild%pes(rempe)
1078	remind(rempe) = remind(rempe) + 1
1079	ind = remind(rempe)
1080	ape%locind(ind)%i = index_list(1,j)
1081	ape%locind(ind)%j = index_list(2,j)
1082	ENDDO
1083
1084	!
1085	!-- Prepare number of elements for children processes
1086	CALL pmc_alloc_mem( rldef, mychild%inter_npes * 2 )
1087
1088	!
1089	!-- Number of child processes * size of INTEGER (i just arbitrary INTEGER)
1090	winsize = mychild%inter_npes * STORAGE_SIZE( i ) / 8 * 2
1091
1092	CALL MPI_WIN_CREATE( rldef, winsize, iwp, MPI_INFO_NULL, mychild%intra_comm, indwin, ierr )
1093
1094	!
1095	!-- Open window to set data
1096	CALL MPI_WIN_FENCE( 0, indwin, ierr )
1097
1098	rldef(1) = 0 ! Index on remote process 0
1099	rldef(2) = remind(1) ! Number of elements on remote process 0
1100
1101	!
1102	!-- Reserve buffer for index array
1103	DO i = 2, mychild%inter_npes
1104	i2 = ( i - 1 ) * 2 + 1
1105	rldef(i2) = rldef(i2-2) + rldef(i2-1) * 2 ! Index on remote process
1106	rldef(i2+1) = remind(i) ! Number of elements on remote process
1107	ENDDO
1108
1109	!
1110	!-- Close window to allow child to access data
1111	CALL MPI_WIN_FENCE( 0, indwin, ierr )
1112
1113	!
1114	!-- Child has retrieved data
1115	CALL MPI_WIN_FENCE( 0, indwin, ierr )
1116
1117	i2 = 2 * mychild%inter_npes - 1
1118	winsize = ( rldef(i2) + rldef(i2+1) ) * 2
1119
1120	!
1121	!-- Make sure, MPI_ALLOC_MEM works
1122	winsize = MAX( winsize, INT( 1, MPI_ADDRESS_KIND ) )
1123
1124	CALL pmc_alloc_mem( remindw, INT( winsize ) )
1125
1126	CALL MPI_BARRIER( m_model_comm, ierr )
1127	CALL MPI_WIN_CREATE( remindw, winsize * STORAGE_SIZE( i ) / 8, iwp, MPI_INFO_NULL, &
1128	mychild%intra_comm, indwin2, ierr )
1129
1130	!
1131	!-- Open window to set data
1132	CALL MPI_WIN_FENCE( 0, indwin2, ierr )
1133
1134	!
1135	!-- Create the 2D index list
1136	DO j = 1, nrp
1137	rempe = index_list(5,j) + 1 ! Process number on remote process
1138	ape => mychild%pes(rempe)
1139	i2 = rempe * 2 - 1
1140	ind = rldef(i2) + 1
1141	remindw(ind) = index_list(3,j)
1142	remindw(ind+1) = index_list(4,j)
1143	rldef(i2) = rldef(i2)+2
1144	ENDDO
1145
1146	!
1147	!-- All data are set
1148	CALL MPI_WIN_FENCE( 0, indwin2, ierr )
1149
1150	!
1151	!-- Don't know why, but this barrier is necessary before windows can be freed
1152	!-- TODO: find out why this is required
1153	CALL MPI_BARRIER( mychild%intra_comm, ierr )
1154
1155	CALL MPI_WIN_FREE( indwin, ierr )
1156	CALL MPI_WIN_FREE( indwin2, ierr )
1157
1158	!
1159	!-- TODO: check if the following idea needs to be done
1160	!-- Should work, Problem with MPI implementation
1161	!-- https://www.lrz.de/services/software/parallel/mpi/onesided
1162	!-- CALL MPI_Free_mem (remindw, ierr)
1163
1164	END SUBROUTINE set_pe_index_list
1165	#endif
1166
1167
1168	END MODULE pmc_parent

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: palm/trunk/SOURCE/pmc_parent_mod.f90 @ 4854

Download in other formats: