Пример #1
0
 //Функция-нить исполнения
 //Принимает в виде аргумента контейнер с заданием, 
 //сортирует часть массива
 //Посылает сообщение в порт
 static void thread_fun(InputData d, Port<int> resp)
 {
     Stopwatch sWatch = new Stopwatch();
     sWatch.Start();
     qsort(d.array, d.start, d.stop);
     sWatch.Stop();
     Console.WriteLine(d.str+"Время работы: "+ sWatch.ElapsedMilliseconds);
     resp.Post(1);
 }
Пример #2
0
        static void task(InputData d, Port<int> resp)
        {
           
            d.result = PerformIntegral(d.start, d.stop, d.n);
            Console.WriteLine(d.str);
            Console.WriteLine("Начало: "+d.start+" конец: "+d.stop);
            Console.WriteLine("Результат на текущем шаге: " + d.result);
            mRes = mRes + d.result; //формируем общий результат

            resp.Post(1);
        }
Пример #3
0
            static void Main(string[] args)
        {
            int i;
            nc = 4;// количество ядер
            n = 100000000;

            Arr = new int[n];
            int Result = 0;

            Random r = new Random();
            for (int j = 0; j < n; j++)
                Arr[j] = r.Next(5);

            System.Diagnostics.Stopwatch sWatch = new System.Diagnostics.Stopwatch();
            sWatch.Start();
            for (i = 9; i < n; i++)//последовательный алгоритм
            {
                Result = Result + Arr[i];
            }

            Console.WriteLine("Сумма:");
            Console.WriteLine(Result);

            sWatch.Stop();
         
            Console.WriteLine("Последовательный алгоритм = {0} мс.", sWatch.ElapsedMilliseconds.ToString());


            InputData[] ClArr = new InputData[nc];// создание массива объектов для хранения параметров 
            for (i = 0; i < nc; i++)
                ClArr[i] = new InputData();

            int step = (Int32)(n / nc); // делим количество элементов  в массиве на nc частей 
            
            int c = -1;
            for (i = 0; i < nc; i++)// заполняем массив параметров 
            {
                ClArr[i].start = c + 1;
                ClArr[i].stop = c + step;
                ClArr[i].i = i;
                c = c + step;
            }
            Dispatcher d = new Dispatcher(nc, "Test Pool");
            DispatcherQueue dq = new DispatcherQueue("Test Queue", d);
            Port<int> p = new Port<int>();

            for (i = 0; i < nc; i++)
                Arbiter.Activate(dq, new Task<InputData, Port<int>>(ClArr[i], p, Sum));

            Arbiter.Activate(dq, Arbiter.MultipleItemReceive(true, p, nc, delegate(int[] array)
     {   }));}}}
Пример #4
0
        static void ParPerformInegral(double a, double b, double n)
        {
            double a1 = a;
            double b1 = b;
            
           

            InputData data1 = new InputData();
            InputData data2 = new InputData();

           
          
                data1.str = "Нить исполнения 1";

             
                data1.start = a;
                data1.stop = b/2+1;
                data1.n = n;


                //вместо performInegral(a,b/2+1,n);
           
           
                data2.str = "Нить исполнения 2";
                
                data2.start = b/2+1;
                data2.stop = b;
                data2.n = n;
                //вместо performInegral(b/2+1,b,n);
            

            //Создаём диспетчеры с пулом из 2 потоков
            Dispatcher d = new Dispatcher(2, " Test Pool");
            DispatcherQueue dq = new DispatcherQueue(" Test Queue", d);

            //Описываем (определяем) порт, в который каждый экземпляр метода отправляет сообщение после завершения вычислений
            Port<int> p = new Port<int>();

            //Метод Arbiter.Activate помещает в очередь диспетчера две задачи (два экземпляра метода)
            //Первый параметр метода Arbiter.Activate – очередь диспетчера,
            //который будет управлять выполнением задачи, второй параметр – запускаемая задача.
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data1, p, task));
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data2, p, task));

            return;
        }
Пример #5
0
        static void Sum(InputData data, Port<int> resp) //параллельный алгоритм
        {
            int Result = 0;
            int i = 0;
            System.Diagnostics.Stopwatch sWatch = new System.Diagnostics.Stopwatch();//для отсчитывания времени
            Random r = new Random();
            for (int j = 0; j < n; j++)
                Arr[j] = r.Next(5);
            sWatch.Start();
            
                for (i = data.start; i <= data.stop; i++)
                {
                    Result = Result + Arr[i]; //сумма массива
                }
        
             resp.Post(1);//результат отпраляется на порт

            Console.WriteLine("Поток № {0}: Параллельный алгоритм = {1} мс.", Thread.CurrentThread.ManagedThreadId, sWatch.ElapsedMilliseconds.ToString());
            sWatch.Stop();
            Console.WriteLine("Сумма:");
            Console.WriteLine(Result);
        }
