Инструмент многопоточного программирования

// Пример выполняется на демонстрационном стенде, по той или иной кнопке. Этот пример 
// совпал с кнопкой Button3, значит здесь его пусковой механизм.
//Прежде всего нужно инициализировать главный класс библиотеки, т.е. запустить 
//исполнительную среду на выполнение
//MyCoreParallel=new  CoreParallel (MyWindow,0);
//Параметры конструктора:  MyWindow – любое окно приложения, закрытие которого остановит 
//все потоки. Следующий параметр – предполагаемое использование юнитов в программе, 
//параметр не очень важный, можно поставить 0, библиотека сама разберется.
 
 
public void Button3(object sender, EventArgs e)  
        { 
// юниты выполняют пользовательские  методы. Эти методы определим в любом классе, здесь 
//класс  KunstTable. Т.е этот класс просто амбар, где хранятся методы для юнитов. Создаем 
//экземпляр этого “амбара”. 
 
          KunstTable   kunstTable = new  KunstTable()
 
//  В амбаре есть два метода 
//public object exampleKunstTable(object arg, int myUnit)  
//public object FunctionViewMail(object param,int myUnit)
//Сигнатура методов определенная, первый аргумент – сжатая до типа объект 
//последовательность реальных аргументов. В самом методе этот аргумент следует разжать до 
//естественного вида. Например реально надо передать 2 аргумента int X, float[] F.
//object[] a = new object [2];  a[0]= (object) X; a[1]= (object)F;   object  arg = (object)a;
//Сжали до одного аргумента. В самом методе разжимаем.
//object[] a = new object [2];  a= (object[])arg;  int arg1= (int)a[0];  float[] arg2 = (float[])a[1];
//Второй целочисленный аргумент в методах  int myUnit, просто формальный параметр, его не 
//надо передавать, через него исполнительная среда подставит в метод номер юнита на котором 
//будет выполняться этот метод, в дальнейшем этот номер потребуется. Методы с такой 
//сигнатурой подпадают под стандартный тип  Func<object,int,object>. Дадим этим методам 
//мнемонические имена f2 и  f1.
           Func<object,int,object> f2  =  kunstTable.FunctionViewMail;
           Func<object,int,object> f1  = kunstTable.exampleKunstTable ;
 
//Юниты выполняются только в связке, т.е  должно быть не менее двух юнитов, поэтому 
//формально вводим юнит сервер, который ничего не делает, так все будет делать юнит – клиент.
         id11=  MyCoreParallel. CreateUnitAsServer(null,null,null, null, null,null);
//  А вот юнит – клиент как раз выполняет два метода, вначале f1, затем f2. Метод f1 –
//инициализирует графическую форму, если она не инициализирована. Далее работает метод f2 –
//он в эту форму вносит данные. Управление передается юниту серверу, который как мы помним 
//ничего не делает, т.е его работа пропускается. Управление снова передается методу f1, но 
//форма уже им инициализирована, так что метод пропускается. Реально работает метод f2, 
//выводт данные в форму.
       id12 = MyCoreParallel. CreateUnitAsClient(f1, null,f2,null, null,null);
//Здесь юниты связываются логически.
          MyCoreParallel.BindingUnitToUnit(id11, id12); 
//Запуск в работу связки юнитов.
          CoreParallel.StartAllUnits();         
 
        }

using System;
using System.Windows;
using System.Threading;
using BindingAndServiceParallel;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Media;
using System.Globalization;
namespace Primer1
{
    
    
    public  class ProgramSort : Application
{ public static CoreParallel myCoreParallel;
  public static    Ambar ambar;
  public static    int unit1, unit2;
  public static    ProgramSort programSort;   
  public static    TextBox textBox = new TextBox();   
  public static    int[] unSortedArray;
  public static    int[] sortedArray;
  public static    TableView  tableView1;
  public static    int processRun=0;      // признак запуска процесса
  public static    int processSorting;    // признак того что происходит процесс сортировки;
  public static    TextEditorCoreParallel textEditorCoreParallel;
  public static    TableView  tableView2;
  public static    int  unitManager;    
  public static    int countArray;         //   размер массива 
        
        [STAThread]
  public static void Main()
     {    programSort = new ProgramSort(); 
          programSort.Startup += ProgramStartup;
          programSort.Run();
 
     }
 
    static void ProgramStartup(object sender, StartupEventArgs e)
    { 
        myCoreParallel = new  CoreParallel(null,2000);     
        ambar = new Ambar();
        Func<object,int,object> f1  = ambar.unit1_F1; 
        Func<object,int,object> f2  = ambar.unit1_F2;   
         unit1=  myCoreParallel. CreateUnitAsServerDirectCore(f1,null,f2, null, null,null,0);
         unit2 = myCoreParallel. CreateUnitAsClientDirectCore(null, null,null,null, null,null,0);  
         myCoreParallel.BindingUnitToUnit(unit1, unit2);
         CoreParallel.StartAllUnits();       
    }
 
//...................................................................................................  
    
    
    
    
    }// class ProgrammSort
 
