diff --git a/applications/test/parallel-comm2/Test-parallel-comm2.C b/applications/test/parallel-comm2/Test-parallel-comm2.C
index 17f8283d13..ce01dc7cf9 100644
--- a/applications/test/parallel-comm2/Test-parallel-comm2.C
+++ b/applications/test/parallel-comm2/Test-parallel-comm2.C
@@ -64,9 +64,12 @@ int main(int argc, char *argv[])
     argList::noBanner();
     argList::noCheckProcessorDirectories();
     argList::addBoolOption("verbose", "Set debug level");
+    argList::addBoolOption("info", "information");
     argList::addBoolOption("print-tree", "Report tree(s) as graph");
     argList::addBoolOption("comm-split", "Test simple comm split");
-    argList::addBoolOption("host-comm", "Test DIY host-comm split");
+    argList::addBoolOption("mpi-host-comm", "Test DIY host-comm split");
+    argList::addBoolOption("host-comm", "Test Pstream host-comm");
+    argList::addBoolOption("host-broadcast", "Test host-base broadcasts");
 
     // Capture manually. We need values before proper startup
     int nVerbose = 0;
@@ -90,76 +93,30 @@ int main(int argc, char *argv[])
         << " with " << UPstream::nComms() << " predefined comm(s)."
         << " proc:" << UPstream::myProcNo() << nl;
 
-    Info<< nl;
-
-    //- Process IDs within a given communicator
-    Info<< "procIDs: "
-        << flatOutput(UPstream::procID(UPstream::commWorld())) << endl;
-
-    rankInfo(UPstream::commWorld());
-    Pout<< endl;
-
-    const int myProci = UPstream::myProcNo(UPstream::commWorld());
-    int localRanki = myProci;
-
-    labelList subRanks;
-    UPstream::communicator newComm;
-
-
     if (UPstream::parRun() && optPrintTree)
     {
         Info<< "comms: " << UPstream::whichCommunication() << endl;
         UPstream::printCommTree(UPstream::commWorld());
     }
 
-    if (!args.found("comm-split") && !args.found("host-comm"))
+    if (args.found("info"))
     {
-        #if 1
-        // With first ranks
-        subRanks = identity(UPstream::nProcs(UPstream::commWorld()) / 2);
-
-        newComm.reset(UPstream::commWorld(), subRanks);
-        localRanki = UPstream::myProcNo(newComm);
-
-        Pout.prefix() =
-        (
-            '[' + Foam::name(myProci) + " a:" + Foam::name(localRanki) + "] "
-        );
+        Info<< nl;
 
+        //- Process IDs within a given communicator
         Info<< "procIDs: "
-            << flatOutput(UPstream::procID(newComm)) << endl;
+            << flatOutput(UPstream::procID(UPstream::commWorld())) << endl;
 
-        rankInfo(newComm);
+        rankInfo(UPstream::commWorld());
         Pout<< endl;
-        #endif
-
-        #if 1
-        // With every other rank
-        subRanks = identity(UPstream::nProcs(UPstream::commWorld()));
-
-        for (label& val : subRanks)
-        {
-            if (val % 2) val = -1;
-        }
-
-        newComm.reset(UPstream::commWorld(), subRanks);
-        localRanki = UPstream::myProcNo(newComm);
-
-        Pout.prefix() =
-        (
-            '[' + Foam::name(myProci) + " b:" + Foam::name(localRanki) + "] "
-        );
-
-        Info<< "procIDs: "
-            << flatOutput(UPstream::procID(newComm)) << endl;
-
-        rankInfo(newComm);
-        Pout<< endl;
-        #endif
     }
 
-    if (Pstream::parRun() && args.found("comm-split"))
+    bool generalTest = true;
+
+    if (UPstream::parRun() && args.found("comm-split"))
     {
+        generalTest = false;
+
         int world_nprocs = 0;
         int world_rank = -1;
         MPI_Comm_size(MPI_COMM_WORLD, &world_nprocs);
@@ -167,37 +124,37 @@ int main(int argc, char *argv[])
 
         int host_nprocs = 0;
         int host_rank = -1;
-        MPI_Comm hostComm;
+        MPI_Comm commIntraHost;
         MPI_Comm_split_type
         (
             MPI_COMM_WORLD,
             MPI_COMM_TYPE_SHARED,  // OMPI_COMM_TYPE_NODE
-            0, MPI_INFO_NULL, &hostComm
+            0, MPI_INFO_NULL, &commIntraHost
         );
 
-        MPI_Comm_size(hostComm, &host_nprocs);
-        MPI_Comm_rank(hostComm, &host_rank);
+        MPI_Comm_size(commIntraHost, &host_nprocs);
+        MPI_Comm_rank(commIntraHost, &host_rank);
 
         int leader_nprocs = 0;
         int leader_rank = -1;
-        MPI_Comm hostMasterComm;
+        MPI_Comm commInterHost;
 
         if (false)
         {
             // Easy enough to use MPI_Comm_split, but slightly annoying
             // that it returns MPI_COMM_NULL for unused ranks...
-            MPI_Comm hostMasterComm;
+            MPI_Comm commInterHost;
             MPI_Comm_split
             (
                 MPI_COMM_WORLD,
                 (host_rank == 0) ? 0 : MPI_UNDEFINED,
-                0, &hostMasterComm
+                0, &commInterHost
             );
 
-            if (hostMasterComm != MPI_COMM_NULL)
+            if (commInterHost != MPI_COMM_NULL)
             {
-                MPI_Comm_size(hostMasterComm, &leader_nprocs);
-                MPI_Comm_rank(hostMasterComm, &leader_rank);
+                MPI_Comm_size(commInterHost, &leader_nprocs);
+                MPI_Comm_rank(commInterHost, &leader_rank);
             }
         }
         else
@@ -242,35 +199,39 @@ int main(int argc, char *argv[])
                 MPI_COMM_WORLD,
                 active_group,
                 UPstream::msgType(),
-                &hostMasterComm
+                &commInterHost
             );
 
             // Groups not needed after this...
             MPI_Group_free(&parent_group);
             MPI_Group_free(&active_group);
 
