diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
index 2521f7b1d2..1204ac5976 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightField.C
@@ -110,30 +110,40 @@ void writeAllData
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                toMaster<< map(vf, prims, cmpt);
+            }
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             ensightFile << key << nl;
 
+            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                fromSlaves.set(slave, new UIPstream(slave, pBufs));
+            }
+
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeData(map(vf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    IPstream fromSlave(Pstream::scheduled, slave);
-                    scalarField data(fromSlave);
+                    scalarField data(fromSlaves[slave]);
                     writeData(data, ensightFile);
                 }
             }
         }
-        else
-        {
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                toMaster<< map(vf, prims, cmpt);
-            }
-        }
     }
 }
 
@@ -150,30 +160,40 @@ void writeAllDataBinary
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                toMaster<< map(vf, prims, cmpt);
+            }
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightFile);
 
+            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                fromSlaves.set(slave, new UIPstream(slave, pBufs));
+            }
+
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeEnsDataBinary(map(vf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    IPstream fromSlave(Pstream::scheduled, slave);
-                    scalarField data(fromSlave);
+                    scalarField data(fromSlaves[slave]);
                     writeEnsDataBinary(data, ensightFile);
                 }
             }
         }
-        else
-        {
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                toMaster<< map(vf, prims, cmpt);
-            }
-        }
     }
 }
 
@@ -190,31 +210,40 @@ void writeAllFaceData
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                toMaster<< map(pf, prims, cmpt);
+            }
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             ensightFile << key << nl;
 
+            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                fromSlaves.set(slave, new UIPstream(slave, pBufs));
+            }
+
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeData(map(pf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    IPstream fromSlave(Pstream::scheduled, slave);
-                    scalarField pf(fromSlave);
-
+                    scalarField pf(fromSlaves[slave]);
                     writeData(pf, ensightFile);
                 }
             }
         }
-        else
-        {
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                toMaster<< map(pf, prims, cmpt);
-            }
-        }
     }
 }
 
@@ -231,31 +260,40 @@ void writeAllFaceDataBinary
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+            {
+                toMaster<< map(pf, prims, cmpt);
+            }
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightFile);
 
+            PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            {
+                fromSlaves.set(slave, new UIPstream(slave, pBufs));
+            }
+
             for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
             {
                 writeEnsDataBinary(map(pf, prims, cmpt), ensightFile);
 
                 for (int slave=1; slave<Pstream::nProcs(); slave++)
                 {
-                    IPstream fromSlave(Pstream::scheduled, slave);
-                    scalarField pf(fromSlave);
-
+                    scalarField pf(fromSlaves[slave]);
                     writeEnsDataBinary(pf, ensightFile);
                 }
             }
         }
-        else
-        {
-            for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-            {
-                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                toMaster<< map(pf, prims, cmpt);
-            }
-        }
     }
 }
 
@@ -554,10 +592,29 @@ void ensightFieldAscii
 
         if (meshCellSets.nHexesWedges)
         {
+            PstreamBuffers pBufs(Pstream::nonBlocking);
+
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+                {
+                    toMaster<< map(vf, hexes, wedges, cmpt);
+                }
+            }
+
+            pBufs.finishedSends();
+
             if (Pstream::master())
             {
                 ensightFile << "hexa8" << nl;
 
+                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
+                }
+
                 for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
                 {
                     writeData
@@ -568,20 +625,11 @@ void ensightFieldAscii
 
                     for (int slave=1; slave<Pstream::nProcs(); slave++)
                     {
-                        IPstream fromSlave(Pstream::scheduled, slave);
-                        scalarField data(fromSlave);
+                        scalarField data(fromSlaves[slave]);
                         writeData(data, ensightFile);
                     }
                 }
             }
-            else
-            {
-                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-                {
-                    OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                    toMaster<< map(vf, hexes, wedges, cmpt);
-                }
-            }
         }
 
         writeAllData("penta6", vf, prisms, meshCellSets.nPrisms, ensightFile);