    public class Ambar
    {   public   TableBase  tableBase = null; // экземпляр экранной формы, инициализированный как null
//.....................................................................................................
        public object unit1_F1(object arg,int myUnit)  
     {  // метод должен открыть экранную форму. Необходимо сформировать письмо и прикркпить к нему метод открытия формы.
       if(tableBase!=null){ Thread.Sleep(1000); return  null;} // если форма уже открыта, пропускем выполнение метода
       CoreParallel.UserFormMail[] ufmArray = new CoreParallel.UserFormMail[1];  // создаем массив содержащий переменные типа UserFormMail
       CoreParallel.UserFormMail ufm  = new CoreParallel.UserFormMail();  // определяем переменную типа UserFormMail
       ufm.FromUnit=myUnit; // адрес отправителя
       ufm.ToUnit=0;        // адрес получателя письма
       ufm.FuncArgument=(object)myUnit; // формально, прикрепленный к письму метод должен содержать входной аргумент типа object,
                                        // просто соблюдение сигнатуры метода
       ufm.Func=   openForm; // прикрепили метод, выполняемый в основном потоке
       ufm.Metka= CoreParallel.GetNewMetka();  // признак того, что требуется  ответное письмо от юнита 0
       ufmArray[0]=ufm; // заполнили массив писем, применяется пакетный способ рассылки писем как наиболее быстрый
       CoreParallel.units[myUnit].unitMailSender. SetAndSendUserDataMailArray(ufmArray,0); // отправили массив писем в адрес юнита 0.
    
       CoreParallel.IdentificationMail returnMail =  null;  // создадим ссылку на письмо и инициализируем ее как null
  
           while(returnMail == null ) // выполнять чтение почтового ящика вплоть до поступления письма с меткой ufm.Metka
       {// ProgramSort.myCoreParallel.WaitMail(myUnit); // встали в ожидании ответного письма от юнита 0.  
           Thread.Sleep(1);
           returnMail =  CoreParallel.units[myUnit].unitMailSender.GetMailFromMetka (myUnit  ,ufm.Metka);  
       }
   // пришло ответное письмо, где в поле ReturnFromMetod находится ссылка на элемент RichTextBox, расположенный в главной форме 
 
        
          return returnMail.ReturnFromMetod ; // возвратили ссылку на элемент RichTextBox
     } //  public object unit1_F1(object arg,int myUnit) 
        
//...................................................................................................
 
     public  object openForm(object arg)
     {   
         if(tableBase!=null) return null; // дублируем проверку  метода unit1_F1, т.к. письмо доходит с задержкой, за это время метод
                                          // может выполниться дважды.       
         tableBase = new TableBase();     // открываем экранную форму
 //        tableBase.ShowGridLineOn();      // для отладки делаем видимыми линии сетки
// выведем  на форму название программы
        
         string strTextBlock1= "Многопоточная сортировка массива"; // текст заголовка
         string fontFamily="Verdana"; // шрифт
         int fontSize=27;   // размер шрифта
 // определим высоту и ширину текста        
         FormattedText F_strTextBlock1 = new FormattedText(strTextBlock1,  CultureInfo.GetCultureInfo("en-us"),  FlowDirection.LeftToRight,
         new Typeface(fontFamily), fontSize ,  Brushes.Black);
         TextBlock textBlock1 = new TextBlock();  // элемент отображения текста и ниже его настройки
         textBlock1.FontFamily              = new FontFamily(fontFamily);
         textBlock1.FontSize                = fontSize;
         textBlock1.Text=strTextBlock1;        
//добавлем строку к сетке высотой (int)F_strTextBlock1.Height*2 пикселей. Узел == 0, т.е это сама экранная форма    
         int usel0Row0 =   tableBase.   AddRowToUsel(0,(int)F_strTextBlock1.Height*2); 
         tableBase. AddColumnToRowFromUsel(0, 0,-1);  // добавляем колонку в строке 0 произвольной длины( параметр длины  = -1 ) 
// чтобы текст располагался по центру формы, добавим фиктивную колонку шириной равной ширине текста  
         tableBase. AddColumnToRowFromUsel(0, 0,(int)F_strTextBlock1.Width);      
         int uselFromTextBlock1 = tableBase. CreateUselFromObject((object)textBlock1);  // создадим содержащий узел и поместим в него элемент с надписью
         tableBase.SetHorizontalAlignment ((int) HorizontalAlignment.Center, uselFromTextBlock1); // для этого узла укажем выравнивание по центру
         tableBase.BindingCellToUsel(0,0, usel0Row0, uselFromTextBlock1); // поместим узел с надписью в ячейку [0,0] узла 0, т.е. верхней формы.
       
          int usel0Row1 = tableBase.AddRowToUsel(0,300);  // добаввим к осовной форме строку высотой 300 пикселей
  
          tableBase. AddColumnToRowFromUsel(0, usel0Row1,300); // добавим к этой строке 4 колонки
          tableBase. AddColumnToRowFromUsel(0, usel0Row1,20); // колонка  разделитель
          tableBase. AddColumnToRowFromUsel(0, usel0Row1,-1); // колонка для таблицы неопределенной длины ( -1)
          tableBase. AddColumnToRowFromUsel(0, usel0Row1,-1);
  
       
         ProgramSort. textEditorCoreParallel = new TextEditorCoreParallel(); // создадим элемент типа RichTextBox
         int uselFromTextEditor  = tableBase. CreateUselFromObject((object) ProgramSort.textEditorCoreParallel ); // разместим элемент в узле
         tableBase.BindingCellToUsel(0,0,usel0Row1 , uselFromTextEditor); // свяжем этот узел с ячейкой [0,1] главной формы
         
         
         ProgramSort. tableView1 = new TableView(); ProgramSort. tableView1.AddColumn("Исходный массив");// создадим элемент Таблица и определим колонку
         int uselFromtableView1   = tableBase. CreateUselFromObject((object)ProgramSort. tableView1 );  // разместим элемент в узле
         tableBase.BindingCellToUsel(0,2, usel0Row1, uselFromtableView1 );   // свяжем этот узел с ячейкой [2,1] главной формы
         
      
         