-            MPI_Comm_size(hostMasterComm, &leader_nprocs);
-            MPI_Comm_rank(hostMasterComm, &leader_rank);
+            MPI_Comm_size(commInterHost, &leader_nprocs);
+            MPI_Comm_rank(commInterHost, &leader_rank);
         }
 
         Pout<< nl << "[MPI_Comm_split_type]" << nl
-            << "Host comm with " << host_rank << " / " << host_nprocs
+            << "Host rank " << host_rank << " / " << host_nprocs
             << " on " << hostName()
-            << " master:" << (host_rank == 0)
-            << " leader rank: " << leader_rank
-            << " / " << leader_nprocs
+            << " inter-rank: " << leader_rank << " / " << leader_nprocs
             << " host leader:" << (leader_rank == 0)
             << " sub-rank:" << (leader_rank > 0)
             << nl;
 
-        if (hostMasterComm != MPI_COMM_NULL)
+        if (commInterHost != MPI_COMM_NULL)
         {
-            MPI_Comm_free(&hostMasterComm);
+            MPI_Comm_free(&commInterHost);
+        }
+        if (commIntraHost != MPI_COMM_NULL)
+        {
+            MPI_Comm_free(&commIntraHost);
         }
-        MPI_Comm_free(&hostComm);
     }
-    if (Pstream::parRun() && args.found("host-comm"))
+
+    if (UPstream::parRun() && args.found("mpi-host-comm"))
     {
+        generalTest = false;
+
         // Host communicator, based on the current world communicator
         // Use hostname
         // Lowest rank per hostname is the IO rank
@@ -290,40 +251,32 @@ int main(int argc, char *argv[])
         // - pro: fixed digest length enables direct MPI calls
         //        can avoid Pstream::gatherList() during setup...
 
-        SHA1Digest myHostDigest(SHA1(hostName()).digest());
-
         List<SHA1Digest> digests;
         if (UPstream::master(UPstream::commGlobal()))
         {
             digests.resize(numprocs);
         }
 
-        UPstream::mpiGather
-        (
-            reinterpret_cast<const char*>(myHostDigest.cdata_bytes()),
-            SHA1Digest::max_size(),     // Num send per proc
-            digests.data_bytes(),       // Recv
-            SHA1Digest::max_size(),     // Num recv per proc
-            UPstream::commGlobal()
-        );
+        {
+            const SHA1Digest myHostDigest(SHA1(hostName()).digest());
 
-        // MPI_Gather
-        // (
-        //     myHostDigest.cdata_bytes(), // Send
-        //     SHA1Digest::max_size(),     // Num send per proc
-        //     MPI_BYTE,
-        //     digests.data_bytes(),       // Recv
-        //     SHA1Digest::max_size(),     // Num recv per proc
-        //     MPI_BYTE,
-        //     0,  //  root
-        //     MPI_COMM_WORLD
-        // );
+            UPstream::mpiGather
+            (
+                reinterpret_cast<const char*>(myHostDigest.cdata_bytes()),
+                SHA1Digest::max_size(),     // Num send per proc
+                digests.data_bytes(),       // Recv
+                SHA1Digest::max_size(),     // Num recv per proc
+                UPstream::commGlobal()
+            );
+        }
+
+
+        labelList hostIDs(numprocs);
+        DynamicList<label> subRanks(numprocs);
 
         Info<< "digests: " << digests << nl;
 
-        labelList hostIDs_(numprocs);
-
-        // Compact
+        // Compact numbering
         if (UPstream::master(UPstream::commGlobal()))
         {
             DynamicList<word> hostNames(numprocs);
@@ -332,95 +285,301 @@ int main(int argc, char *argv[])
             {
                 const word& host = hosts[proci];
 
-                hostIDs_[proci] = hostNames.find(host);
+                hostIDs[proci] = hostNames.find(host);
 
-                if (hostIDs_[proci] < 0)
+                if (hostIDs[proci] < 0)
                 {
                     // First appearance of host (encode as leader)
-                    hostIDs_[proci] = -(hostNames.size() + 1);
+                    hostIDs[proci] = -(hostNames.size() + 1);
                     hostNames.push_back(host);
-                }
+                 }
             }
+            hostIDs = -1;
 
-            DynamicList<SHA1Digest> hostDigest(numprocs);
+
+            DynamicList<SHA1Digest> uniqDigests(numprocs);
 
             forAll(digests, proci)
             {
                 const SHA1Digest& dig = digests[proci];
 
-                hostIDs_[proci] = hostDigest.find(dig);
+                hostIDs[proci] = uniqDigests.find(dig);
 
-                if (hostIDs_[proci] < 0)
+                if (hostIDs[proci] < 0)
                 {
                     // First appearance of host (encode as leader)
-                    hostIDs_[proci] = -(hostDigest.size() + 1);
-                    hostDigest.push_back(dig);
+                    hostIDs[proci] = -(uniqDigests.size() + 1);
+                    uniqDigests.push_back(dig);
                 }
             }
         }
 