@@ -695,10 +743,29 @@ void ensightFieldBinary
 
         if (meshCellSets.nHexesWedges)
         {
+            PstreamBuffers pBufs(Pstream::nonBlocking);
+
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
+                {
+                    toMaster<< map(vf, hexes, wedges, cmpt);
+                }
+            }
+
+            pBufs.finishedSends();
+
             if (Pstream::master())
             {
                 writeEnsDataBinary("hexa8",ensightFile);
 
+                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
+                }
+
                 for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
                 {
                     writeEnsDataBinary
@@ -709,20 +776,11 @@ void ensightFieldBinary
 
                     for (int slave=1; slave<Pstream::nProcs(); slave++)
                     {
-                        IPstream fromSlave(Pstream::scheduled, slave);
-                        scalarField data(fromSlave);
+                        scalarField data(fromSlaves[slave]);
                         writeEnsDataBinary(data, ensightFile);
                     }
                 }
             }
-            else
-            {
-                for (direction cmpt=0; cmpt<pTraits<Type>::nComponents; cmpt++)
-                {
-                    OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                    toMaster<< map(vf, hexes, wedges, cmpt);
-                }
-            }
         }
 
         writeAllDataBinary
diff --git a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
index 19920b008a..4298ac43d1 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToEnsight/ensightMesh.C
@@ -467,104 +467,125 @@ void Foam::ensightMesh::writeAllPolys
         }
 
         // Number of faces for each poly cell