         ProgramSort.  tableView2 = new TableView(); ProgramSort.tableView2.AddColumn("Отсортированный массив"); // создадим элемент Таблица и определим колонку
         int uselFromtableView2   = tableBase. CreateUselFromObject((object)ProgramSort.tableView2 ); // разместим элемент в узле
         tableBase.BindingCellToUsel(0,3, usel0Row1, uselFromtableView2 ); // свяжем этот узел с ячейкой [3,1] главной формы
         tableBase.AddRowToUsel(0,20);
       
  // добавим снопку Монитор 
         int usel0Row3 = tableBase.AddRowToUsel(0,100);
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,90 );
         Button monitor = new Button();    
         monitor   .Click += new  RoutedEventHandler (monitorEvent);
         monitor.Content="Монитор"; monitor.Height=20;  monitor.Width=70;
         int uselFromMonitor   = tableBase. CreateUselFromUIelement(monitor ); // разместим элемент в узле
         tableBase.BindingCellToUsel(0,0, usel0Row3, uselFromMonitor);
 // добавим поле ввода количества элементов сортировки. Элемент определен в глобальной области видимости переменных.  
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,20 );
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,90 );
 //        TextBox textBox = new TextBox();
        ProgramSort. textBox.Height=20; ProgramSort. textBox.Width=70;
        ProgramSort. textBox.Text="10";
         int uselFromTextBox   = tableBase. CreateUselFromUIelement(ProgramSort. textBox );
         tableBase.BindingCellToUsel(0,2, usel0Row3,uselFromTextBox );
  // добавим кнопку Старт       
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,20 );
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,90 );
         Button start = new Button();    
         start   .Click += new  RoutedEventHandler (startEvent);
         start.Content="Старт"; start.Height=20;  start.Width=70;
         int uselFromStart   = tableBase. CreateUselFromUIelement(start ); // разместим элемент в узле
         tableBase.BindingCellToUsel(0,4, usel0Row3, uselFromStart);
         
   // добавим кнопку Выход       
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,20 );
         tableBase. AddColumnToRowFromUsel(0, usel0Row3,90 );
         Button exit = new Button();    
         exit   .Click += new  RoutedEventHandler (exitEvent);
         exit.Content="Выход"; exit.Height=20;  exit.Width=70;
         int uselFromExit   = tableBase. CreateUselFromUIelement(exit ); // разместим элемент в узле
         tableBase.BindingCellToUsel(0,6, usel0Row3, uselFromExit);      
         
         
         tableBase.MakeTable();           // рисуем форму непосредственно
         return (object) ProgramSort.textEditorCoreParallel ; // возвращаем ссылку на элемент RichTextBox для дальнейшего применения
     
     } //  public object openForm(object arg)

