TABLE OF CONTENTS

ABINIT/xmpi_bcast_ch0d [ Functions ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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 ]

[ Top ] [ 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