-        if (Pstream::master())
         {
-            // Master
-            writePolysNFaces
-            (
-                meshCellSets_.polys,
-                cellFaces,
-                ensightGeometryFile
-            );
-            // Slaves
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                labelList polys(fromSlave);
-                cellList cellFaces(fromSlave);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< meshCellSets_.polys << cellFaces;
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                // Master
                 writePolysNFaces
                 (
-                    polys,
+                    meshCellSets_.polys,
                     cellFaces,
                     ensightGeometryFile
                 );
+                // Slaves
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+
+                    writePolysNFaces
+                    (
+                        polys,
+                        cellFaces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< meshCellSets_.polys << cellFaces;
-        }
 
 
         // Number of points for each face of the above list
-        if (Pstream::master())
         {
-            // Master
-            writePolysNPointsPerFace
-            (
-                meshCellSets_.polys,
-                cellFaces,
-                faces,
-                ensightGeometryFile
-            );
-            // Slaves
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                labelList polys(fromSlave);
-                cellList cellFaces(fromSlave);
-                faceList faces(fromSlave);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< meshCellSets_.polys << cellFaces << faces;
+            }
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                // Master
                 writePolysNPointsPerFace
                 (
-                    polys,
+                    meshCellSets_.polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
+                // Slaves
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+                    faceList faces(fromSlave);
+
+                    writePolysNPointsPerFace
+                    (
+                        polys,
+                        cellFaces,
+                        faces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< meshCellSets_.polys << cellFaces << faces;
-        }
+
 
         // List of points id for each face of the above list
-        if (Pstream::master())
         {
-            // Master
-            writePolysPoints
-            (
-                meshCellSets_.polys,
-                cellFaces,
-                faces,
-                ensightGeometryFile
-            );
-            // Slaves
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                labelList polys(fromSlave);
-                cellList cellFaces(fromSlave);
-                faceList faces(fromSlave);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< meshCellSets_.polys << cellFaces << faces;
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                // Master
                 writePolysPoints
                 (
-                    polys,
+                    meshCellSets_.polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
+                // Slaves
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+                    faceList faces(fromSlave);
+
+                    writePolysPoints
+                    (
+                        polys,
+                        cellFaces,
+                        faces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< meshCellSets_.polys << cellFaces << faces;
-        }
     }
 }
 
@@ -659,103 +680,124 @@ void Foam::ensightMesh::writeAllPolysBinary
         }
 
         // Number of faces for each poly cell
-        if (Pstream::master())
         {
-            // Master
-            writePolysNFacesBinary
-            (
-                meshCellSets_.polys,
-                cellFaces,
-                ensightGeometryFile
-            );
-            // Slaves
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                labelList polys(fromSlave);
-                cellList cellFaces(fromSlave);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< meshCellSets_.polys << cellFaces;
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                // Master
                 writePolysNFacesBinary
                 (
-                    polys,
+                    meshCellSets_.polys,
                     cellFaces,
                     ensightGeometryFile
                 );
+                // Slaves
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+
+                    writePolysNFacesBinary
+                    (
+                        polys,
+                        cellFaces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< meshCellSets_.polys << cellFaces;
-        }
 
         // Number of points for each face of the above list
-        if (Pstream::master())
         {
-            // Master
-            writePolysNPointsPerFaceBinary
-            (
-                meshCellSets_.polys,
-                cellFaces,
-                faces,
-                ensightGeometryFile
-            );
-            // Slaves
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                labelList polys(fromSlave);
-                cellList cellFaces(fromSlave);
-                faceList faces(fromSlave);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< meshCellSets_.polys << cellFaces << faces;
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                // Master
                 writePolysNPointsPerFaceBinary
                 (
-                    polys,
+                    meshCellSets_.polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
+                // Slaves
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+                    faceList faces(fromSlave);
+
+                    writePolysNPointsPerFaceBinary
+                    (
+                        polys,
+                        cellFaces,
+                        faces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< meshCellSets_.polys << cellFaces << faces;
-        }
 
         // List of points id for each face of the above list
-        if (Pstream::master())
         {
-            // Master
-            writePolysPointsBinary
-            (
-                meshCellSets_.polys,
-                cellFaces,
-                faces,
-                ensightGeometryFile
-            );
-            // Slaves
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
-            {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                labelList polys(fromSlave);
-                cellList cellFaces(fromSlave);
-                faceList faces(fromSlave);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
+            if (!Pstream::master())
+            {
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< meshCellSets_.polys << cellFaces << faces;
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                // Master
                 writePolysPointsBinary
                 (
-                    polys,
+                    meshCellSets_.polys,
                     cellFaces,
                     faces,
                     ensightGeometryFile
                 );
+                // Slaves
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    labelList polys(fromSlave);
+                    cellList cellFaces(fromSlave);
+                    faceList faces(fromSlave);
+
+                    writePolysPointsBinary
+                    (
+                        polys,
+                        cellFaces,
+                        faces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< meshCellSets_.polys << cellFaces << faces;
-        }
     }
 }
 
@@ -770,6 +812,16 @@ void Foam::ensightMesh::writeAllPrims
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            toMaster<< cellShapes;
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
@@ -778,17 +830,12 @@ void Foam::ensightMesh::writeAllPrims
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
+                UIPstream fromSlave(slave, pBufs);
                 cellShapeList cellShapes(fromSlave);
 
                 writePrims(cellShapes, ensightGeometryFile);
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< cellShapes;
-        }
     }
 }
 
@@ -803,6 +850,16 @@ void Foam::ensightMesh::writeAllPrimsBinary
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            toMaster<< cellShapes;
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightGeometryFile);
@@ -812,17 +869,12 @@ void Foam::ensightMesh::writeAllPrimsBinary
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
+                UIPstream fromSlave(slave, pBufs);
                 cellShapeList cellShapes(fromSlave);
 
                 writePrimsBinary(cellShapes, ensightGeometryFile);
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< cellShapes;
-        }
     }
 }
 
@@ -833,18 +885,15 @@ void Foam::ensightMesh::writeFacePrims
     OFstream& ensightGeometryFile
 ) const
 {
-    if (patchFaces.size())
+    forAll(patchFaces, i)
     {
-        forAll(patchFaces, i)
-        {
-            const face& patchFace = patchFaces[i];
+        const face& patchFace = patchFaces[i];
 
-            forAll(patchFace, pointI)
-            {
-                ensightGeometryFile << setw(10) << patchFace[pointI] + 1;
-            }
-            ensightGeometryFile << nl;
+        forAll(patchFace, pointI)
+        {
+            ensightGeometryFile << setw(10) << patchFace[pointI] + 1;
         }
+        ensightGeometryFile << nl;
     }
 }
 
@@ -855,16 +904,13 @@ void Foam::ensightMesh::writeFacePrimsBinary
     std::ofstream& ensightGeometryFile
 ) const
 {
-    if (patchFaces.size())
+    forAll(patchFaces, i)
     {
-        forAll(patchFaces, i)
-        {
-            const face& patchFace = patchFaces[i];
+        const face& patchFace = patchFaces[i];
 
-            forAll(patchFace, pointI)
-            {
-                writeEnsDataBinary(patchFace[pointI] + 1, ensightGeometryFile);
-            }
+        forAll(patchFace, pointI)
+        {
+            writeEnsDataBinary(patchFace[pointI] + 1, ensightGeometryFile);
         }
     }
 }
@@ -881,6 +927,16 @@ void Foam::ensightMesh::writeAllFacePrims
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             ensightGeometryFile << key << nl << setw(10) << nPrims << nl;
@@ -893,17 +949,12 @@ void Foam::ensightMesh::writeAllFacePrims
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
+                UIPstream fromSlave(slave, pBufs);
                 faceList patchFaces(fromSlave);
 
                 writeFacePrims(patchFaces, ensightGeometryFile);
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< UIndirectList<face>(patchFaces, prims);
-        }
     }
 }
 