+
         Info<< "hosts =  " << hosts << endl;
-        Info<< "hostIDs_ =  " << hostIDs_ << endl;
+        Info<< "hostIDs =  " << hostIDs << endl;
 
         UPstream::broadcast
         (
-            hostIDs_.data_bytes(),
-            hostIDs_.size_bytes(),
+            hostIDs.data_bytes(),
+            hostIDs.size_bytes(),
             UPstream::commGlobal(),
             UPstream::masterNo()
         );
 
-        DynamicList<label> subRanks(numprocs);
+        // Ranks for world to inter-host communicator
+        // - very straightforward
 
-        // Ranks for world to hostMaster
-        forAll(hostIDs_, proci)
+        #if 0
+        subRanks.clear();
+        forAll(hostIDs, proci)
         {
             // Is host leader?
-            if (hostIDs_[proci] < 0)
+            if (hostIDs[proci] < 0)
             {
                 subRanks.push_back(proci);
 
                 // Flip back to generic host id
-                hostIDs_[proci] = -(hostIDs_[proci] + 1);
+                hostIDs[proci] = -(hostIDs[proci] + 1);
             }
         }
 
         // From world to hostMaster
-        const label hostMasterComm =
+        const label commInterHost =
             UPstream::allocateCommunicator(UPstream::commGlobal(), subRanks);
+        #endif
 
+        const label myWorldProci = UPstream::myProcNo(UPstream::commGlobal());
 
-        const label myHostId =
-            hostIDs_[Pstream::myProcNo(UPstream::commGlobal())];
+        label myHostId = hostIDs[myWorldProci];
+        if (myHostId < 0) myHostId = -(myHostId + 1);  // Flip to generic id
 
         // Ranks for within a host
         subRanks.clear();
-        forAll(hostIDs_, proci)
+        forAll(hostIDs, proci)
         {
-            if (hostIDs_[proci] == myHostId)
+            label id = hostIDs[proci];
+            if (id < 0) id = -(id + 1);  // Flip to generic id
+
+            if (id == myHostId)
             {
                 subRanks.push_back(proci);
             }
         }
 
         // The intra-host ranks
-        const label hostComm =
+        const label commIntraHost =
             UPstream::allocateCommunicator(UPstream::commGlobal(), subRanks);
 
+
+        // Test what if we have intra-host comm and we want host-master
+
+        List<bool> isHostMaster(numprocs, false);
+        if (UPstream::master(commIntraHost))
+        {
+            isHostMaster[myWorldProci] = true;
+        }
+
+        UPstream::mpiAllGather
+        (
+            isHostMaster.data_bytes(),
+            sizeof(bool),
+            UPstream::commGlobal()
+        );
+
+        // Ranks for world to hostMaster
+        // - very straightforward
+        subRanks.clear();
+        forAll(isHostMaster, proci)
+        {
+            if (isHostMaster[proci])
+            {
+                subRanks.push_back(proci);
+            }
+        }
+
+        // From world to hostMaster
+        const label commInterHost =
+            UPstream::allocateCommunicator(UPstream::commGlobal(), subRanks);
+
+
         Pout<< nl << "[manual split]" << nl
-            << nl << "Host comm with "
-            << UPstream::myProcNo(hostComm)
-            << " / " << UPstream::nProcs(hostComm)
+            << nl << "Host rank " << UPstream::myProcNo(commIntraHost)
+            << " / " << UPstream::nProcs(commIntraHost)
             << " on " << hostName()
-            << " master:" << UPstream::master(hostComm)
-            << " leader rank: " << UPstream::myProcNo(hostMasterComm)
-            << " / " << UPstream::nProcs(hostMasterComm)
-            << " host leader:" << UPstream::master(hostMasterComm)
-            << " sub-rank:" << UPstream::is_subrank(hostMasterComm)
+            << ", inter-rank: " << UPstream::myProcNo(commInterHost)
+            << " / " << UPstream::nProcs(commInterHost)
+            << " host leader:" << UPstream::master(commInterHost)
+            << " sub-rank:" << UPstream::is_subrank(commInterHost)
             << nl;
 