//.............................................................................................................
 
          public object unit1_F2(object arg,int myUnit)  // стандартная сигнатура методов юнита
 
          { // метод выполняется после метода F1, выполняет диалог с пользователем
            // прочитаем значение, возвращаемое методом F1 
            // с помощью поткобезопасного варианта метода public   object   GetReturnToServer  (int unit,   int numberMetod) 
          
            int unit = myUnit;   // метод F2 исполняется тем же юнитом что и метод F1, поэтому myUnit у них одинаков
            int numberMetod=1;   // поскольку читаем значение метода F1, то параметр равен 1
              
           // поткобезопасный вариант принимает один аргумент типа object, запакуем входную последовательнсть аргументов
              
            object[] argument= new  object[2];
            argument[0]=(object)unit;
            argument[1]=(object)numberMetod;
            object input =(object)argument;
            
            Func<object,object> func =  ProgramSort.myCoreParallel.GetReturnToServerThread; // потокобезопасный вариант получения значения метода юнита
            TextEditorCoreParallel textEditorCoreParallel=null;
 error:     try  {      
             object ob= new object();
               
              ob=     CoreParallel.units[unit].unitRunMetod.RunMetodSync(func, input); // передаем метод и его аргумент  
             textEditorCoreParallel =  (  TextEditorCoreParallel) ob;
              
              
                     }
             catch(Exception e1)    {string  str=e1.ToString(); goto error; }
                        
              
  //   переменная   textEditorCoreParallel содержит ссылку на элемент RichTextBox, открытый в главной форме.
  // подготовим письмо и отошлем в адрес юнита 0 с методом заполнения формы addTextToRichTextBox(object arg) 
    
          CoreParallel.UserFormMail[] ufmArray = new CoreParallel.UserFormMail[1];  // создаем массив содержащий переменные типа UserFormMail
          CoreParallel.UserFormMail ufm  = new CoreParallel.UserFormMail();  // определяем переменную типа UserFormMail
          ufm.FromUnit=myUnit; // адрес отправителя
          ufm.ToUnit=0;        // адрес получателя письма
      
         
  // пакуем  аргументы 
          string text = "Будьте внимательны, программа может вывести\nпроцессор на близкую к максимальной\n"+
              "загрузку. Убедитесь в надежности системы охлаждения\n\n1. Введите количество элементов сортировки \n" + 
              "    в диапазоне от 1 до 10.000.000\n\n2. Нажмите кнопку Старт "; 
          object[] array = new  object[2]; array[0]= (object)text; array[1]= (object) textEditorCoreParallel; object arg1 =(object)array;
          ufm.FuncArgument = arg1; 
          ufm.Func=   addTextToRichTextBox; // прикрепили метод, выполняемый в основном потоке
          ufm.Metka= 0;  // признак того, что не требуется  ответное письмо от юнита 0
          ufmArray[0]=ufm; // заполнили массив писем, применяется пакетный способ рассылки писем как наиболее быстрый
          CoreParallel.units[myUnit].unitMailSender. SetAndSendUserDataMailArray(ufmArray,0); // отправили массив писем в адрес юнита 0. 
 
          while(ProgramSort.processRun==0) Thread.Sleep(1);  // ожидаем ввода данных
     
              int countArray= ProgramSort.countArray; 
              int core = ProgramSort.myCoreParallel.GetCountCore()-3;
    
  // сформируем независимый альянс юнитов выполняющих сортировку
            Sorting sorting = new Sorting();  // открыли класс обеспечивающий сортировку
            Func<object,int,object> f1  = sorting.managerSortingF1; // 
            Func<object,int,object> f2  = sorting.managerSortingF2; //
            Func<object,int,object> f3  = sorting.managerSortingF3; //
            ProgramSort.   unitManager=   ProgramSort.  myCoreParallel. CreateUnitAsServerDirectCore(f1,null,f2, null, f3,null,0);
    
 // Следующая команда позволяет задать скорость выполнения методов юнита, условно, в диапазоне 0-10000 (speedMax)
 // таким образом можно динамически регулировать скоростью исполнения отдельных частей кода
 // если процессор перегревается, присвойте значение 0 или 1             
              
              CoreParallel.units[ProgramSort.   unitManager].SpeedServer= CoreParallel.speedMax;
          
      
    // ВНИМАНИЕ! Важно 
//для следуещего цикла определим его переменные вне цикла. Это крайне рекомендуемое условие
// если в цикле есть потокобезопасное  обращение к методу, локальные переменные определяются вне цикла
// особенно осторожно относитесь к этому при асинхронных вызовах метода. Дело в том, что исполнение метода произойдет не мгновенно
// а переход к следующему оператору - сразу же по вызову метода. Когда произойдет реальное исполнение метода, программа может выйти
// из цикла. Все объявленные в цикле переменные потеряют область видимости и могут быть уничтожены сборщиком мусора. Когда реално произойдет
// выполнение метода, окажется что входной аргумент уже не существует. Если не уверены, что асинхронный  метод закончится в течении времени
// существования основного метода (т.е. метода в котором он был вызван), определите локальные переменные в глобальной области видимости 
// всей программы. В этом случае не допускайте использование этих переменных другими методами, только точечное использование.
      
              int[] parallelUnit = new  int[core];
 
              argument = new object[7];
     
               object arg2;
   
 // создадим рабочие юниты сортировки
      for(int i=0;i < core ; i++)
            { 
                argument[0]= null;  argument[1]= null; argument[2]=  null; argument[3]= null; argument[4]=  null;
                argument[5]=  null; argument[6]= (object)(1+i); 
                arg = (object)argument;
               
 error3:     try{                   
             
                parallelUnit[i]= (int)  CoreParallel.units[myUnit].unitRunMetod.RunMetodSync
                       (ProgramSort.myCoreParallel. CreateUnitAsClientDirectCoreThread, arg);           
                   }      
         catch(Exception e1)    {string  str=e1.ToString(); goto error3;}
 // Следующая команда позволяет задать скорость выполнения методов юнита, условно, в диапазоне 0-10000 (speedMax)
 // таким образом можно динамически регулировать скоростью исполнения отдельных частей кода
 // если процессор перегревается, присвойте значение 0 или 1          
          CoreParallel.units[parallelUnit[i]].SpeedClient= CoreParallel.speedMax;  
          ProgramSort.myCoreParallel.BindingUnitToUnit(ProgramSort.   unitManager,  parallelUnit[i]);  // свяжем рабочий юнит с менеджером          
         
      }   
 
      // упакуем аргументы для метода  managerSortingF1 юнит-сервера unitManager
     
      object[] argument1 = new  object[10];
      argument1[0]= (object) ProgramSort.unSortedArray; // исходный массив
      argument1[1]= (object) ProgramSort.sortedArray;   // отсортированный массив
      argument1[2] =(object) parallelUnit;   // список номеров серверов клиентов
      argument1[3]= (object)core; // количество ядер
  
      arg1 = (object)argument1;
  // сигнатура метода      int   SetArgumentToServer  (int unit,   int numMetod,   object Argument)  
  // требует первым аргументом - номер юнита, второй аргумент - номер метода, третий аргумент -  собственно сам аргумент метода юнита    
      object[] argument2 = new  object[3];
      argument2 [0]= (object) ProgramSort.unitManager; // номер юнита
      argument2 [1]= (object) 1;  // номер метода
      argument2 [2]= arg1;   // аргумент метода юнита
      arg2= (object)argument2;
 
      // установим для медода F1 юнита менеджера входные аргументы в потокобезопасном режиме
    
       CoreParallel.units[myUnit].musor.Add(new System.Collections.Generic.List<object>());  // сохраним входные аргументы
       int index=  CoreParallel.units[myUnit].musor.Count-1;
       CoreParallel.units[myUnit].musor[index].Add(arg2);
 
 error1:  try{
      CoreParallel.units[myUnit].unitRunMetod.RunMetodSyncSafe
                                           (ProgramSort.myCoreParallel.SetArgumentToServerThread , arg2, index);
     }
      catch(Exception e1)    {string  str=e1.ToString(); goto error1;}
 
      CoreParallel.StartAllUnits();  // запускаем юниты сортировки
   
 
          return null;
          }