@@ -948,53 +999,67 @@ void Foam::ensightMesh::writeAllNSided
         }
 
         // Number of points for each face
-        if (Pstream::master())
         {
-            writeNSidedNPointsPerFace
-            (
-                UIndirectList<face>(patchFaces, prims)(),
-                ensightGeometryFile
-            );
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            if (!Pstream::master())
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                faceList patchFaces(fromSlave);
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< UIndirectList<face>(patchFaces, prims);
+            }
 
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
                 writeNSidedNPointsPerFace
                 (
-                    patchFaces,
+                    UIndirectList<face>(patchFaces, prims)(),
                     ensightGeometryFile
                 );
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    faceList patchFaces(fromSlave);
+
+                    writeNSidedNPointsPerFace
+                    (
+                        patchFaces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< UIndirectList<face>(patchFaces, prims);
-        }
 
         // List of points id for each face
-        if (Pstream::master())
         {
-            writeNSidedPoints
-            (
-                UIndirectList<face>(patchFaces, prims)(),
-                ensightGeometryFile
-            );
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            if (!Pstream::master())
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                faceList patchFaces(fromSlave);
-
-                writeNSidedPoints(patchFaces, ensightGeometryFile);
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< UIndirectList<face>(patchFaces, prims);
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                writeNSidedPoints
+                (
+                    UIndirectList<face>(patchFaces, prims)(),
+                    ensightGeometryFile
+                );
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    faceList patchFaces(fromSlave);
+
+                    writeNSidedPoints(patchFaces, ensightGeometryFile);
+                }
             }
-        }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< UIndirectList<face>(patchFaces, prims);
         }
     }
 }
@@ -1040,53 +1105,71 @@ void Foam::ensightMesh::writeAllNSidedBinary
         }
 
         // Number of points for each face
-        if (Pstream::master())
         {
-            writeNSidedNPointsPerFaceBinary
-            (
-                UIndirectList<face>(patchFaces, prims)(),
-                ensightGeometryFile
-            );
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            if (!Pstream::master())
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                faceList patchFaces(fromSlave);
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< UIndirectList<face>(patchFaces, prims);
+            }
 
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
                 writeNSidedNPointsPerFaceBinary
                 (
-                    patchFaces,
+                    UIndirectList<face>(patchFaces, prims)(),
                     ensightGeometryFile
                 );
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    faceList patchFaces(fromSlave);
+
+                    writeNSidedNPointsPerFaceBinary
+                    (
+                        patchFaces,
+                        ensightGeometryFile
+                    );
+                }
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< UIndirectList<face>(patchFaces, prims);
-        }
 
         // List of points id for each face
-        if (Pstream::master())
         {
-            writeNSidedPointsBinary
-            (
-                UIndirectList<face>(patchFaces, prims)(),
-                ensightGeometryFile
-            );
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
-            for (int slave=1; slave<Pstream::nProcs(); slave++)
+            if (!Pstream::master())
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
-                faceList patchFaces(fromSlave);
-
-                writeNSidedPointsBinary(patchFaces, ensightGeometryFile);
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                toMaster<< UIndirectList<face>(patchFaces, prims);
+            }
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
+            {
+                writeNSidedPointsBinary
+                (
+                    UIndirectList<face>(patchFaces, prims)(),
+                    ensightGeometryFile
+                );
+
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    UIPstream fromSlave(slave, pBufs);
+                    faceList patchFaces(fromSlave);
+
+                    writeNSidedPointsBinary
+                    (
+                        patchFaces,
+                        ensightGeometryFile
+                    );
+                }
             }