-        UPstream::freeCommunicator(hostMasterComm);
-        UPstream::freeCommunicator(hostComm);
+        UPstream::freeCommunicator(commInterHost);
+        UPstream::freeCommunicator(commIntraHost);
+    }
+
+    if (UPstream::parRun() && args.found("host-comm"))
+    {
+        generalTest = false;
+        Info<< nl << "[pstream host-comm]" << nl << endl;
+
+        const label commInterHost = UPstream::commInterHost();
+        const label commIntraHost = UPstream::commIntraHost();
+
+        Pout<< "Host rank " << UPstream::myProcNo(commIntraHost)
+            << " / " << UPstream::nProcs(commIntraHost)
+            << " on " << hostName()
+            << ", inter-rank: " << UPstream::myProcNo(commInterHost)
+            << " / " << UPstream::nProcs(commInterHost)
+            << ", host leader:" << UPstream::master(commInterHost)
+            << " sub-rank:" << UPstream::is_subrank(commInterHost)
+            << endl;
+
+
+        {
+            Info<< "host-master: "
+                << UPstream::whichCommunication(commInterHost) << endl;
+
+            UPstream::printCommTree(commInterHost);
+            UPstream::printCommTree(commIntraHost);
+        }
+    }
+
+    if (UPstream::parRun() && args.found("host-broadcast"))
+    {
+        generalTest = false;
+        Info<< nl << "[pstream host-broadcast]" << nl << endl;
+
+        const label commInterHost = UPstream::commInterHost();
+        const label commIntraHost = UPstream::commIntraHost();
+
+        Pout<< "world rank: " << UPstream::myProcNo(UPstream::commWorld())
+            << " host-leader rank: "
+            << UPstream::myProcNo(UPstream::commInterHost())
+            << " intra-host rank: "
+            << UPstream::myProcNo(UPstream::commIntraHost())
+            << endl;
+
+        label value1(0), value2(0), value3(0);
+        label hostIndex = UPstream::myProcNo(commInterHost);
+
+        if (UPstream::master(commInterHost))
+        {
+            value1 = 100;
+            value2 = 200;
+        }
+        if (UPstream::master(commIntraHost))
+        {
+            value3 = 300;
+        }
+
+        Pstream::broadcast(value1, commInterHost);
+        Pstream::broadcast(value2, commIntraHost);
+        Pstream::broadcast(hostIndex, commIntraHost);
+
+        Pout<< "host: " << hostIndex
+            << " broadcast 1: "
+            << value1 << ' '
+            << value2 << ' '
+            << value3 << endl;
+
+        // re-broadcast
+        Pstream::broadcast(value1, commIntraHost);
+        Pout<< "host: " << hostIndex
+            << " broadcast 2: "
+            << value1 << endl;
+
+
+        label reduced1 = value1;
+        label reduced2 = value1;
+
+        reduce
+        (
+            reduced1,
+            sumOp<label>(),
+            UPstream::msgType(),
+            commIntraHost
+        );
+
+        reduce
+        (
+            reduced2,
+            sumOp<label>(),
+            UPstream::msgType(),
+            commInterHost
+        );
+
+        Pout<< "value1: (host) " << reduced1
+            << " (leader) " << reduced2 << endl;
+
+        // Pout<< "ranks: " << UPstream::nProcs(commInterHost) << endl;
+
+        wordList strings;
+        if (UPstream::is_rank(commInterHost))
+        {
+            strings.resize(UPstream::nProcs(commInterHost));
+            strings[UPstream::myProcNo(commInterHost)] = name(pid());
+        }
+
+        // Some basic gather/scatter
+        Pstream::allGatherList(strings, UPstream::msgType(), commInterHost);
+
+        Pout<< "pids " << flatOutput(strings) << endl;
+
+        Foam::reverse(strings);
+
+        Pstream::broadcast(strings, commIntraHost);
+        Pout<< "PIDS " << flatOutput(strings) << endl;
+    }
+
+
+    if (UPstream::parRun() && generalTest)
+    {
+        #if 1
+        // With first ranks
+        labelList subRanks =
+            identity(UPstream::nProcs(UPstream::commWorld()) / 2);
+
+        UPstream::communicator newComm;
+
+        newComm.reset(UPstream::commWorld(), subRanks);
+        label localRanki = UPstream::myProcNo(newComm);
+
+        const int myProci = UPstream::myProcNo(UPstream::commWorld());
+
+        Pout.prefix() =
+        (
+            '[' + Foam::name(myProci) + " a:" + Foam::name(localRanki) + "] "
+        );
+
+        Info<< "procIDs: "
+            << flatOutput(UPstream::procID(newComm)) << endl;
+
+        rankInfo(newComm);
+        Pout<< endl;
+        #endif
+
+        #if 1
+        // With every other rank
+        subRanks = identity(UPstream::nProcs(UPstream::commWorld()));
+
+        for (label& val : subRanks)
+        {
+            if (val % 2) val = -1;
+        }
+
+        newComm.reset(UPstream::commWorld(), subRanks);
+        localRanki = UPstream::myProcNo(newComm);
+
+        Pout.prefix() =
+        (
+            '[' + Foam::name(myProci) + " b:" + Foam::name(localRanki) + "] "
+        );
+
+        Info<< "procIDs: "
+            << flatOutput(UPstream::procID(newComm)) << endl;
+
+        rankInfo(newComm);
+        Pout<< endl;
+        #endif
     }
 
     Info<< "\nEnd\n" << endl;
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C b/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
index 14a5cbc7d1..ae95f15daf 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
@@ -33,6 +33,8 @@ Note
 #include "debug.H"
 #include "registerSwitch.H"
 #include "dictionary.H"
