Архитектура параллельных вычислений

   for(int i = 0; i<a.Length&& a[i]!=0; i++) sb.Append(a[i]+" ");

   Console.WriteLine(sb.ToString());

   }

   }

Public class CSieve

{

// Функция, реализующая стандартный  алгоритм "Решето //Эратосфена"

Private int[] SynchronousSieve(int[] ar)

    {

if (ar == null || ar.Length == 0) return new int [ 0 ];

int[] primes = (int[]) Array.CreateInstance(typeof(int), Config.MAX_LEN);

int ind = 0;

primes[0] = ar[0];

for(int i = 1; i <ar.Length; i++)

        {

if(isPrime(ar[i],primes)) primes[++ind] = ar[i];

}

Return primes;

    }

// Функция,проверяющаячислонапростоту

Private bool isPrime(int n, int[]primes)

    {

Bool isPrime = true;

for(int j = 0; isPrime&& j <primes.Length&&                    primes[j]!=0 && primes[j]*primes[j] <= n; j++)

isPrime = (n % primes[j] != 0);

return isPrime;

    }

Async Sieve(handlerint[]() getNatPack, channel (int[]) sendPrimesPack)

{

// Получаем первый пакет из входного  потока и

        // извлекаем из него подпакет  простых чисел

int[] head = SynchronousSieve((int[])getNatPack());

// Посылаем пакет простых чисел  в выходной поток

sendPrimesPack(head );

// Фильтруем оставшиеся пакеты  входного потока

        // относительно пакета head

if ( head.Length != 0 )

{

New CSieve().Sieve( inter,sendPrimesPack);

filter ( head, getNatPack, cout );

        }

    }

Handler inter int[]()  &channel cout ( int[] p) {

return ( x );

    }

// Фильтрацияпотоков

void filter(int[] head, handler int[] () getNatPack, channel (int[]) cfiltered)

    {

int[] al =   (int[])Array.CreateInstance(typeof(int),Config.MAX_LEN);

int ind = 0;

// Для каждого пакета из входного  потока

for( int[] p; (p = (int[])getNatPack() ).Length != 0;)

        {

// Выбираем простые числа, формируя  новый пакет

for(int i = 0; i <p.Length&& p[i]!=0; i++)

            {

if(isPrime(p[i],head))

{

al[ind++] = p[i]; 

// Если пакет заполнен, то посылаем  его

                    // в поток отфильтрованных пакетов

if(ind == Config.MAX_LEN)

{

ind = 0;

cfiltered (al);

al = (int[])Array.CreateInstance(typeof(int),Config.MAX_LEN);

}

                }

            }

        }

// Посылаем последний пакет в  поток

        // отфильтрованных пакетов

if(al[0] != 0) cfiltered (al);

// Посылаем маркер конца потока  пакетов      

cfiltered(new int [ 0 ] );

    }

Class Eratosthenes2   {

public static void Main(String[] args) {

   Eratosthenes2 er2 = new Eratosthenes2();

CSievecsieve = new CSieve();

// Запускаемметод Sieve

csieve.Sieve( er2.getNatPack, er2.sendPrimePack);

int[] al =   (int[])Array.CreateInstance(typeof(int),Config.MAX_LEN);

// Создаем поток пакетов натуральных  чисел

for (inti = 2; i<= Config.N; i++)

{

intind = (i-2)%Config.MAX_LEN;

al[ind] = i;

if(ind == Config.MAX_LEN - 1)

            {

                er2.Nats ( al );

al = (int[])Array.CreateInstance(typeof(int),Config.MAX_LEN);

            }

        }

if(al[0] != 0)

er2.Nats(al);

        er2.Nats ( newint [ 0 ] );

int[] p;

// Распечатываем результирующие пакеты  простых чисел

while (( p = (int[])er2.getPrimePack()).Length != 0)

Config.print(p);

}

Handler getNatPackint[]()  &channel Nats ( int[]p ) {             

return( p );

}

Handler getPrimePackint[]() &channel sendPrimePack( int[]p ) {     

return( p );

 }

} 

3.5.4 Обход бинарного дерева

   Если  структура данных задачи организована в виде дерева, то его обработку  легко распараллелить путем обработки  каждого поддерева отдельном async- (movable-) методом.

         Предположим, что  мы имеем следующее определение  бинарного дерева в виде класса BinTree. Тогда просуммировать значения, находящиеся в узлах такого дерева (и, в общем случае, произвести более сложную обработку) можно с помощью следующей программы, структура которой, по существу, совпадает со структурой предыдущей программы Fib.  

Class BinTree {

   Public BinTree left;

   Public BinTree right;

   Public int value; 

   public BinTree( int depth ) {

   value = 1;

   if ( depth <= 1 ) {

   left = null;

   right = null;

       }

   else {

   left = new BinTree( depth – 1 );

   right = new BinTree( depth – 1 );

       }

     }

}

public class SumBinTree {

   public static void Main( String[] args ) {

   int depth = System.Convert.ToInt32( args [0] );

   SumBinTreesbt = new SumBinTree();

   BinTreebtree = newBinTree( depth );

   sbt.Sum(btree, sbt.c );

   Console.WriteLine( “Sum = “ + sbt.Get() );

   }

     // Определениеканалаиобработчика

   handler Get int() &channel c( int x )

     {

   return ( x );

     }

   // Определениеasync-метода

   Public async Sum( BinTreebtree, channel (int) c ) {

   if ( btree.left == null )  // Деревоестьлист