-        }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< UIndirectList<face>(patchFaces, prims);
         }
     }
 }
@@ -1103,6 +1186,16 @@ void Foam::ensightMesh::writeAllFacePrimsBinary
 {
     if (nPrims)
     {
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        if (!Pstream::master())
+        {
+            UOPstream toMaster(Pstream::masterNo(), pBufs);
+            toMaster<< UIndirectList<face>(patchFaces, prims);
+        }
+
+        pBufs.finishedSends();
+
         if (Pstream::master())
         {
             writeEnsDataBinary(key,ensightGeometryFile);
@@ -1116,17 +1209,12 @@ void Foam::ensightMesh::writeAllFacePrimsBinary
 
             for (int slave=1; slave<Pstream::nProcs(); slave++)
             {
-                IPstream fromSlave(Pstream::scheduled, slave);
+                UIPstream fromSlave(slave, pBufs);
                 faceList patchFaces(fromSlave);
 
                 writeFacePrimsBinary(patchFaces, ensightGeometryFile);
             }
         }
-        else
-        {
-            OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-            toMaster<< UIndirectList<face>(patchFaces, prims);
-        }
     }
 }
 
@@ -1245,34 +1333,47 @@ void Foam::ensightMesh::writeAscii
     {
         label nPoints = globalPoints.size();
 
-        if (Pstream::master())
         {
-            ensightGeometryFile
-                << "part" << nl
-                << setw(10) << 1 << nl
-                << "internalMesh" << nl
-                << "coordinates" << nl
-                << setw(10) << nPoints
-                << endl;
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
-            for (direction d=0; d<vector::nComponents; d++)
+            if (!Pstream::master())
             {
-                writePoints(uniquePoints.component(d), ensightGeometryFile);
-
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                for (direction d=0; d<vector::nComponents; d++)
                 {
-                    IPstream fromSlave(Pstream::scheduled, slave);
-                    scalarField pointsComponent(fromSlave);
-                    writePoints(pointsComponent, ensightGeometryFile);
+                    toMaster<< uniquePoints.component(d);
                 }
             }
-        }
-        else
-        {
-            for (direction d=0; d<vector::nComponents; d++)
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
             {
-                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                toMaster<< uniquePoints.component(d);
+                ensightGeometryFile
+                    << "part" << nl
+                    << setw(10) << 1 << nl
+                    << "internalMesh" << nl
+                    << "coordinates" << nl
+                    << setw(10) << nPoints
+                    << endl;
+
+
+                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
+                }
+
+                for (direction d=0; d<vector::nComponents; d++)
+                {
+                    writePoints(uniquePoints.component(d), ensightGeometryFile);
+
+                    for (int slave=1; slave<Pstream::nProcs(); slave++)
+                    {
+                        scalarField pointsComponent(fromSlaves[slave]);
+                        writePoints(pointsComponent, ensightGeometryFile);
+                    }
+                }
             }
         }
 
@@ -1352,7 +1453,6 @@ void Foam::ensightMesh::writeAscii
                     uniqueMeshPointLabels
                 );
 
-
                 pointField uniquePoints(mesh_.points(), uniqueMeshPointLabels);
                 // Renumber the patch faces
                 faceList patchFaces(p.localFaces());
@@ -1362,47 +1462,58 @@ void Foam::ensightMesh::writeAscii
                 }
 
 