+#include "SHA1.H"
+#include "OSspecific.H"  // for hostName()
 #include "IOstreams.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -54,6 +56,85 @@ Foam::UPstream::commsTypeNames
 });
 
 
+// * * * * * * * * * * * * * * * Local Functions * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Determine host grouping.
+// Uses SHA1 of hostname instead of MPI_Comm_split or MPI_Comm_split_type
+// for two reasons:
+// - Comm_split returns an MPI_COMM_NULL on non-participating process
+//   which does not easily fit into the OpenFOAM framework
+//
+// - use the SHA1 of hostname allows a single MPI_Gather, determination of
+//   the inter-host vs intra-host (on the master) followed by a single
+//   broadcast of integers.
+//
+// Returns: the unique host indices with the leading hosts encoded
+// with negative values
+static List<int> getHostGroupIds(const label parentCommunicator)
+{
+    const label numProcs = UPstream::nProcs(parentCommunicator);
+
+    List<SHA1Digest> digests;
+    if (UPstream::master(parentCommunicator))
+    {
+        digests.resize(numProcs);
+    }
+
+    // Could also add lowercase etc, but since hostName()
+    // will be consistent within the same node, there is no need.
+    SHA1Digest myDigest(SHA1(hostName()).digest());
+
+    // The fixed-length digest allows use of MPI_Gather
+    // and avoids Pstream::gatherList() during setup...
+
+    UPstream::mpiGather
+    (
+        reinterpret_cast<const char*>(myDigest.cdata_bytes()),
+        SHA1Digest::max_size(),     // Num send per proc
+        digests.data_bytes(),       // Recv
+        SHA1Digest::max_size(),     // Num recv per proc
+        parentCommunicator
+    );
+
+    List<int> hostIDs(numProcs);
+
+    // Compact numbering of hosts.
+    if (UPstream::master(parentCommunicator))
+    {
+        DynamicList<SHA1Digest> uniqDigests;
+
+        forAll(digests, proci)
+        {
+            const SHA1Digest& dig = digests[proci];
+
+            hostIDs[proci] = uniqDigests.find(dig);
+
+            if (hostIDs[proci] < 0)
+            {
+                // First appearance of host. Encode as leader
+                hostIDs[proci] = -(uniqDigests.size() + 1);
+                uniqDigests.push_back(dig);
+            }
+        }
+    }
+
+    UPstream::broadcast
+    (
+        hostIDs.data_bytes(),
+        hostIDs.size_bytes(),
+        parentCommunicator,
+        UPstream::masterNo()
+    );
+
+    return hostIDs;
+}
+
+} // End namespace Foam
+
+
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
@@ -62,6 +143,11 @@ void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
     haveThreads_ = haveThreads;
 
     label comm = -1;