//.............................................................................................................
  public void monitorEvent (object sender, EventArgs e){ ProgramSort.   myCoreParallel.RunMonitor(2);}
//.............................................................................................................
 
  public void exitEvent (object sender, EventArgs e){ CoreParallel.AbortAllUnits(); Application.Current.Shutdown();}
           
//.............................................................................................................
  public void startEvent(object sender, EventArgs e)
       {
 //  введем данные и очистим таблицы вывода
 
      if( ProgramSort.   processRun!=0) return;
     
   
      try{
            ProgramSort.   countArray = Int32.Parse(  ProgramSort.textBox.Text);
            }
         catch(Exception e1)    {string  str=e1.ToString();  return;}
         if(ProgramSort. countArray <1 || ProgramSort. countArray > 10000000)return;
         ProgramSort.unSortedArray = new int[ProgramSort. countArray];
         ProgramSort.sortedArray = new int[ProgramSort. countArray];
         Random random = new Random();
         ProgramSort. tableView1.ClearTable();
         ProgramSort. tableView2.ClearTable();
         for(int i=0; i< ProgramSort. countArray; i++){
             ProgramSort.unSortedArray[i]= random. Next ();
             ProgramSort.tableView1.AddRecord( ProgramSort.unSortedArray[i]);
         }      
     
      ProgramSort.   processRun=1;
      return;
 
       }
  
//.............................................................................................................
 
 public object addTextToRichTextBox(object arg)
 { // распакуем входной аргумент
            object[] array = (object[])arg;
            string text =(string)array[0]; 
            TextEditorCoreParallel textEditorCoreParallel = (TextEditorCoreParallel) array[1];      
    
            Paragraph myParagraph = new Paragraph(new Run(text));
            textEditorCoreParallel.flowDocument.Blocks.Add(myParagraph ); 
  
     return null;
 }
 
 public object addProgressToRichTextBox(object arg)
 { // распакуем входной аргумент
            object[] array = (object[])arg;
            string text =(string)array[0]; 
            TextEditorCoreParallel textEditorCoreParallel = (TextEditorCoreParallel) array[1];             
            textEditorCoreParallel.flowDocument.Blocks.Remove(textEditorCoreParallel.flowDocument.Blocks.LastBlock  );
        
            Paragraph myParagraph = new Paragraph(new Run(text));
            textEditorCoreParallel.flowDocument.Blocks.Add(myParagraph ); 
  
     return null;
 }
        
        
        
//.............................................................................................................
 
  
    }//class Ambar

//.............................................................................................................
//                                              Класс сортировки
//.............................................................................................................
 