-                if (Pstream::master())
                 {
-                    ensightGeometryFile
-                        << "part" << nl
-                        << setw(10) << ensightPatchI++ << nl
-                        << patchName << nl
-                        << "coordinates" << nl
-                        << setw(10) << globalPointsPtr().size()
-                        << endl;
+                    PstreamBuffers pBufs(Pstream::nonBlocking);
 
-                    for (direction d=0; d<vector::nComponents; d++)
+                    if (!Pstream::master())
                     {
-                        writePoints
-                        (
-                            uniquePoints.component(d),
-                            ensightGeometryFile
-                        );
-
-                        for (int slave=1; slave<Pstream::nProcs(); slave++)
+                        UOPstream toMaster(Pstream::masterNo(), pBufs);
+                        for (direction d=0; d<vector::nComponents; d++)
                         {
-                            IPstream fromSlave(Pstream::scheduled, slave);
-                            scalarField patchPointsComponent(fromSlave);
-
-                            writePoints
-                            (
-                                patchPointsComponent,
-                                ensightGeometryFile
-                            );
+                            toMaster<< uniquePoints.component(d);
                         }
                     }
-                }
-                else
-                {
-                    for (direction d=0; d<vector::nComponents; d++)
+
+                    pBufs.finishedSends();
+
+                    if (Pstream::master())
                     {
-                        OPstream toMaster
-                        (
-                            Pstream::scheduled,
-                            Pstream::masterNo()
-                        );
-                        toMaster<< uniquePoints.component(d);
+                        ensightGeometryFile
+                            << "part" << nl
+                            << setw(10) << ensightPatchI++ << nl
+                            << patchName << nl
+                            << "coordinates" << nl
+                            << setw(10) << globalPointsPtr().size()
+                            << endl;
+
+                        PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+                        for (int slave=1; slave<Pstream::nProcs(); slave++)
+                        {
+                            fromSlaves.set(slave, new UIPstream(slave, pBufs));
+                        }
+
+                        for (direction d=0; d<vector::nComponents; d++)
+                        {
+                            writePoints
+                            (
+                                uniquePoints.component(d),
+                                ensightGeometryFile
+                            );
+
+                            for (int slave=1; slave<Pstream::nProcs(); slave++)
+                            {
+                                scalarField patchPointsComponent
+                                (
+                                    fromSlaves[slave]
+                                );
+
+                                writePoints
+                                (
+                                    patchPointsComponent,
+                                    ensightGeometryFile
+                                );
+                            }
+                        }
                     }
                 }
 
@@ -1497,36 +1608,52 @@ void Foam::ensightMesh::writeBinary
     {
         label nPoints = globalPoints.size();
 
-        if (Pstream::master())
         {
-            writeEnsDataBinary("part",ensightGeometryFile);
-            writeEnsDataBinary(1,ensightGeometryFile);
-            writeEnsDataBinary("internalMesh",ensightGeometryFile);
-            writeEnsDataBinary("coordinates",ensightGeometryFile);
-            writeEnsDataBinary(nPoints,ensightGeometryFile);
+            PstreamBuffers pBufs(Pstream::nonBlocking);
 
-            for (direction d=0; d<vector::nComponents; d++)
+            if (!Pstream::master())
             {
-                writeEnsDataBinary
-                (
-                    uniquePoints.component(d),
-                    ensightGeometryFile
-                );
-
-                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                UOPstream toMaster(Pstream::masterNo(), pBufs);
+                for (direction d=0; d<vector::nComponents; d++)
                 {
-                    IPstream fromSlave(Pstream::scheduled, slave);
-                    scalarField pointsComponent(fromSlave);
-                    writeEnsDataBinary(pointsComponent, ensightGeometryFile);
+                    toMaster<< uniquePoints.component(d);
                 }
             }
-        }
-        else
-        {
-            for (direction d=0; d<vector::nComponents; d++)
+
+            pBufs.finishedSends();
+
+            if (Pstream::master())
             {
-                OPstream toMaster(Pstream::scheduled, Pstream::masterNo());
-                toMaster<< uniquePoints.component(d);
+                writeEnsDataBinary("part",ensightGeometryFile);
+                writeEnsDataBinary(1,ensightGeometryFile);
+                writeEnsDataBinary("internalMesh",ensightGeometryFile);
+                writeEnsDataBinary("coordinates",ensightGeometryFile);
+                writeEnsDataBinary(nPoints,ensightGeometryFile);
+
+                PtrList<UIPstream> fromSlaves(Pstream::nProcs());
+                for (int slave=1; slave<Pstream::nProcs(); slave++)
+                {
+                    fromSlaves.set(slave, new UIPstream(slave, pBufs));
+                }
+
+                for (direction d=0; d<vector::nComponents; d++)
+                {
+                    writeEnsDataBinary
+                    (
+                        uniquePoints.component(d),
+                        ensightGeometryFile
+                    );
+
+                    for (int slave=1; slave<Pstream::nProcs(); slave++)
+                    {
+                        scalarField pointsComponent(fromSlaves[slave]);
+                        writeEnsDataBinary
+                        (
+                            pointsComponent,
+                            ensightGeometryFile
+                        );
+                    }
+                }
             }
         }
 
@@ -1605,7 +1732,6 @@ void Foam::ensightMesh::writeBinary
                     pointToGlobal,
                     uniqueMeshPointLabels
                 );