+    labelList singleProc(Foam::one{}, 0);
+
+    // Redo communicators that were created during static initialisation.
+    // When parRun == true, redo with MPI components
+    // When parRun == false, just redo in case of future changes
 
     if (!parRun_)
     {
@@ -73,7 +159,7 @@ void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
         freeCommunicator(UPstream::globalComm);
 
         // 0: worldComm
-        comm = allocateCommunicator(-1, Foam::labelList(Foam::one{}, 0), false);
+        comm = allocateCommunicator(-1, singleProc, false);
         if (comm != UPstream::globalComm)
         {
             // Failed sanity check
@@ -84,7 +170,7 @@ void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
         }
 
         // 1: selfComm
-        comm = allocateCommunicator(-2, Foam::labelList(Foam::one{}, 0), false);
+        comm = allocateCommunicator(-2, singleProc, false);
         if (comm != UPstream::selfComm)
         {
             // Failed sanity check
@@ -100,7 +186,7 @@ void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
     else
     {
         // Redo communicators that were created during static initialisation
-        // but this time with Pstream components
+        // but this time with MPI components
 
         // Using (world, self) ordering
         freeCommunicator(UPstream::selfComm);
@@ -117,11 +203,8 @@ void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
                 << Foam::exit(FatalError);
         }
 
-        Pout.prefix() = '[' +  Foam::name(myProcNo(comm)) + "] ";
-        Perr.prefix() = Pout.prefix();
-
         // 1: selfComm
-        comm = allocateCommunicator(-2, Foam::labelList(Foam::one{}, 0), true);
+        comm = allocateCommunicator(-2, singleProc, true);
         if (comm != UPstream::selfComm)
         {
             // Failed sanity check
@@ -130,6 +213,9 @@ void Foam::UPstream::setParRun(const label nProcs, const bool haveThreads)
                 << "  UPstream::selfComm:" << UPstream::selfComm
                 << Foam::exit(FatalError);
         }
+
+        Pout.prefix() = '[' +  Foam::name(myProcNo(globalComm)) + "] ";
+        Perr.prefix() = Pout.prefix();
     }
 
     if (debug)
@@ -180,7 +266,7 @@ Foam::label Foam::UPstream::allocateCommunicator
 (
     const label parentIndex,
     const labelUList& subRanks,
-    const bool doPstream
+    const bool withComponents
 )
 {
     const label index = getAvailableCommIndex(parentIndex);
@@ -193,7 +279,8 @@ Foam::label Foam::UPstream::allocateCommunicator
             << endl;
     }
 
-    // Initially treat as master, overwritten by allocatePstreamCommunicator
+    // Initially treat as master,
+    // overwritten by allocateCommunicatorComponents
     myProcNo_[index] = UPstream::masterNo();
 
     // The selected sub-ranks.
@@ -234,9 +321,9 @@ Foam::label Foam::UPstream::allocateCommunicator
     linearCommunication_[index].clear();
     treeCommunication_[index].clear();
 
-    if (doPstream && parRun())
+    if (withComponents && parRun())
     {
-        allocatePstreamCommunicator(parentIndex, index);
+        allocateCommunicatorComponents(parentIndex, index);
 
         // Could 'remember' locations of uninvolved ranks
         /// if (myProcNo_[index] < 0 && parentIndex >= 0)
@@ -257,10 +344,174 @@ Foam::label Foam::UPstream::allocateCommunicator
 }
 
 
+Foam::label Foam::UPstream::allocateInterHostCommunicator
+(
+    const label parentCommunicator
+)
+{
+    List<int> hostIDs = getHostGroupIds(parentCommunicator);
+
+    DynamicList<label> subRanks(hostIDs.size());
+
+    // From master to host-leader. Ranks between hosts.
+    forAll(hostIDs, proci)
+    {
+        // Is host leader?
+        if (hostIDs[proci] < 0)
+        {
+            subRanks.push_back(proci);
+        }
+    }
+
+    return allocateCommunicator(parentCommunicator, subRanks);
+}
+
+
+Foam::label Foam::UPstream::allocateIntraHostCommunicator
+(
+    const label parentCommunicator
+)
+{
+    List<int> hostIDs = getHostGroupIds(parentCommunicator);
+
+    DynamicList<label> subRanks(hostIDs.size());
+
+    // Intra-host ranks. Ranks within a host
+    int myHostId = hostIDs[UPstream::myProcNo(parentCommunicator)];
+    if (myHostId < 0) myHostId = -(myHostId + 1);  // Flip to generic id
+
+    forAll(hostIDs, proci)
+    {
+        int id = hostIDs[proci];
+        if (id < 0) id = -(id + 1);  // Flip to generic id
+
+        if (id == myHostId)
+        {
+            subRanks.push_back(proci);
+        }
+    }
+
+    return allocateCommunicator(parentCommunicator, subRanks);
+}
+
+
+bool Foam::UPstream::allocateHostCommunicatorPairs()
+{
+    // Use the world communicator (not global communicator)
+    const label parentCommunicator = worldComm;
+
+    // Skip if non-parallel
+    if (!parRun())
+    {
+        return false;
+    }
+
+    if (interHostComm_ >= 0 || intraHostComm_ >= 0)
+    {
+        // Failed sanity check
+        FatalErrorInFunction
+            << "Host communicator(s) already created!" << endl
+            << Foam::exit(FatalError);
+        return false;
+    }
+
+    interHostComm_ = getAvailableCommIndex(parentCommunicator);
+    intraHostComm_ = getAvailableCommIndex(parentCommunicator);
+
+    // Sorted order, purely cosmetic
+    if (intraHostComm_ < interHostComm_)
+    {
+        std::swap(intraHostComm_, interHostComm_);
+    }
+
+    // Overwritten later
+    myProcNo_[intraHostComm_] = UPstream::masterNo();
+    myProcNo_[interHostComm_] = UPstream::masterNo();
+
+    if (debug)
+    {
+        Pout<< "Allocating host communicators "
+            << interHostComm_ << ", " << intraHostComm_ << nl
+            << "    parent : " << parentCommunicator << nl
+            << endl;
+    }
+
+    List<int> hostIDs = getHostGroupIds(parentCommunicator);
+
+    DynamicList<int> subRanks(hostIDs.size());
+
+    // From master to host-leader. Ranks between hosts.
+    {
+        subRanks.clear();
+        forAll(hostIDs, proci)
+        {
+            // Is host leader?
+            if (hostIDs[proci] < 0)
+            {
+                subRanks.push_back(proci);
+
+                // Flip to generic host id
+                hostIDs[proci] = -(hostIDs[proci] + 1);
+            }
+        }
+
+        const label index = interHostComm_;
+
+        // Direct copy (subRanks is also int)
+        procIDs_[index] = subRanks;
+
+        // Implicitly: withComponents = true
+        if (parRun())  // Already checked...
+        {
+            allocateCommunicatorComponents(parentCommunicator, index);
+        }
+
+        // Sizing and filling are demand-driven
+        linearCommunication_[index].clear();
+        treeCommunication_[index].clear();
+    }
+
+    // Intra-host ranks. Ranks within a host
+    {
+        int myHostId = hostIDs[UPstream::myProcNo(parentCommunicator)];
+        if (myHostId < 0) myHostId = -(myHostId + 1);  // Flip to generic id
+
+        subRanks.clear();
+        forAll(hostIDs, proci)
+        {
+            int id = hostIDs[proci];
+            if (id < 0) id = -(id + 1);  // Flip to generic id
+
+            if (id == myHostId)
+            {
+                subRanks.push_back(proci);
+            }
+        }
+
+        const label index = intraHostComm_;
+
+        // Direct copy (subRanks is also int)
+        procIDs_[index] = subRanks;
+
+        // Implicitly: withComponents = true
+        if (parRun())  // Already checked...
+        {
+            allocateCommunicatorComponents(parentCommunicator, index);
+        }
+
+        // Sizing and filling are demand-driven
+        linearCommunication_[index].clear();
+        treeCommunication_[index].clear();
+    }
+
+    return true;
+}
+
+
 void Foam::UPstream::freeCommunicator
 (
     const label communicator,
-    const bool doPstream
+    const bool withComponents
 )
 {
     // Filter out any placeholders
@@ -269,6 +520,10 @@ void Foam::UPstream::freeCommunicator
         return;
     }
 
+    // Update demand-driven communicators
+    if (interHostComm_ == communicator) interHostComm_ = -1;
+    if (intraHostComm_ == communicator) intraHostComm_ = -1;
+
     if (debug)
     {
         Pout<< "Communicators : Freeing communicator " << communicator
@@ -277,9 +532,9 @@ void Foam::UPstream::freeCommunicator
             << endl;
     }
 
-    if (doPstream && parRun())
+    if (withComponents && parRun())
     {
-        freePstreamCommunicator(communicator);
+        freeCommunicatorComponents(communicator);
     }
 
     myProcNo_[communicator] = -1;
@@ -293,18 +548,6 @@ void Foam::UPstream::freeCommunicator
 }
 
 
