TABLE OF CONTENTS
- ABINIT/xmpi_bcast_ch0d
- ABINIT/xmpi_bcast_ch1d
- ABINIT/xmpi_bcast_coeff2_1d
- ABINIT/xmpi_bcast_coeffi2_1d
- ABINIT/xmpi_bcast_cplx1d
- ABINIT/xmpi_bcast_cplx2d
- ABINIT/xmpi_bcast_cplx3d
- ABINIT/xmpi_bcast_cplx4d
- ABINIT/xmpi_bcast_cplxv
- ABINIT/xmpi_bcast_dc1d
- ABINIT/xmpi_bcast_dc2d
- ABINIT/xmpi_bcast_dc3d
- ABINIT/xmpi_bcast_dc4d
- ABINIT/xmpi_bcast_dcv
- ABINIT/xmpi_bcast_dp1d
- ABINIT/xmpi_bcast_dp2d
- ABINIT/xmpi_bcast_dp3d
- ABINIT/xmpi_bcast_dp4d
- ABINIT/xmpi_bcast_dp5d
- ABINIT/xmpi_bcast_dp6d
- ABINIT/xmpi_bcast_dpv
- ABINIT/xmpi_bcast_int1d
- ABINIT/xmpi_bcast_int2d
- ABINIT/xmpi_bcast_int3d
- ABINIT/xmpi_bcast_int4d
- ABINIT/xmpi_bcast_intv
- ABINIT/xmpi_bcast_log0d
- ABINIT/xmpi_bcast_sp1d
- ABINIT/xmpi_bcast_sp2d
- ABINIT/xmpi_bcast_sp3d
- ABINIT/xmpi_bcast_sp4d
- ABINIT/xmpi_bcast_spv
ABINIT/xmpi_bcast_ch0d [ Functions ]
NAME
xmpi_bcast_ch0d
FUNCTION
Broadcasts data from master to slaves. Target: character strings.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1565 subroutine xmpi_bcast_ch0d(xval, master, comm, ier) 1566 1567 !Arguments------------------------- 1568 character(len=*),intent(inout),target :: xval 1569 integer,intent(in) :: comm,master 1570 integer,intent(out) :: ier 1571 1572 !Local variables------------------------------- 1573 #if defined HAVE_MPI 1574 integer :: nch(1),rank 1575 character,pointer :: arr_xval(:) 1576 type(c_ptr) :: cptr 1577 #endif 1578 1579 !************************************************************************* 1580 1581 ier=0 1582 #if defined HAVE_MPI 1583 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1584 call MPI_COMM_RANK(comm,rank,ier) 1585 if (rank==master) nch(1)=len_trim(xval) 1586 call MPI_BCAST(nch,1,MPI_INTEGER,master,comm,ier) 1587 cptr=c_loc(xval) ; call c_f_pointer(cptr,arr_xval,[nch(1)]) 1588 call MPI_BCAST(arr_xval,nch(1),MPI_CHARACTER,master,comm,ier) 1589 if (rank/=master) xval(nch(1)+1:)='' 1590 end if 1591 #endif 1592 1593 end subroutine xmpi_bcast_ch0d
ABINIT/xmpi_bcast_ch1d [ Functions ]
NAME
xmpi_bcast_ch1d
FUNCTION
Broadcasts data from master to slaves. Target: one-dimensional array of character stringss.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1616 subroutine xmpi_bcast_ch1d(xval,master,comm,ier) 1617 1618 !Arguments------------------------- 1619 Character(len=*), DEV_CONTARRD intent(inout) :: xval(:) 1620 integer,intent(in) :: comm,master 1621 integer,intent(out) :: ier 1622 1623 !Local variables------------------------------- 1624 #if defined HAVE_MPI 1625 integer :: ii,nch 1626 #endif 1627 1628 !************************************************************************* 1629 1630 ier=0 1631 #if defined HAVE_MPI 1632 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1633 nch=0 1634 do ii=1,size(xval) 1635 nch=nch+len(xval(ii)) 1636 end do 1637 call MPI_BCAST(xval,nch,MPI_CHARACTER,master,comm,ier) 1638 end if 1639 #endif 1640 1641 end subroutine xmpi_bcast_ch1d
ABINIT/xmpi_bcast_coeff2_1d [ Functions ]
NAME
xmpi_bcast_coeff2_1d
FUNCTION
Broadcasts data from master to slaves. Target: type(coeff2) 1D-arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1803 subroutine xmpi_bcast_coeff2_1d(xval,master,comm,ier) 1804 1805 !Arguments------------------------- 1806 type(coeff2_type), intent(inout) :: xval(:) 1807 integer ,intent(in) :: comm,master 1808 integer ,intent(out) :: ier 1809 1810 !Local variables------------------- 1811 #if defined HAVE_MPI 1812 integer :: ii,jj,kk,me,n0,n1,n2,siztot 1813 integer,allocatable :: siz(:,:) 1814 real(dp),allocatable :: mpibuf(:) 1815 #endif 1816 1817 ! ************************************************************************* 1818 1819 ier=0 1820 #if defined HAVE_MPI 1821 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1822 me=xmpi_comm_rank(comm) 1823 1824 ! Broadcast xval%value sizes 1825 n0=size(xval) 1826 ABI_STAT_MALLOC(siz,(2,n0), ier) 1827 if (ier/= 0) call xmpi_abort(msg='error allocating siz in xmpi_bcast') 1828 if (me==master) then 1829 do ii=1,n0 1830 siz(1,ii)=size(xval(ii)%value,1) 1831 siz(2,ii)=size(xval(ii)%value,2) 1832 end do 1833 end if 1834 call MPI_BCAST(siz,2*n0,MPI_INTEGER,master,comm,ier) 1835 siztot=0 1836 do ii=1,n0 1837 siztot=siztot+siz(1,ii)*siz(2,ii) 1838 end do 1839 1840 ! Fill in the buffer 1841 ABI_STAT_MALLOC(mpibuf,(siztot), ier) 1842 if (ier/= 0) call xmpi_abort(msg='error allocating mpibuf in xmpi_bcast') 1843 if (me==master) then 1844 jj=0 1845 do ii=1,n0 1846 n1=siz(1,ii);n2=siz(2,ii) 1847 do kk=1,n2 1848 mpibuf(jj+1:jj+n1)=xval(ii)%value(1:n1,kk) 1849 jj=jj+n1 1850 end do 1851 end do 1852 end if 1853 1854 ! Broadcast the data 1855 call MPI_BCAST(mpibuf,siztot,MPI_DOUBLE_PRECISION,master,comm,ier) 1856 1857 ! Retrieve the buffer 1858 jj=0 1859 do ii=1,n0 1860 n1=siz(1,ii);n2=siz(2,ii) 1861 if (.not.allocated(xval(ii)%value)) then 1862 ABI_STAT_MALLOC(xval(ii)%value,(n1,n2), ier) 1863 if (ier/= 0) call xmpi_abort(msg='error allocating xval%value in xmpi_bcast') 1864 end if 1865 do kk=1,n2 1866 xval(ii)%value(1:n1,kk)=mpibuf(jj+1:jj+n1) 1867 jj=jj+n1 1868 end do 1869 end do 1870 ABI_FREE(siz) 1871 ABI_FREE(mpibuf) 1872 1873 end if 1874 #endif 1875 1876 end subroutine xmpi_bcast_coeff2_1d
ABINIT/xmpi_bcast_coeffi2_1d [ Functions ]
NAME
xmpi_bcast_coeffi2_1d
FUNCTION
Broadcasts data from master to slaves. Target: type(coeffi2) 1D-arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1708 subroutine xmpi_bcast_coeffi2_1d(xval,master,comm,ier) 1709 1710 !Arguments------------------------- 1711 type(coeffi2_type), intent(inout) :: xval(:) 1712 integer ,intent(in) :: comm,master 1713 integer ,intent(out) :: ier 1714 1715 !Local variables------------------- 1716 #if defined HAVE_MPI 1717 integer :: ii,jj,kk,me,n0,n1,n2,siztot 1718 integer,allocatable :: mpibuf(:),siz(:,:) 1719 #endif 1720 1721 ! ************************************************************************* 1722 1723 ier=0 1724 #if defined HAVE_MPI 1725 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1726 me=xmpi_comm_rank(comm) 1727 1728 ! Broadcast xval%value sizes 1729 n0=size(xval) 1730 ABI_STAT_MALLOC(siz,(2,n0), ier) 1731 if (ier/= 0) call xmpi_abort(msg='error allocating siz in xmpi_bcast') 1732 if (me==master) then 1733 do ii=1,n0 1734 siz(1,ii)=size(xval(ii)%value,1) 1735 siz(2,ii)=size(xval(ii)%value,2) 1736 end do 1737 end if 1738 call MPI_BCAST(siz,2*n0,MPI_INTEGER,master,comm,ier) 1739 siztot=0 1740 do ii=1,n0 1741 siztot=siztot+siz(1,ii)*siz(2,ii) 1742 end do 1743 1744 ! Fill in the buffer 1745 ABI_STAT_MALLOC(mpibuf,(siztot), ier) 1746 if (ier/= 0) call xmpi_abort(msg='error allocating mpibuf in xmpi_bcast') 1747 if (me==master) then 1748 jj=0 1749 do ii=1,n0 1750 n1=siz(1,ii);n2=siz(2,ii) 1751 do kk=1,n2 1752 mpibuf(jj+1:jj+n1)=xval(ii)%value(1:n1,kk) 1753 jj=jj+n1 1754 end do 1755 end do 1756 end if 1757 1758 ! Broadcast the data 1759 call MPI_BCAST(mpibuf,siztot,MPI_INTEGER,master,comm,ier) 1760 1761 ! Retrieve the buffer 1762 jj=0 1763 do ii=1,n0 1764 n1=siz(1,ii);n2=siz(2,ii) 1765 if (.not.allocated(xval(ii)%value)) then 1766 ABI_STAT_MALLOC(xval(ii)%value,(n1,n2), ier) 1767 if (ier/= 0) call xmpi_abort(msg='error allocating xval%value in xmpi_bcast') 1768 end if 1769 do kk=1,n2 1770 xval(ii)%value(1:n1,kk)=mpibuf(jj+1:jj+n1) 1771 jj=jj+n1 1772 end do 1773 end do 1774 ABI_FREE(siz) 1775 ABI_FREE(mpibuf) 1776 1777 end if 1778 #endif 1779 1780 end subroutine xmpi_bcast_coeffi2_1d
ABINIT/xmpi_bcast_cplx1d [ Functions ]
NAME
xmpi_bcast_cplx1d
FUNCTION
Broadcasts data from master to slaves. Target: one-dimensional complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
1061 subroutine xmpi_bcast_cplx1d(xval,master,comm,ier) 1062 1063 !Arguments------------------------- 1064 complex(spc), DEV_CONTARRD intent(inout) :: xval(:) 1065 integer ,intent(in) :: comm,master 1066 integer ,intent(out) :: ier 1067 1068 !Local variables------------------- 1069 #if defined HAVE_MPI 1070 integer :: n 1071 #endif 1072 1073 ! ************************************************************************* 1074 1075 ier=0 1076 #if defined HAVE_MPI 1077 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1078 n=size(xval(:)) 1079 call MPI_BCAST(xval,n,MPI_COMPLEX,master,comm,ier) 1080 end if 1081 #endif 1082 1083 end subroutine xmpi_bcast_cplx1d
ABINIT/xmpi_bcast_cplx2d [ Functions ]
NAME
xmpi_bcast_cplx2d
FUNCTION
Broadcasts data from master to slaves. Target: two-dimensional complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1106 subroutine xmpi_bcast_cplx2d(xval,master,comm,ier) 1107 1108 !Arguments------------------------- 1109 complex(spc), DEV_CONTARRD intent(inout) :: xval(:,:) 1110 integer ,intent(in) :: comm,master 1111 integer ,intent(out) :: ier 1112 1113 !Local variables------------------- 1114 #if defined HAVE_MPI 1115 integer :: my_dt,my_op,n1,n2 1116 integer(kind=int64) :: ntot 1117 #endif 1118 1119 ! ************************************************************************* 1120 1121 ier=0 1122 #if defined HAVE_MPI 1123 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1124 n1=size(xval,dim=1) 1125 n2=size(xval,dim=2) 1126 1127 !This product of dimensions can be greater than a 32bit integer 1128 !We use a INT64 to store it. If it is too large, we switch to an 1129 !alternate routine because MPI<4 doesnt handle 64 bit counts. 1130 ntot=int(n1*n2,kind=int64) 1131 1132 if (ntot<=xmpi_maxint32_64) then 1133 call MPI_BCAST(xval,n1*n2,MPI_COMPLEX,master,comm,ier) 1134 else 1135 call xmpi_largetype_create(ntot,MPI_COMPLEX,my_dt,my_op,MPI_OP_NULL) 1136 call MPI_BCAST(xval,1,my_dt,master,comm,ier) 1137 call xmpi_largetype_free(my_dt,my_op) 1138 end if 1139 end if 1140 #endif 1141 1142 end subroutine xmpi_bcast_cplx2d
ABINIT/xmpi_bcast_cplx3d [ Functions ]
NAME
xmpi_bcast_cplx3d
FUNCTION
Broadcasts data from master to slaves. Target: three-dimensional complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1165 subroutine xmpi_bcast_cplx3d(xval,master,comm,ier) 1166 1167 !Arguments------------------------- 1168 complex(spc), DEV_CONTARRD intent(inout) :: xval(:,:,:) 1169 integer ,intent(in) :: comm,master 1170 integer ,intent(out) :: ier 1171 1172 !Local variables------------------- 1173 #if defined HAVE_MPI 1174 integer :: my_dt,my_op,n1,n2,n3 1175 integer(kind=int64) :: nn,ntot 1176 #endif 1177 1178 ! ************************************************************************* 1179 1180 ier=0 1181 #if defined HAVE_MPI 1182 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1183 n1=size(xval,dim=1) 1184 n2=size(xval,dim=2) 1185 n3=size(xval,dim=3) 1186 1187 !This product of dimensions can be greater than a 32bit integer 1188 !We use a INT64 to store it. If it is too large, we switch to an 1189 !alternate routine because MPI<4 doesnt handle 64 bit counts. 1190 ntot=int(n1*n2*n3,kind=int64) 1191 1192 if (ntot<=xmpi_maxint32_64) then 1193 else 1194 nn=int(n1*n2,kind=int64);if (nn>huge(0_int32)) nn=int(n1,kind=int64) 1195 call xmpi_largetype_create(ntot/nn,MPI_COMPLEX,my_dt,my_op,MPI_OP_NULL) 1196 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 1197 call xmpi_largetype_free(my_dt,my_op) 1198 end if 1199 end if 1200 #endif 1201 1202 end subroutine xmpi_bcast_cplx3d
ABINIT/xmpi_bcast_cplx4d [ Functions ]
NAME
xmpi_bcast_cplx4d
FUNCTION
Broadcasts data from master to slaves. Target: four-dimensional complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1225 subroutine xmpi_bcast_cplx4d(xval,master,comm,ier) 1226 1227 !Arguments------------------------- 1228 complex(spc), DEV_CONTARRD intent(inout) :: xval(:,:,:,:) 1229 integer ,intent(in) :: comm,master 1230 integer ,intent(out) :: ier 1231 1232 !Local variables------------------- 1233 #if defined HAVE_MPI 1234 integer :: my_dt,my_op,n1,n2,n3,n4 1235 integer(kind=int64) :: nn,ntot 1236 #endif 1237 1238 ! ************************************************************************* 1239 1240 ier=0 1241 #if defined HAVE_MPI 1242 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1243 n1=size(xval,dim=1) 1244 n2=size(xval,dim=2) 1245 n3=size(xval,dim=3) 1246 n4=size(xval,dim=4) 1247 1248 !This product of dimensions can be greater than a 32bit integer 1249 !We use a INT64 to store it. If it is too large, we switch to an 1250 !alternate routine because MPI<4 doesnt handle 64 bit counts. 1251 ntot=int(n1*n2*n3*n4,kind=int64) 1252 1253 if (ntot<=xmpi_maxint32_64) then 1254 call MPI_BCAST(xval,n1*n2*n3*n4,MPI_COMPLEX,master,comm,ier) 1255 else 1256 nn=int(n1*n2*n3,kind=int64) 1257 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 1258 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 1259 call xmpi_largetype_create(ntot/nn,MPI_COMPLEX,my_dt,my_op,MPI_OP_NULL) 1260 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 1261 call xmpi_largetype_free(my_dt,my_op) 1262 end if 1263 end if 1264 #endif 1265 1266 end subroutine xmpi_bcast_cplx4d
ABINIT/xmpi_bcast_cplxv [ Functions ]
NAME
xmpi_bcast_cplxv
FUNCTION
Broadcasts data from master to slaves. Target: scalar complexs.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
1009 subroutine xmpi_bcast_cplxv(xval,master,comm,ier) 1010 1011 !Arguments------------------------- 1012 complex(spc),intent(inout) :: xval 1013 integer ,intent(in) :: comm,master 1014 integer ,intent(out) :: ier 1015 1016 !Local variables------------------- 1017 #if defined HAVE_MPI 1018 complex(spc) :: arr_xval(1) 1019 #endif 1020 1021 1022 ! ************************************************************************* 1023 1024 ier=0 1025 #if defined HAVE_MPI 1026 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1027 arr_xval(1)=xval 1028 call MPI_BCAST(arr_xval,1,MPI_COMPLEX,master,comm,ier) 1029 xval=arr_xval(1) 1030 end if 1031 #endif 1032 1033 end subroutine xmpi_bcast_cplxv
ABINIT/xmpi_bcast_dc1d [ Functions ]
NAME
xmpi_bcast_dc1d
FUNCTION
Broadcasts data from master to slaves. Target: one-dimensional double complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1335 subroutine xmpi_bcast_dc1d(xval,master,comm,ier) 1336 1337 !Arguments------------------------- 1338 complex(dpc), DEV_CONTARRD intent(inout):: xval(:) 1339 integer ,intent(in) :: comm,master 1340 integer ,intent(out) :: ier 1341 1342 !Local variables------------------- 1343 #if defined HAVE_MPI 1344 integer :: n 1345 #endif 1346 1347 ! ************************************************************************* 1348 1349 ier=0 1350 #if defined HAVE_MPI 1351 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1352 n=size(xval(:)) 1353 call MPI_BCAST(xval,n,MPI_DOUBLE_COMPLEX,master,comm,ier) 1354 end if 1355 #endif 1356 1357 end subroutine xmpi_bcast_dc1d
ABINIT/xmpi_bcast_dc2d [ Functions ]
NAME
xmpi_bcast_dc2d
FUNCTION
Broadcasts data from master to slaves. Target: two-dimensional double complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1381 subroutine xmpi_bcast_dc2d(xval,master,comm,ier) 1382 1383 !Arguments------------------------- 1384 complex(dpc), DEV_CONTARRD intent(inout):: xval(:,:) 1385 integer ,intent(in) :: comm,master 1386 integer ,intent(out) :: ier 1387 1388 !Local variables------------------- 1389 #if defined HAVE_MPI 1390 integer :: my_dt,my_op,n1,n2 1391 integer(kind=int64) :: ntot 1392 #endif 1393 1394 ! ************************************************************************* 1395 1396 ier=0 1397 #if defined HAVE_MPI 1398 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1399 n1=size(xval,dim=1) 1400 n2=size(xval,dim=2) 1401 1402 !This product of dimensions can be greater than a 32bit integer 1403 !We use a INT64 to store it. If it is too large, we switch to an 1404 !alternate routine because MPI<4 doesnt handle 64 bit counts. 1405 ntot=int(n1*n2,kind=int64) 1406 1407 if (ntot<=xmpi_maxint32_64) then 1408 call MPI_BCAST(xval,n1*n2,MPI_DOUBLE_COMPLEX,master,comm,ier) 1409 else 1410 call xmpi_largetype_create(ntot,MPI_DOUBLE_COMPLEX,my_dt,my_op,MPI_OP_NULL) 1411 call MPI_BCAST(xval,1,my_dt,master,comm,ier) 1412 call xmpi_largetype_free(my_dt,my_op) 1413 end if 1414 end if 1415 #endif 1416 1417 end subroutine xmpi_bcast_dc2d
ABINIT/xmpi_bcast_dc3d [ Functions ]
NAME
xmpi_bcast_dc3d
FUNCTION
Broadcasts data from master to slaves. Target: three-dimensional double complex arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1440 subroutine xmpi_bcast_dc3d(xval,master,comm,ier) 1441 1442 !Arguments------------------------- 1443 complex(dpc), DEV_CONTARRD intent(inout):: xval(:,:,:) 1444 integer ,intent(in) :: comm,master 1445 integer ,intent(out) :: ier 1446 1447 !Local variables------------------- 1448 #if defined HAVE_MPI 1449 integer :: my_dt,my_op,n1,n2,n3 1450 integer(kind=int64) :: nn,ntot 1451 #endif 1452 1453 ! ************************************************************************* 1454 1455 ier=0 1456 #if defined HAVE_MPI 1457 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1458 n1=size(xval,dim=1) 1459 n2=size(xval,dim=2) 1460 n3=size(xval,dim=3) 1461 1462 !This product of dimensions can be greater than a 32bit integer 1463 !We use a INT64 to store it. If it is too large, we switch to an 1464 !alternate routine because MPI<4 doesnt handle 64 bit counts. 1465 ntot=int(n1*n2*n3,kind=int64) 1466 1467 if (ntot<=xmpi_maxint32_64) then 1468 call MPI_BCAST(xval,n1*n2*n3,MPI_DOUBLE_COMPLEX,master,comm,ier) 1469 else 1470 nn=int(n1*n2,kind=int64);if (nn>huge(0_int32)) nn=int(n1,kind=int64) 1471 call xmpi_largetype_create(ntot/nn,MPI_DOUBLE_COMPLEX,my_dt,my_op,MPI_OP_NULL) 1472 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 1473 call xmpi_largetype_free(my_dt,my_op) 1474 end if 1475 end if 1476 #endif 1477 1478 end subroutine xmpi_bcast_dc3d
ABINIT/xmpi_bcast_dc4d [ Functions ]
NAME
xmpi_bcast_dc4d
FUNCTION
Broadcasts data from master to slaves. Target: four-dimensional complex arrays in double precision.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1501 subroutine xmpi_bcast_dc4d(xval,master,comm,ier) 1502 1503 !Arguments------------------------- 1504 complex(dpc), DEV_CONTARRD intent(inout) :: xval(:,:,:,:) 1505 integer,intent(in) :: comm,master 1506 integer,intent(out) :: ier 1507 1508 !Local variables------------------- 1509 #if defined HAVE_MPI 1510 integer :: my_dt,my_op,n1,n2,n3,n4 1511 integer(kind=int64) :: nn,ntot 1512 #endif 1513 1514 ! ************************************************************************* 1515 1516 ier=0 1517 #if defined HAVE_MPI 1518 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1519 n1=size(xval,dim=1) 1520 n2=size(xval,dim=2) 1521 n3=size(xval,dim=3) 1522 n4=size(xval,dim=4) 1523 1524 !This product of dimensions can be greater than a 32bit integer 1525 !We use a INT64 to store it. If it is too large, we switch to an 1526 !alternate routine because MPI<4 doesnt handle 64 bit counts. 1527 ntot=int(n1*n2*n3*n4,kind=int64) 1528 1529 if (ntot<=xmpi_maxint32_64) then 1530 call MPI_BCAST(xval,n1*n2*n3*n4,MPI_DOUBLE_COMPLEX,master,comm,ier) 1531 else 1532 nn=int(n1*n2*n3,kind=int64) 1533 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 1534 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 1535 call xmpi_largetype_create(ntot/nn,MPI_DOUBLE_COMPLEX,my_dt,my_op,MPI_OP_NULL) 1536 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 1537 call xmpi_largetype_free(my_dt,my_op) 1538 end if 1539 end if 1540 #endif 1541 1542 end subroutine xmpi_bcast_dc4d
ABINIT/xmpi_bcast_dcv [ Functions ]
NAME
xmpi_bcast_dcv
FUNCTION
Broadcasts data from master to slaves. Target: scalar double complexs.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
1289 subroutine xmpi_bcast_dcv(xval,master,comm,ier) 1290 1291 !Arguments------------------------- 1292 complex(dpc),intent(inout) :: xval 1293 integer ,intent(in) :: comm,master 1294 integer ,intent(out) :: ier 1295 1296 !Local variables------------------- 1297 #if defined HAVE_MPI 1298 complex(dpc) :: arr_xval(1) 1299 #endif 1300 1301 ! ************************************************************************* 1302 1303 ier=0 1304 #if defined HAVE_MPI 1305 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1306 arr_xval(1)=xval 1307 call MPI_BCAST(arr_xval,1,MPI_DOUBLE_COMPLEX,master,comm,ier) 1308 xval=arr_xval(1) 1309 end if 1310 #endif 1311 1312 end subroutine xmpi_bcast_dcv
ABINIT/xmpi_bcast_dp1d [ Functions ]
NAME
xmpi_bcast_dp1d
FUNCTION
Broadcasts data from master to slaves. Target: double precision one-dimensional arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
368 subroutine xmpi_bcast_dp1d(xval,master,comm,ier) 369 370 !Arguments------------------------- 371 real(dp), DEV_CONTARRD intent(inout) :: xval(:) 372 integer ,intent(in) :: comm,master 373 integer ,intent(out) :: ier 374 375 !Local variables------------------- 376 #if defined HAVE_MPI 377 integer :: n 378 #endif 379 380 ! ************************************************************************* 381 382 ier=0 383 #if defined HAVE_MPI 384 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 385 n=size(xval,dim=1) 386 call MPI_BCAST(xval,n,MPI_DOUBLE_PRECISION,master,comm,ier) 387 end if 388 #endif 389 390 end subroutine xmpi_bcast_dp1d
ABINIT/xmpi_bcast_dp2d [ Functions ]
NAME
xmpi_bcast_dp2d
FUNCTION
Broadcasts data from master to slaves. Target: double precision two-dimensional arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
413 subroutine xmpi_bcast_dp2d(xval,master,comm,ier) 414 415 !Arguments------------------------- 416 real(dp), DEV_CONTARRD intent(inout) :: xval(:,:) 417 integer ,intent(in) :: comm,master 418 integer ,intent(out) :: ier 419 420 !Local variables------------------- 421 #if defined HAVE_MPI 422 integer :: my_dt,my_op,n1,n2 423 integer(kind=int64) :: ntot 424 #endif 425 426 ! ************************************************************************* 427 428 ier=0 429 #if defined HAVE_MPI 430 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 431 n1=size(xval,dim=1) 432 n2=size(xval,dim=2) 433 434 !This product of dimensions can be greater than a 32bit integer 435 !We use a INT64 to store it. If it is too large, we switch to an 436 !alternate routine because MPI<4 doesnt handle 64 bit counts. 437 ntot=int(n1*n2,kind=int64) 438 439 if (ntot<=xmpi_maxint32_64) then 440 call MPI_BCAST(xval,n1*n2,MPI_DOUBLE_PRECISION,master,comm,ier) 441 else 442 call xmpi_largetype_create(ntot,MPI_DOUBLE_PRECISION,my_dt,my_op,MPI_OP_NULL) 443 call MPI_BCAST(xval,1,my_dt,master,comm,ier) 444 call xmpi_largetype_free(my_dt,my_op) 445 end if 446 end if 447 #endif 448 449 end subroutine xmpi_bcast_dp2d
ABINIT/xmpi_bcast_dp3d [ Functions ]
NAME
xmpi_bcast_dp3d
FUNCTION
Broadcasts data from master to slaves. Target: double precision three-dimensional arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
472 subroutine xmpi_bcast_dp3d(xval,master,comm,ier) 473 474 !Arguments------------------------- 475 real(dp), DEV_CONTARRD intent(inout) :: xval(:,:,:) 476 integer ,intent(in) :: comm,master 477 integer ,intent(out) :: ier 478 479 !Local variables------------------- 480 #if defined HAVE_MPI 481 integer :: my_dt,my_op,n1,n2,n3 482 integer(kind=int64) :: nn,ntot 483 #endif 484 485 ! ************************************************************************* 486 487 ier=0 488 #if defined HAVE_MPI 489 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 490 n1=size(xval,dim=1) 491 n2=size(xval,dim=2) 492 n3=size(xval,dim=3) 493 494 !This product of dimensions can be greater than a 32bit integer 495 !We use a INT64 to store it. If it is too large, we switch to an 496 !alternate routine because MPI<4 doesnt handle 64 bit counts. 497 ntot=int(n1*n2*n3,kind=int64) 498 499 if (ntot<=xmpi_maxint32_64) then 500 call MPI_BCAST(xval,n1*n2*n3,MPI_DOUBLE_PRECISION,master,comm,ier) 501 else 502 nn=int(n1*n2,kind=int64);if (nn>huge(0_int32)) nn=int(n1,kind=int64) 503 call xmpi_largetype_create(ntot/nn,MPI_DOUBLE_PRECISION,my_dt,my_op,MPI_OP_NULL) 504 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 505 call xmpi_largetype_free(my_dt,my_op) 506 end if 507 end if 508 #endif 509 510 end subroutine xmpi_bcast_dp3d
ABINIT/xmpi_bcast_dp4d [ Functions ]
NAME
xmpi_bcast_dp4d
FUNCTION
Broadcasts data from master to slaves. Target: double precision four-dimensional arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
533 subroutine xmpi_bcast_dp4d(xval,master,comm,ier) 534 535 !Arguments------------------------- 536 real(dp), DEV_CONTARRD intent(inout) :: xval(:,:,:,:) 537 integer ,intent(in) :: comm,master 538 integer ,intent(out) :: ier 539 540 !Local variables------------------- 541 #if defined HAVE_MPI 542 integer :: my_dt,my_op,n1,n2,n3,n4 543 integer(kind=int64) :: nn,ntot 544 #endif 545 546 ! ************************************************************************* 547 548 ier=0 549 #if defined HAVE_MPI 550 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 551 n1=size(xval,dim=1) 552 n2=size(xval,dim=2) 553 n3=size(xval,dim=3) 554 n4=size(xval,dim=4) 555 556 !This product of dimensions can be greater than a 32bit integer 557 !We use a INT64 to store it. If it is too large, we switch to an 558 !alternate routine because MPI<4 doesnt handle 64 bit counts. 559 ntot=int(n1*n2*n3*n4,kind=int64) 560 561 if (ntot<=xmpi_maxint32_64) then 562 call MPI_BCAST(xval,n1*n2*n3*n4,MPI_DOUBLE_PRECISION,master,comm,ier) 563 else 564 nn=int(n1*n2*n3,kind=int64) 565 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 566 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 567 call xmpi_largetype_create(ntot/nn,MPI_DOUBLE_PRECISION,my_dt,my_op,MPI_OP_NULL) 568 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 569 call xmpi_largetype_free(my_dt,my_op) 570 end if 571 end if 572 #endif 573 574 end subroutine xmpi_bcast_dp4d
ABINIT/xmpi_bcast_dp5d [ Functions ]
NAME
xmpi_bcast_dp5d
FUNCTION
Broadcasts data from master to slaves. Target: double precision five-dimensional arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
597 subroutine xmpi_bcast_dp5d(xval,master,comm,ier) 598 599 !Arguments------------------------- 600 real(dp), DEV_CONTARRD intent(inout) :: xval(:,:,:,:,:) 601 integer ,intent(in) :: comm,master 602 integer ,intent(out) :: ier 603 604 !Local variables------------------- 605 #if defined HAVE_MPI 606 integer :: my_dt,my_op,n1,n2,n3,n4,n5 607 integer(kind=int64) :: nn,ntot 608 #endif 609 610 ! ************************************************************************* 611 612 ier=0 613 #if defined HAVE_MPI 614 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 615 n1=size(xval,dim=1) 616 n2=size(xval,dim=2) 617 n3=size(xval,dim=3) 618 n4=size(xval,dim=4) 619 n5=size(xval,dim=5) 620 621 !This product of dimensions can be greater than a 32bit integer 622 !We use a INT64 to store it. If it is too large, we switch to an 623 !alternate routine because MPI<4 doesnt handle 64 bit counts. 624 ntot=int(n1*n2*n3*n4*n5,kind=int64) 625 626 if (ntot<=xmpi_maxint32_64) then 627 call MPI_BCAST(xval,n1*n2*n3*n4*n5,MPI_DOUBLE_PRECISION,master,comm,ier) 628 else 629 nn=int(n1*n2*n3*n4,kind=int64) 630 if (nn>huge(0_int32)) nn=int(n1*n2*n3,kind=int64) 631 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 632 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 633 call xmpi_largetype_create(ntot/nn,MPI_DOUBLE_PRECISION,my_dt,my_op,MPI_OP_NULL) 634 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 635 call xmpi_largetype_free(my_dt,my_op) 636 end if 637 end if 638 #endif 639 640 end subroutine xmpi_bcast_dp5d
ABINIT/xmpi_bcast_dp6d [ Functions ]
NAME
xmpi_bcast_dp6d
FUNCTION
Broadcasts data from master to slaves. Target: double precision six-dimensional arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
663 subroutine xmpi_bcast_dp6d(xval,master,comm,ier) 664 665 !Arguments------------------------- 666 real(dp), DEV_CONTARRD intent(inout) :: xval(:,:,:,:,:,:) 667 integer ,intent(in) :: comm,master 668 integer ,intent(out) :: ier 669 670 !Local variables------------------- 671 #if defined HAVE_MPI 672 integer :: my_dt,my_op,n1,n2,n3,n4,n5,n6 673 integer(kind=int64) :: nn,ntot 674 #endif 675 676 ! ************************************************************************* 677 678 ier=0 679 #if defined HAVE_MPI 680 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 681 n1=size(xval,dim=1) 682 n2=size(xval,dim=2) 683 n3=size(xval,dim=3) 684 n4=size(xval,dim=4) 685 n5=size(xval,dim=5) 686 n6=size(xval,dim=6) 687 688 !This product of dimensions can be greater than a 32bit integer 689 !We use a INT64 to store it. If it is too large, we switch to an 690 !alternate routine because MPI<4 doesnt handle 64 bit counts. 691 ntot=int(n1*n2*n3*n4*n5*n6,kind=int64) 692 693 if (ntot<=xmpi_maxint32_64) then 694 call MPI_BCAST(xval,n1*n2*n3*n4*n5*n6,MPI_DOUBLE_PRECISION,master,comm,ier) 695 else 696 nn=int(n1*n2*n3*n4*n5,kind=int64) 697 if (nn>huge(0_int32)) nn=int(n1*n2*n3*n4,kind=int64) 698 if (nn>huge(0_int32)) nn=int(n1*n2*n3,kind=int64) 699 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 700 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 701 call xmpi_largetype_create(ntot/nn,MPI_DOUBLE_PRECISION,my_dt,my_op,MPI_OP_NULL) 702 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 703 call xmpi_largetype_free(my_dt,my_op) 704 end if 705 end if 706 #endif 707 708 end subroutine xmpi_bcast_dp6d
ABINIT/xmpi_bcast_dpv [ Functions ]
NAME
xmpi_bcast_dpv
FUNCTION
Broadcasts data from master to slaves. Target: scalar double precisions.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
317 subroutine xmpi_bcast_dpv(xval,master,comm,ier) 318 319 !Arguments ------------------------------------ 320 real(dp),intent(inout) :: xval 321 integer ,intent(in) :: comm,master 322 integer ,intent(out) :: ier 323 324 !Local variables------------------- 325 #if defined HAVE_MPI 326 real(dp) :: arr_xval(1) 327 #endif 328 329 ! ************************************************************************* 330 331 ier=0 332 #if defined HAVE_MPI 333 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 334 arr_xval(1)=xval 335 call MPI_BCAST(arr_xval,1,MPI_DOUBLE_PRECISION,master,comm,ier) 336 xval=arr_xval(1) 337 end if 338 #endif 339 340 end subroutine xmpi_bcast_dpv
ABINIT/xmpi_bcast_int1d [ Functions ]
NAME
xmpi_bcast_int1d
FUNCTION
Broadcasts data from master to slaves. Target: one-dimensional integer arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
70 subroutine xmpi_bcast_int1d(xval,master,comm,ier) 71 72 !Arguments ------------------------------------ 73 integer, DEV_CONTARRD intent(inout) :: xval(:) 74 integer,intent(in) :: comm,master 75 integer,intent(out) :: ier 76 77 !Local variables------------------------------- 78 integer :: n 79 80 ! ************************************************************************* 81 82 ier=0 83 #if defined HAVE_MPI 84 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 85 n=size(xval) 86 call MPI_BCAST(xval,n,MPI_INTEGER,master,comm,ier) 87 end if 88 #endif 89 end subroutine xmpi_bcast_int1d
ABINIT/xmpi_bcast_int2d [ Functions ]
NAME
xmpi_bcast_int2d
FUNCTION
Broadcasts data from master to slaves. Target: two-dimensional integer arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
117 subroutine xmpi_bcast_int2d(xval,master,comm,ier) 118 119 !Arguments------------------------- 120 integer, DEV_CONTARRD intent(inout) :: xval(:,:) 121 integer,intent(in) :: comm,master 122 integer,intent(out) :: ier 123 124 !Local variables------------------- 125 #if defined HAVE_MPI 126 integer :: my_dt,my_op,n1,n2 127 integer(kind=int64) :: ntot 128 #endif 129 130 ! ************************************************************************* 131 132 ier=0 133 #if defined HAVE_MPI 134 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 135 n1=size(xval,dim=1) 136 n2=size(xval,dim=2) 137 138 !This product of dimensions can be greater than a 32bit integer 139 !We use a INT64 to store it. If it is too large, we switch to an 140 !alternate routine because MPI<4 doesnt handle 64 bit counts. 141 ntot=int(n1*n2,kind=int64) 142 143 if (ntot<=xmpi_maxint32_64) then 144 call MPI_BCAST(xval,n1*n2,MPI_INTEGER,master,comm,ier) 145 else 146 call xmpi_largetype_create(ntot,MPI_INTEGER,my_dt,my_op,MPI_OP_NULL) 147 call MPI_BCAST(xval,1,my_dt,master,comm,ier) 148 call xmpi_largetype_free(my_dt,my_op) 149 end if 150 151 end if 152 #endif 153 154 end subroutine xmpi_bcast_int2d
ABINIT/xmpi_bcast_int3d [ Functions ]
NAME
xmpi_bcast_int3d
FUNCTION
Broadcasts data from master to slaves. Target: three-dimensional integer arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
182 subroutine xmpi_bcast_int3d(xval,master,comm,ier) 183 184 !Arguments------------------------- 185 integer, DEV_CONTARRD intent(inout) :: xval(:,:,:) 186 integer,intent(in) :: comm,master 187 integer,intent(out) :: ier 188 189 !Local variables------------------------------- 190 #if defined HAVE_MPI 191 integer :: my_dt,my_op,n1,n2,n3 192 integer(kind=int64) :: nn,ntot 193 #endif 194 195 ! ************************************************************************* 196 197 ier=0 198 #if defined HAVE_MPI 199 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 200 n1=size(xval,dim=1) 201 n2=size(xval,dim=2) 202 n3=size(xval,dim=3) 203 204 !This product of dimensions can be greater than a 32bit integer 205 !We use a INT64 to store it. If it is too large, we switch to an 206 !alternate routine because MPI<4 doesnt handle 64 bit counts. 207 ntot=int(n1*n2*n3,kind=int64) 208 209 if (ntot<=xmpi_maxint32_64) then 210 call MPI_BCAST(xval,n1*n2*n3,MPI_INTEGER,master,comm,ier) 211 else 212 nn=int(n1*n2,kind=int64);if (nn>huge(0_int32)) nn=int(n1,kind=int64) 213 call xmpi_largetype_create(ntot/nn,MPI_INTEGER,my_dt,my_op,MPI_OP_NULL) 214 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 215 call xmpi_largetype_free(my_dt,my_op) 216 end if 217 end if 218 #endif 219 220 end subroutine xmpi_bcast_int3d
ABINIT/xmpi_bcast_int4d [ Functions ]
NAME
xmpi_bcast_int4d
FUNCTION
Broadcasts data from master to slaves. Target: three-dimensional integer arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
PARENTS
CHILDREN
mpi_bcast
SOURCE
248 subroutine xmpi_bcast_int4d(xval,master,comm,ier) 249 250 !Arguments------------------------- 251 integer, DEV_CONTARRD intent(inout) :: xval(:,:,:,:) 252 integer,intent(in) :: comm,master 253 integer,intent(out) :: ier 254 255 !Local variables------------------------------- 256 #if defined HAVE_MPI 257 integer :: my_dt,my_op,n1,n2,n3,n4 258 integer(kind=int64) :: nn,ntot 259 #endif 260 261 ! ************************************************************************* 262 263 ier=0 264 #if defined HAVE_MPI 265 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 266 n1=size(xval,dim=1) 267 n2=size(xval,dim=2) 268 n3=size(xval,dim=3) 269 n4=size(xval,dim=4) 270 271 !This product of dimensions can be greater than a 32bit integer 272 !We use a INT64 to store it. If it is too large, we switch to an 273 !alternate routine because MPI<4 doesnt handle 64 bit counts. 274 ntot=int(n1*n2*n3*n4,kind=int64) 275 276 if (ntot<=xmpi_maxint32_64) then 277 call MPI_BCAST(xval,n1*n2*n3*n4,MPI_INTEGER,master,comm,ier) 278 else 279 nn=int(n1*n2*n3,kind=int64) 280 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 281 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 282 call xmpi_largetype_create(ntot/nn,MPI_INTEGER,my_dt,my_op,MPI_OP_NULL) 283 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 284 call xmpi_largetype_free(my_dt,my_op) 285 end if 286 end if 287 #endif 288 289 end subroutine xmpi_bcast_int4d
ABINIT/xmpi_bcast_intv [ Functions ]
NAME
xmpi_bcast_intv
FUNCTION
This module contains functions that calls MPI routine, if we compile the code using the MPI CPP flags. xmpi_bcast is the generic function.
COPYRIGHT
Copyright (C) 2001-2024 ABINIT group (Rshaltaf,AR,XG) This file is distributed under the terms of the GNU General Public License, see ~ABINIT/COPYING or http://www.gnu.org/copyleft/gpl.txt .
SOURCE
19 subroutine xmpi_bcast_intv(xval,master,comm,ier) 20 21 !Arguments------------------------- 22 integer,intent(inout) :: xval 23 integer,intent(in) :: comm,master 24 integer,intent(out) :: ier 25 26 !Local variables------------------- 27 #if defined HAVE_MPI 28 integer :: arr_xval(1) 29 #endif 30 31 ! ************************************************************************* 32 33 ier=0 34 #if defined HAVE_MPI 35 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 36 arr_xval(1)=xval 37 call MPI_BCAST(arr_xval,1,MPI_INTEGER,master,comm,ier) 38 xval=arr_xval(1) 39 end if 40 #endif 41 42 end subroutine xmpi_bcast_intv
ABINIT/xmpi_bcast_log0d [ Functions ]
NAME
xmpi_bcast_log0d
FUNCTION
Broadcasts data from master to slaves. Target: logical scalar
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SOURCE
1662 subroutine xmpi_bcast_log0d(xval,master,comm,ier) 1663 1664 !Arguments------------------------- 1665 logical,intent(inout) :: xval 1666 integer,intent(in) :: comm,master 1667 integer,intent(out) :: ier 1668 1669 !Local variables------------------- 1670 #if defined HAVE_MPI 1671 logical :: arr_xval(1) 1672 #endif 1673 1674 ! ************************************************************************* 1675 1676 ier=0 1677 #if defined HAVE_MPI 1678 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 1679 arr_xval(1)=xval 1680 call MPI_BCAST(arr_xval,1,MPI_LOGICAL,master,comm,ier) 1681 xval=arr_xval(1) 1682 end if 1683 #endif 1684 1685 end subroutine xmpi_bcast_log0d
ABINIT/xmpi_bcast_sp1d [ Functions ]
NAME
xmpi_bcast_sp1d
FUNCTION
Broadcasts data from master to slaves. Target: one-dimensional single precision arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
777 subroutine xmpi_bcast_sp1d(xval,master,comm,ier) 778 779 !Arguments------------------------- 780 real(sp), DEV_CONTARRD intent(inout) :: xval(:) 781 integer ,intent(in) :: comm,master 782 integer ,intent(out) :: ier 783 784 !Local variables------------------- 785 #if defined HAVE_MPI 786 integer :: n 787 #endif 788 789 ! ************************************************************************* 790 791 ier=0 792 #if defined HAVE_MPI 793 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 794 n=size(xval,dim=1) 795 call MPI_BCAST(xval,n,MPI_REAL,master,comm,ier) 796 end if 797 #endif 798 799 end subroutine xmpi_bcast_sp1d
ABINIT/xmpi_bcast_sp2d [ Functions ]
NAME
xmpi_bcast_sp2d
FUNCTION
Broadcasts data from master to slaves. Target: two-dimensional single precision arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
822 subroutine xmpi_bcast_sp2d(xval,master,comm,ier) 823 824 !Arguments------------------------- 825 real(sp), DEV_CONTARRD intent(inout) :: xval(:,:) 826 integer ,intent(in) :: comm,master 827 integer ,intent(out) :: ier 828 829 !Local variables------------------- 830 #if defined HAVE_MPI 831 integer :: my_dt,my_op,n1,n2 832 integer(kind=int64) :: ntot 833 #endif 834 835 ! ************************************************************************* 836 837 ier=0 838 #if defined HAVE_MPI 839 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 840 n1=size(xval,dim=1) 841 n2=size(xval,dim=2) 842 843 !This product of dimensions can be greater than a 32bit integer 844 !We use a INT64 to store it. If it is too large, we switch to an 845 !alternate routine because MPI<4 doesnt handle 64 bit counts. 846 ntot=int(n1*n2,kind=int64) 847 848 if (ntot<=xmpi_maxint32_64) then 849 call MPI_BCAST(xval,n1*n2,MPI_REAL,master,comm,ier) 850 else 851 call xmpi_largetype_create(ntot,MPI_REAL,my_dt,my_op,MPI_OP_NULL) 852 call MPI_BCAST(xval,1,my_dt,master,comm,ier) 853 call xmpi_largetype_free(my_dt,my_op) 854 end if 855 end if 856 #endif 857 858 end subroutine xmpi_bcast_sp2d
ABINIT/xmpi_bcast_sp3d [ Functions ]
NAME
xmpi_bcast_sp3d
FUNCTION
Broadcasts data from master to slaves. Target: three-dimensional single precision arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
881 subroutine xmpi_bcast_sp3d(xval,master,comm,ier) 882 883 !Arguments------------------------- 884 real(sp), DEV_CONTARRD intent(inout) :: xval(:,:,:) 885 integer ,intent(in) :: comm,master 886 integer ,intent(out) :: ier 887 888 !Local variables------------------- 889 #if defined HAVE_MPI 890 integer :: my_dt,my_op,n1,n2,n3 891 integer(kind=int64) :: nn,ntot 892 #endif 893 894 ! ************************************************************************* 895 896 ier=0 897 #if defined HAVE_MPI 898 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 899 n1=size(xval,dim=1) 900 n2=size(xval,dim=2) 901 n3=size(xval,dim=3) 902 903 !This product of dimensions can be greater than a 32bit integer 904 !We use a INT64 to store it. If it is too large, we switch to an 905 !alternate routine because MPI<4 doesnt handle 64 bit counts. 906 ntot=int(n1*n2*n3,kind=int64) 907 908 if (ntot<=xmpi_maxint32_64) then 909 else 910 nn=int(n1*n2,kind=int64);if (nn>huge(0_int32)) nn=int(n1,kind=int64) 911 call xmpi_largetype_create(ntot/nn,MPI_REAL,my_dt,my_op,MPI_OP_NULL) 912 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 913 call xmpi_largetype_free(my_dt,my_op) 914 end if 915 end if 916 #endif 917 918 end subroutine xmpi_bcast_sp3d
ABINIT/xmpi_bcast_sp4d [ Functions ]
NAME
xmpi_bcast_sp4d
FUNCTION
Broadcasts data from master to slaves. Target: four-dimensional single precision arrays.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
941 subroutine xmpi_bcast_sp4d(xval,master,comm,ier) 942 943 !Arguments------------------------- 944 real(sp), DEV_CONTARRD intent(inout) :: xval(:,:,:,:) 945 integer ,intent(in) :: comm,master 946 integer ,intent(out) :: ier 947 948 !Local variables------------------- 949 #if defined HAVE_MPI 950 integer :: my_dt,my_op,n1,n2,n3,n4 951 integer(kind=int64) :: nn,ntot 952 #endif 953 954 ! ************************************************************************* 955 956 ier=0 957 #if defined HAVE_MPI 958 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 959 n1=size(xval,dim=1) 960 n2=size(xval,dim=2) 961 n3=size(xval,dim=3) 962 n4=size(xval,dim=4) 963 964 !This product of dimensions can be greater than a 32bit integer 965 !We use a INT64 to store it. If it is too large, we switch to an 966 !alternate routine because MPI<4 doesnt handle 64 bit counts. 967 ntot=int(n1*n2*n3*n4,kind=int64) 968 969 if (ntot<=xmpi_maxint32_64) then 970 else 971 nn=int(n1*n2*n3,kind=int64) 972 if (nn>huge(0_int32)) nn=int(n1*n2,kind=int64) 973 if (nn>huge(0_int32)) nn=int(n1,kind=int64) 974 call xmpi_largetype_create(ntot/nn,MPI_REAL,my_dt,my_op,MPI_OP_NULL) 975 call MPI_BCAST(xval,int(nn,kind=int32),my_dt,master,comm,ier) 976 call xmpi_largetype_free(my_dt,my_op) 977 end if 978 end if 979 #endif 980 981 end subroutine xmpi_bcast_sp4d
ABINIT/xmpi_bcast_spv [ Functions ]
NAME
xmpi_bcast_spv
FUNCTION
Broadcasts data from master to slaves. Target: scalar single precisions.
INPUTS
comm= MPI communicator master= master MPI node
OUTPUT
ier= exit status, a non-zero value meaning there is an error
SIDE EFFECTS
xval= buffer array
SOURCE
731 subroutine xmpi_bcast_spv(xval,master,comm,ier) 732 733 !Arguments------------------------- 734 real(sp),intent(inout) :: xval 735 integer,intent(in) :: comm,master 736 integer,intent(out) :: ier 737 738 !Local variables------------------- 739 #if defined HAVE_MPI 740 real(sp) :: arr_xval(1) 741 #endif 742 743 ! ************************************************************************* 744 745 ier=0 746 #if defined HAVE_MPI 747 if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then 748 arr_xval(1)=xval 749 call MPI_BCAST(arr_xval,1,MPI_REAL,master,comm,ier) 750 xval=arr_xval(1) 751 end if 752 #endif 753 754 end subroutine xmpi_bcast_spv