Пример #6
0
        static void paral_qsort(int[] a, int left, int right)
        {
            int l = left;
            int r = right;
            int val = 0;
            int mid = a[(l + r) / 2];

            while (l <= r)
            {
                while ((a[l] < mid) && (l <= right))
                {
                    l++;
                }
                while ((a[r] > mid) && (r >= left))
                {
                    r--;
                }

                if (l <= r)
                {
                    val = a[l];
                    a[l] = a[r];
                    a[r] = val;
                    l++;
                    r--;
                }
            }

            InputData data1 = new InputData();
            InputData data2 = new InputData();

            if (r > left)
            {
                data1.str="Нить исполнения 1";
                data1.array = a; data1.start = left; data1.stop = r;
                //qsort(a, left, r);
            }
            if (l < right)
            {
                data2.str = "Нить исполнения 2";
                data2.array = a; data2.start = l; data2.stop = right;
                //qsort(a, l, right);
            }

            //Создаём диспетчеры
            Dispatcher d = new Dispatcher(2, " Test Pool");
            DispatcherQueue dq = new DispatcherQueue(" Test Queue", d);

            //Описываем порт
            Port<int> p = new Port<int>();

            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data1, p, thread_fun));
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data2, p, thread_fun));

            return;
        }
Пример #7
0
 //Функция-нить исполнения
 //Принимает в виде аргумента контейнер с заданием, 
 //сортирует часть массива
 //Посылает сообщение в порт
 static void thread_fun(InputData d, Port<int> resp)
 {
     qsort(d.array, d.start, d.stop);
     Console.WriteLine(d.str);
     resp.Post(1);
 }
Пример #8
0
        //Метод параллельной сортировки массива
        static void parral_qsort(int[] a, int left, int right)
        {
            //Создаём диспетчеры
            Dispatcher d = new Dispatcher(2, " Test Pool");
            DispatcherQueue dq = new DispatcherQueue(" Test Queue", d);

            //Описываем порт
            Port<int> p = new Port<int>();

            //Первый этап параллельной сортировки
            //Параллельно сортируются две половины массива
            InputData data = new InputData();
            data.str = "Первая половина массива ";
            data.array = a; data.start = 0; data.stop = right/2 + 1;
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
            Console.WriteLine("Первый этап");
            Console.ReadKey();
            data.str = "Вторая половина массива ";
            data.array = a; data.start = right/2 + 1; data.stop = right;
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
            Console.ReadKey();

            //Второй этап параллельной сортировки
            //Сортируется центральная часть массива
            Console.WriteLine();
            Console.WriteLine("Второй этап");
            Stopwatch sWatch = new Stopwatch();
            sWatch.Start();
            qsort(a,right/4,right/4+right/2 +1);
            sWatch.Stop();
            Console.WriteLine("Средняя часть массива   Время работы: " + sWatch.ElapsedMilliseconds);
            Console.ReadKey();

            //Третий этап параллельной сортировки
            //Параллельно сортируются две половины массива
            data.str = "Первая половина массива ";
            data.array = a; data.start = 0; data.stop = right / 2 + 1;
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
            Console.WriteLine("Первый этап");
            Console.ReadKey();
            data.str = "Вторая половина массива ";
            data.array = a; data.start = right / 2 + 1; data.stop = right;
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data, p, thread_fun));
            Console.ReadKey();
            return;
        }
Пример #9
0
        //параллельная сортирока с нитями исполнения
        static void paral_qsort(int[] arr_q, int left, int right)
        {
            int l = left;
            int r = right;
            int temp = 0;
            int middle = arr_q[(l + r) / 2];

            while (l <= r)
            {
                while ((arr_q[l] < middle) && (l <= right))
                {
                    l++;
                }
                while ((arr_q[r] > middle) && (r >= left))
                {
                    r--;
                }

                if (l <= r)
                {
                    temp = arr_q[l];
                    arr_q[l] = arr_q[r];
                    arr_q[r] = temp;
                    l++;
                    r--;
                }
            }

            InputData data1 = new InputData();
            InputData data2 = new InputData();

            if (r > left)
            {
                data1.str="Нить исполнения 1";

                data1.array = arr_q;
                data1.start = left;
                data1.stop = r;
                //вместо qsort(arr_q, left, r);
            }
            if (l < right)
            {
                data2.str = "Нить исполнения 2";

                data2.array = arr_q;
                data2.start = l;
                data2.stop = right;
                //вместо qsort(arr_q, l, right);
            }

            //Создаём диспетчеры с пулом из 2 потоков
            Dispatcher d = new Dispatcher(2, " Test Pool");
            DispatcherQueue dq = new DispatcherQueue(" Test Queue", d);

            //Описываем (определяем) порт, в который каждый экземпляр метода отправляет сообщение после завершения вычислений
            Port<int> p = new Port<int>();

            //Метод Arbiter.Activate помещает в очередь диспетчера две задачи (два экземпляра метода)
            //Первый параметр метода Arbiter.Activate – очередь диспетчера,
            //который будет управлять выполнением задачи, второй параметр – запускаемая задача.
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data1, p, thread_fun));
            Arbiter.Activate(dq, new Task<InputData, Port<int>>(data2, p, thread_fun));

            return;
        }