-void Foam::UPstream::freeCommunicators(const bool doPstream)
-{
-    forAll(myProcNo_, communicator)
-    {
-        if (myProcNo_[communicator] >= 0)
-        {
-            freeCommunicator(communicator, doPstream);
-        }
-    }
-}
-
-
 int Foam::UPstream::baseProcNo(label comm, int procID)
 {
     while (UPstream::parent(comm) >= 0 && procID >= 0)
@@ -383,6 +626,48 @@ void Foam::UPstream::printCommTree(const label communicator)
 }
 
 
+Foam::label Foam::UPstream::commIntraHost()
+{
+    if (!parRun())
+    {
+        return worldComm;  // Don't know anything better to return
+    }
+    if (intraHostComm_ < 0)
+    {
+        allocateHostCommunicatorPairs();
+    }
+    return intraHostComm_;
+}
+
+
+Foam::label Foam::UPstream::commInterHost()
+{
+    if (!parRun())
+    {
+        return worldComm;  // Don't know anything better to return
+    }
+    if (interHostComm_ < 0)
+    {
+        allocateHostCommunicatorPairs();
+    }
+    return interHostComm_;
+}
+
+
+bool Foam::UPstream::hasHostComms()
+{
+    return (intraHostComm_ >= 0 || interHostComm_ >= 0);
+}
+
+
+void Foam::UPstream::clearHostComms()
+{
+    // Always with Pstream
+    freeCommunicator(intraHostComm_, true);
+    freeCommunicator(interHostComm_, true);
+}
+
+
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 bool Foam::UPstream::parRun_(false);
@@ -409,6 +694,9 @@ Foam::DynamicList<Foam::List<Foam::UPstream::commsStruct>>
 Foam::UPstream::treeCommunication_(16);
 
 
+Foam::label Foam::UPstream::intraHostComm_(-1);
+Foam::label Foam::UPstream::interHostComm_(-1);
+
 Foam::label Foam::UPstream::worldComm(0);
 Foam::label Foam::UPstream::warnComm(-1);
 
diff --git a/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H b/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H
index 053eb8b9aa..c2b38d6778 100644
--- a/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H
+++ b/src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H
@@ -217,6 +217,12 @@ private:
         //- Per processor the world index (into allWorlds_)
         static labelList worldIDs_;
 
+        //- Intra-host communicator
+        static label intraHostComm_;
+
+        //- Inter-host communicator (between host leaders)
+        static label interHostComm_;
+
 
     // Communicator specific data
 
