In many cases, a parallel application has the form of many communicating processes, where each each process is essentially a loop iterating on separate core of the multi core processor. Usually the times required for the loop iterations are quite predictable and such a system of communicating loops has a tendency to synchronize all loop-iterations rates to the slowest component.

Consider the following example of two concurrent communicating loops:

// On processor 1 for \(i=0\) to \(N\) do send(\(2\),\(A[i][0\ldots 1024])\) receive(\(2\), buffer)

// On processor 2 for \(i=0\) to \(N\) do send(\(1\),\(B[i][0\ldots 256])\) receive(\(1\), buffer)

The processes communicate using non-blocking 'send' and blocking 'receive' operations. The amounts of data sent from process 1 to process 2 are much larger than the amounts of data sent in the opposite direction. Consequently, the process 2 can send its data more slowly, without any performance penalty.

Consider the another example:

// On processor 1 for \(i=0\) to \(N\) do send(\(2\),\(A[i][0\ldots 256]) \) short computation(...) receive(\(2\), buffer)

// On processor 2 for \(i=0\) to \(N\) do send(\(1\),\(B[i][0\ldots 256])\) long computation(...) receive(\(1\), buffer)

Here, the time interval between the consecutive 'receive' operations of process 2 must be long because of long computations in each iteration. Thus, the bit-rate transmission from process 1 to process 2 can be lowered without performance penalty.