public class Sorting
 {      int[] result; // массив результатов работы процессоров исполнителей 
        int[,] granicy; // массив вычисления диапазонов данных для процессов 
        int N;  // величина исходного массива
        int T;  // степень распараллеливания 
        int cikl=-1; // цикл сортировки
        int delta; // рабочая переменная
        int realProcess; // количество реальных процессов сортировки, выcчитываемая величина
        int[] unsortedArray; // массив подлежащий сортировке
        int[] sortedArray;   // отсортированный массив
        int[] myClients;     //  массив номеров рабочих юнитов
        float progress=0.0f;
 
    
    
    public object   managerSortingF1(object arg, int myUnit)   // метод управления сортировкой метод F1
       {  // распакуем входные аргументы
         if(ProgramSort. processSorting!=0) return null;
         ProgramSort.   processSorting=1;
         int cikl;
         object[] argument = (object[])arg;       
         unsortedArray = (int[])argument[0]; // исходный массив
         sortedArray   = (int[])argument[1]; //  отсортированный массив
         myClients = (int[]) argument[2]   ; //  массив номеров рабочих юнитов
   
         int core =(int)argument[3];               // число рабочих ядер
         result= new int[T];
         T= core;
   
         N = unsortedArray.GetLength(0);      // величина исходного массива
         result = new int[core];              // в этот массив потоки будут заносить результаты сортировки в каждом цикле
         granicy = new int[T,2];                // границы сортируемого массива (нижняя и верхняя )для каждого юнита
         
// назначим рабочим ядрам сортировки их методы
        for (int i=0;i<T;i++)
        { WorkCore wc = new WorkCore(); // методы должны принадлежать различным экземплярам класса
          Func<object,int,object> f1 = wc.coreSorting;
          ProgramSort.myCoreParallel.  SetMetodToClient  (myClients[i], 1,( object) f1, null) ;
        }
 
         int realProcess=1; // количество реальных процесов
         int  delta ;// = N-;  // величина сектора поиска каждого процесса
       
         for (cikl =0;cikl < N; cikl++) // основной цикл сортировки
         {
      
           delta= (N-cikl)/(T ); //величина сектора поиска каждого процесса
    
 // определим границы сортировки для процессов   
           realProcess=1; 
           granicy[0,0]= cikl;   granicy[0,1]= cikl + delta ; if( granicy[0,1] > N -1) {granicy[0,1]=N-1;  ProgramSort.  processRun=0;  return null;}
            
             for (int i=1;i < T; i++)
           {  granicy[i,0]= granicy[i-1,1] +1; if(granicy[i,0] > N-1) {ProgramSort.  processRun=0;  return null;}
              realProcess++;
              granicy[i,1]= granicy[i,0] + delta; if(granicy[i,1] > N-1)  granicy[i,1]= N-1;
              
           }
 
         }
 
        ProgramSort.  processRun=0;
        return null;
       }
//.............................................................................................................
 
    public object   managerSortingF2(object arg, int myUnit)   // метод управления сортировкой метод F2
    {// здесь распределяются задания рабочим юнитам сортировки
      
        if (++cikl <N)
       
       { 
            realProcess=1; // количество реальных процесов
            delta= (N-cikl)/(T ); //величина сектора сортировки каждого процесса
            granicy[0,0]= cikl;   granicy[0,1]= cikl + delta ; if( granicy[0,1] > N -1) {granicy[0,1]=N-1; }
     else       {
        for (int i=1;i < T; i++)
           {  granicy[i,0]= granicy[i-1,1] +1; if(granicy[i,0] > N-1) {break;}
              realProcess++;
              granicy[i,1]= granicy[i,0] + delta; if(granicy[i,1] > N-1)  granicy[i,1]= N-1;
              
           }
 
            }    
   
  //    Границы расчитаны, сформируем входные аргументы рабочих юнитов
        for(int i=1; i <=T; i++)
          { if( i <= realProcess) 
               { object[] ob = new object[3];
                 ob[0]= (object) unsortedArray; // соритруемый массив
                 ob[1]= granicy[i-1,0]; // нижняя граница сортировки
                 ob[2]= granicy[i-1,1]; // верхняя граница
                 object Argument = (object)ob;
                 ProgramSort.myCoreParallel.  SetArgumentToClient  (myClients[i-1], 1 , Argument);
 
               }
                 else {  ProgramSort.myCoreParallel.  SetArgumentToClient  (myClients[i-1], 1 , null);  }// если процесс не участвет в сортировке         
        }
    
    
            float tmp = ((float)cikl/(float)N) *100.0f;
            if(tmp <= progress+0.01f)  return null; // передали управление методу F3
            progress=tmp;
// выведем процент сортировки
            // подготовим письмо и отошлем в адрес юнита 0 с методом заполнения формы addProgressTextBox(object arg) 
          CoreParallel.UserFormMail[]  ufmArray = new CoreParallel.UserFormMail[1];  // создаем массив содержащий переменные типа UserFormMail
          CoreParallel.UserFormMail  ufm  = new CoreParallel.UserFormMail();  // определяем переменную типа UserFormMail
          ufm.FromUnit=myUnit; // адрес отправителя
          ufm.ToUnit=0;        // адрес получателя письма   
         
          // пакуем  аргументы 
          string text = "Выполнено " + tmp.ToString() +"%" + " задания"; 
          object[] array = new  object[2]; array[0]= (object)text; array[1]= (object)ProgramSort. textEditorCoreParallel; object arg1 =(object)array;
          ufm.FuncArgument = arg1; 
          ufm.Func=  ProgramSort.ambar.addProgressToRichTextBox; // прикрепили метод, выполняемый в основном потоке
        
          ufm.Metka=  0;  // признак того, что не требуется  ответное письмо от юнита 0
          ufmArray[0]=ufm; // заполнили массив писем, применяется пакетный способ рассылки писем как наиболее быстрый
          CoreParallel.units[myUnit].unitMailSender. SetAndSendUserDataMailArray(ufmArray,0); // отправили массив писем в адрес юнита 0.   
         
            
            
            return null; // передали управление методу F3
 
        }
        else { // сортировка закончена
        
   // подготовим письмо и отошлем в адрес юнита 0 с методом вывода результата
          CoreParallel.UserFormMail[] ufmArray = new CoreParallel.UserFormMail[1];  // создаем массив содержащий переменные типа UserFormMail
          CoreParallel.UserFormMail    ufm  = new CoreParallel.UserFormMail();  // определяем переменную типа UserFormMail
          ufm.FromUnit=myUnit; // адрес отправителя
          ufm.ToUnit=0;        // адрес получателя письма
    
          ufm.FuncArgument = null; 
          ufm.Func=    mailEnd; // прикрепили метод, выполняемый в основном потоке
          ufm.Metka= CoreParallel.GetNewMetka();  // признак того, что  требуется  ответное письмо от юнита 0
          ufmArray[0]=ufm; // заполнили массив писем, применяется пакетный способ рассылки писем как наиболее быстрый
          CoreParallel.units[myUnit].unitMailSender. SetAndSendUserDataMailArray(ufmArray,0); // отправили массив писем в адрес юнита 0. 
          ProgramSort.myCoreParallel.WaitMail(myUnit); // остановились в ожидании ответного письма, синхронизация
   
  // подготовим письмо и отошлем в адрес юнита 0 с методом заполнения формы addTextToRichTextBox(object arg) 
          ufmArray = new CoreParallel.UserFormMail[1];  // создаем массив содержащий переменные типа UserFormMail
          ufm  = new CoreParallel.UserFormMail();  // определяем переменную типа UserFormMail
          ufm.FromUnit=myUnit; // адрес отправителя
          ufm.ToUnit=0;        // адрес получателя письма   
         
  // пакуем  аргументы 
          string text = "Сортировка закончена\n"; 
          object[] array = new  object[2]; array[0]= (object)text; array[1]= (object)ProgramSort. textEditorCoreParallel; object arg1 =(object)array;
          ufm.FuncArgument = arg1; 
          ufm.Func=  ProgramSort.ambar. addTextToRichTextBox; // прикрепили метод, выполняемый в основном потоке
        
          ufm.Metka=  CoreParallel.GetNewMetka();   // признак того, что  требуется  ответное письмо от юнита 0
          ufmArray[0]=ufm; // заполнили массив писем, применяется пакетный способ рассылки писем как наиболее быстрый
          CoreParallel.units[myUnit].unitMailSender. SetAndSendUserDataMailArray(ufmArray,0); // отправили массив писем в адрес юнита 0.   
          ProgramSort.myCoreParallel.WaitMail(myUnit); // остановились в ожидании ответного письма, синхронизация
// уничтожим альянс юнитов сортировки
           CoreParallel.AbortUnit(ProgramSort.unitManager   );
           for(int i = 0; i < T; i++)  CoreParallel.AbortUnit( myClients[i]  );
           ProgramSort.   processSorting=0;
           ProgramSort.  processRun=0;
        }
    
        return null;
    }
//.............................................................................................................
    public object mailEnd(object ob){ for(int i=0; i < ProgramSort.unSortedArray.GetLength(0);  i++) 
                           ProgramSort.tableView2.AddRecord(sortedArray[i]);return null;}
   
//.............................................................................................................
 public object   managerSortingF3(object arg, int myUnit)   // метод управления сортировкой метод F3
    {// здесь обрабатываются результаты сортировки рабочих юнитов
     // прочитаем значения возврата методов рабочих юнитов
       object  ob = new object();
     
     for(int i=0; i< realProcess; i++)
         { 
           ob= ProgramSort.myCoreParallel. GetReturnToClient  (myClients[i],1); if(ob!=null) result[i]= (int)ob;
         }
  
     // найдем среди результатов максимальный 
        int max= unsortedArray   [result[0]]; int index=0;
        for(int i=0; i< realProcess; i++)
        {  if(   unsortedArray [result[i]]  <=  max) continue; max =  unsortedArray [result[i]];   index=i;  }
  
      if(unsortedArray[cikl] < max) { unsortedArray[result[index]]= unsortedArray[cikl]; } // поменяли значения найденного элемента 
        sortedArray[cikl]=max;
   
 
     return null;
    }
 
 
 
} //class Sorting
 