@@ -247,8 +253,8 @@ private:
         //- Initialise entries for new communicator. Return the index
         static label getAvailableCommIndex(const label parentIndex);
 
-        //- Allocate a communicator with index
-        static void allocatePstreamCommunicator
+        //- Allocate MPI components of communicator with given index
+        static void allocateCommunicatorComponents
         (
             const label parentIndex,
             const label index
@@ -256,7 +262,11 @@ private:
 
         //- Free MPI components of communicator.
         //  Does not touch the first two communicators (SELF, WORLD)
-        static void freePstreamCommunicator(const label index);
+        static void freeCommunicatorComponents(const label index);
+
+        //- Allocate inter-host, intra-host communicators
+        //- with worldComm as parent
+        static bool allocateHostCommunicatorPairs();
 
 
 public:
@@ -348,6 +358,21 @@ public:
         static void printCommTree(const label communicator);
 
 
+    // Host Communicators
+
+        //- Demand-driven: Intra-host communicator (respects any local worlds)
+        static label commIntraHost();
+
+        //- Demand-driven: Inter-host communicator (respects any local worlds)
+        static label commInterHost();
+
+        //- Test for presence of any intra or inter host communicators
+        static bool hasHostComms();
+
+        //- Remove any existing intra and inter host communicators
+        static void clearHostComms();
+
+
     // Constructors
 
         //- Construct for given communication type
@@ -368,8 +393,8 @@ public:
             //! The sub-ranks of parent to use (ignore negative values)
             const labelUList& subRanks,
 
-            //! Call allocatePstreamCommunicator
-            const bool doPstream = true
+            //! Call allocateCommunicatorComponents()
+            const bool withComponents = true
         );
 
         //- Free a previously allocated communicator.
@@ -377,11 +402,20 @@ public:
         static void freeCommunicator
         (
             const label communicator,
-            const bool doPstream = true
+            const bool withComponents = true
         );
 
-        //- Free all communicators
-        static void freeCommunicators(const bool doPstream);
+        //- Allocate an inter-host communicator
+        static label allocateInterHostCommunicator
+        (
+            const label parentCommunicator = worldComm
+        );
+
+        //- Allocate an intra-host communicator
+        static label allocateIntraHostCommunicator
+        (
+            const label parentCommunicator = worldComm
+        );
 
 
         //- Wrapper class for allocating/freeing communicators
diff --git a/src/Pstream/dummy/UPstream.C b/src/Pstream/dummy/UPstream.C
index c9f74eca1d..573c094469 100644
--- a/src/Pstream/dummy/UPstream.C
+++ b/src/Pstream/dummy/UPstream.C
@@ -75,7 +75,7 @@ void Foam::UPstream::abort()
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-void Foam::UPstream::allocatePstreamCommunicator
+void Foam::UPstream::allocateCommunicatorComponents
 (
     const label,
     const label
@@ -83,7 +83,7 @@ void Foam::UPstream::allocatePstreamCommunicator
 {}
 
 
-void Foam::UPstream::freePstreamCommunicator(const label)
+void Foam::UPstream::freeCommunicatorComponents(const label)
 {}
 
 
diff --git a/src/Pstream/mpi/UPstream.C b/src/Pstream/mpi/UPstream.C
index d841666199..b980948228 100644
--- a/src/Pstream/mpi/UPstream.C
+++ b/src/Pstream/mpi/UPstream.C
@@ -451,12 +451,9 @@ void Foam::UPstream::shutdown(int errNo)
     }
 
     // Clean mpi communicators
-    forAll(myProcNo_, communicator)
+    forAllReverse(myProcNo_, communicator)
     {
-        if (myProcNo_[communicator] >= 0)
-        {
-            freePstreamCommunicator(communicator);
-        }
+        freeCommunicatorComponents(communicator);
     }
 
     if (!flag)
@@ -497,7 +494,7 @@ void Foam::UPstream::abort()
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-void Foam::UPstream::allocatePstreamCommunicator
+void Foam::UPstream::allocateCommunicatorComponents
 (
     const label parentIndex,
     const label index
@@ -534,7 +531,7 @@ void Foam::UPstream::allocatePstreamCommunicator
 
         // TBD: MPI_Comm_dup(MPI_COMM_WORLD, ...);
         // with pendingMPIFree_[index] = true
-        // Note: freePstreamCommunicator may need an update
+        // Note: freeCommunicatorComponents() may need an update
 
         MPI_Comm_rank
         (
@@ -661,13 +658,12 @@ void Foam::UPstream::allocatePstreamCommunicator
 }
 
 
-void Foam::UPstream::freePstreamCommunicator(const label index)
+void Foam::UPstream::freeCommunicatorComponents(const label index)
 {
     // Skip placeholders and pre-defined (not allocated) communicators
-
     if (UPstream::debug)
     {
-        Pout<< "freePstreamCommunicator: " << index
+        Pout<< "freeCommunicatorComponents: " << index
             << " from " << PstreamGlobals::MPICommunicators_.size() << endl;
     }