-
                 pointField uniquePoints(mesh_.points(), uniqueMeshPointLabels);
                 // Renumber the patch faces
                 faceList patchFaces(p.localFaces());
@@ -1615,54 +1741,70 @@ void Foam::ensightMesh::writeBinary
                 }
 
 
-                if (Pstream::master())
                 {
-                    writeEnsDataBinary("part",ensightGeometryFile);
-                    writeEnsDataBinary(ensightPatchI++,ensightGeometryFile);
-                    //writeEnsDataBinary(patchName.c_str(),ensightGeometryFile);
-                    writeEnsDataBinary(patchName.c_str(),ensightGeometryFile);
-                    writeEnsDataBinary("coordinates",ensightGeometryFile);
-                    writeEnsDataBinary
-                    (
-                        globalPointsPtr().size(),
-                        ensightGeometryFile
-                    );
+                    PstreamBuffers pBufs(Pstream::nonBlocking);
 
-                    for (direction d=0; d<vector::nComponents; d++)
+                    if (!Pstream::master())
                     {
-                        //writePointsBinary
+                        UOPstream toMaster(Pstream::masterNo(), pBufs);
+                        for (direction d=0; d<vector::nComponents; d++)
+                        {
+                            toMaster<< uniquePoints.component(d);
+                        }
+                    }
+
+                    pBufs.finishedSends();
+
+                    if (Pstream::master())
+                    {
+                        writeEnsDataBinary("part",ensightGeometryFile);
+                        writeEnsDataBinary(ensightPatchI++,ensightGeometryFile);
+                        //writeEnsDataBinary
+                        //(patchName.c_str(),ensightGeometryFile);
+                        writeEnsDataBinary
+                        (   
+                            patchName.c_str(),
+                            ensightGeometryFile
+                        );
+                        writeEnsDataBinary("coordinates",ensightGeometryFile);
                         writeEnsDataBinary
                         (
-                            uniquePoints.component(d),
+                            globalPointsPtr().size(),
                             ensightGeometryFile
                         );
 
+                        PtrList<UIPstream> fromSlaves(Pstream::nProcs());
                         for (int slave=1; slave<Pstream::nProcs(); slave++)
                         {
-                            IPstream fromSlave(Pstream::scheduled, slave);
-                            scalarField patchPointsComponent(fromSlave);
+                            fromSlaves.set(slave, new UIPstream(slave, pBufs));
+                        }
 
+                        for (direction d=0; d<vector::nComponents; d++)
+                        {
                             //writePointsBinary
                             writeEnsDataBinary
                             (
-                                patchPointsComponent,
+                                uniquePoints.component(d),
                                 ensightGeometryFile
                             );
+
+                            for (int slave=1; slave<Pstream::nProcs(); slave++)
+                            {
+                                scalarField patchPointsComponent
+                                (
+                                    fromSlaves[slave]
+                                );
+
+                                //writePointsBinary
+                                writeEnsDataBinary
+                                (
+                                    patchPointsComponent,
+                                    ensightGeometryFile
+                                );
+                            }
                         }
                     }
                 }
-                else
-                {
-                    for (direction d=0; d<vector::nComponents; d++)
-                    {
-                        OPstream toMaster
-                        (
-                            Pstream::scheduled,
-                            Pstream::masterNo()
-                        );
-                        toMaster<< uniquePoints.component(d);
-                    }
-                }
 
                 writeAllFacePrimsBinary
                 (