public class WorkCore
    {
      public object coreSorting(object arg, int myUnit)  // метод сортировки на одном ядре
      { if(arg==null) return  null;
        object[] ob= (object[])arg;
        int[] unsorted = (int[]) ob[0];  // сортируемый массив
        int gr1 =(int) ob[1]; int gr2= (int) ob[2];  // нижняя и верхняя границы сортировки
     
        // сортировка в отдельном потоке
        int max= unsorted[gr1]; int ret = gr1;
        for(int i=gr1 ; i<=gr2 ;i++) {if(unsorted[i] < max) continue; else {max = unsorted[i] ; ret=i;   } }
        return (object)ret ; // вернули индекс максимального элемента в сегменте массива
 
      }  
    }
 
}

 // сортировка в отдельном потоке
        int max= unsorted[gr1]; int ret = gr1;
        for(int i=gr1 ; i<=gr2 ;i++) {if(unsorted[i] < max) continue; else {max = unsorted[i] ; ret=i;   } }
        return (object)ret ; // вернули индекс максимального элемента в сегменте массива

using System;class E{static int A=4,B=10,M=1,D=5,Z=3,F=0;static int[]L={3,3};
static string a2(){int a=A,b=B,c=0,e=3,g=0,h,i,j,k,l,m,p,q=L.Length;var r=false;
var t=new int[10,20];t[M,D]=8;if(F!=1)goto X;for(int u=0;u<q;u++){c=L[u];int d=u
==0?Z:L[u-1];if(d==0||d==2){k=0;l=2;m=1;p=3;j=2;h=0;i=1;}else{k=1;l=3;m=0;p=2;j=
1;h=1;i=0;}if(u==0){if((Z!=k||c!=l)&&(Z!=l||c!=k))e=Z;else e=c;g=e==k?-1:1;A=A+g
*h;B=B+g*i;if(A<0||A>=10||B<0||B>=20){F=2;goto X;}if(t[A,B]==8)r=true;t[A,B]=5;}
if(u!=q-1||r)t[a,b]=c==m||c==p?c==m^d!=k?3:4:j;else t[a,b]=d==0||d==2?7:6;if(c==
0)b++;if(c==2)b--;if(c==1)a++;if(c==3)a--;}if(t[A,B]!=5){F=2;goto X;}if(r){t[a,b
]=c==0||c==2?7:6;F=3;for(h=0;h<10;h++)for(i=0;i<20;i++)if(t[h,i]==0)F=1;if(F==3)
goto X;var v=new Random();for(;;){M=v.Next(10);D=v.Next(20);if(t[M,D]==0){t[M,D]
=8;break;}}var w=new int[q+1];for(g=0;g<q;g++)w[g+1]=L[g];w[0]=e;L=w;}else{for(g
=q-2;g>=0;g--)L[g+1]=L[g];L[0]=e;}X:var R="";var x="\r\n";var s=new string('/',
20+4);R+=x+s+x;var y=" |-\\/O"=*";for(h=0;h<10;h++){R+="//";if(F==1)for(i=0;i<
20;i++)R+=y[t[h,i]].ToString();else{var z=F==2?"Game Over!":"  Win!!!  ";int C=
20/2;R+=new string(' ',C-5)+z+new string(' ',20-C-5);}R+="//";R+=x;}R+=s+
"   QuineSnake by KvanTTT for GoStash"+x;return R;}static void Main(){if(F!=0){
int a=(int)Console.ReadKey(true).Key;Z=a<37||a>40?L[0]:a-37;}if(F==0)F=1;var R=a2();var s=
"using System;class E{{static int {10}={8},{11}={9},{12}={6},{13}={7},{14}={4},{17}={16};static int[]{15}={5};static string a2(){{int a={10},b={11},c=0,e=3,g=0,h,i,j,k,l,m,p,q={15}.Length;var r=false;var t=new int[10,20];t[{12},{13}]=8;if({17}!=1)goto X;for(int u=0;u<q;u++){{c={15}[u];int d=u==0?{14}:{15}[u-1];if(d==0||d==2){{k=0;l=2;m=1;p=3;j=2;h=0;i=1;}}else{{k=1;l=3;m=0;p=2;j=1;h=1;i=0;}}if(u==0){{if(({14}!=k||c!=l)&&({14}!=l||c!=k))e={14};else e=c;g=e==k?-1:1;{10}={10}+g*h;{11}={11}+g*i;if({10}<0||{10}>=10||{11}<0||{11}>=20){{{17}=2;goto X;}}if(t[{10},{11}]==8)r=true;t[{10},{11}]=5;}}if(u!=q-1||r)t[a,b]=c==m||c==p?c==m^d!=k?3:4:j;else t[a,b]=d==0||d==2?7:6;if(c==0)b++;if(c==2)b--;if(c==1)a++;if(c==3)a--;}}if(t[{10},{11}]!=5){{{17}=2;goto X;}}if(r){{t[a,b]=c==0||c==2?7:6;{17}=3;for(h=0;h<10;h++)for(i=0;i<20;i++)if(t[h,i]==0){17}=1;if({17}==3)goto X;var v=new Random();for(;;){{{12}=v.Next(10);{13}=v.Next(20);if(t[{12},{13}]==0){{t[{12},{13}]=8;break;}}}}var w=new int[q+1];for(g=0;g<q;g++)w[g+1]={15}[g];w[0]=e;{15}=w;}}else{{for(g=q-2;g>=0;g--){15}[g+1]={15}[g];{15}[0]=e;}}X:var R={1}{1};var x={1}{2}r{2}n{1};var s=new string('/',20+4);R+=x+s+x;var y={1} |-{2}{2}/O{2}{1}=*{1};for(h=0;h<10;h++){{R+={1}//{1};if({17}==1)for(i=0;i<20;i++)R+=y[t[h,i]].ToString();else{{var z={17}==2?{1}Game Over!{1}:{1}  Win!!!  {1};int C=20/2;R+=new string(' ',C-5)+z+new string(' ',20-C-5);}}R+={1}//{1};R+=x;}}R+=s+{1}   QuineSnake by KvanTTT for GoStash{1}+x;return R;}}static void Main(){{if({17}!=0){{int a=(int)Console.ReadKey(true).Key;{14}=a<37||a>40?{15}[0]:a-37;}}if({17}==0){17}=1;var R=a2();var s={1}{0}{1};Console.Write(s,s,'{1}','{2}{2}',R,{14},{1}{{{1}+string.Join({1},{1},{15})+{1}}}{1},{12},{13},{10},{11},{1}A{1},{1}B{1},{1}M{1},{1}D{1},{1}Z{1},{1}L{1},{17},{1}F{1});}}}}{3}";Console.Write(s,s,'"','\\',R,Z,"{"+string.Join(",",L)+"}",M,D,A,B,"A","B","M","D","Z","L",F,"F");}}

public static class MySortingLib
{
    public static int[] ParallelSort(int[] arr)
    {
        return arr.AsParallel().OrderBy(x => x).ToArray();
    }
}