Обсуждение участника:AKhimulya — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
м
Строка 47: Строка 47:
 
Рассмотрим псевдокод данного алгоритма:
 
Рассмотрим псевдокод данного алгоритма:
  
     // если <math>right <= left</math> возвращает <math>left</math>
+
     // если <math>right \leqslant left</math> возвращает <math>left</math>
     // если <math>x <= T[left]</math>, возвращает <math>left</math>
+
     // если <math>x \leqslant T[left]</math>, возвращает <math>left</math>
 
     // иначе возвращает наибольший индекс <math>i</math> из отрезка <math>[left; right]</math> такой, что <math>array[i - 1] < x</math>
 
     // иначе возвращает наибольший индекс <math>i</math> из отрезка <math>[left; right]</math> такой, что <math>array[i - 1] < x</math>
 
     binarySearch(x, array, left, right)
 
     binarySearch(x, array, left, right)
 
      
 
      
 
     // слияние <math>T[left_{1} \dots right_{1}]</math> и <math>T[left_{2} \dots right_{2}]</math> в <math>A[left_{3} \dots right_{1} - left_{1} + right_{2} - left_{2}]</math>
 
     // слияние <math>T[left_{1} \dots right_{1}]</math> и <math>T[left_{2} \dots right_{2}]</math> в <math>A[left_{3} \dots right_{1} - left_{1} + right_{2} - left_{2}]</math>
     mergeMT(T, <math>left_{1}</math>, <math>right_{1}</math>, <math>left_{2}</math>, <math>right_{2}</math>, A, <math>left_{3}</math>):
+
     mergeMT(T, left<math>_{1}</math>, right<math>_{1}</math>, left<math>_{2}</math>, right<math>_{2}</math>, A, left<math>_{3}</math>):
     <math>n_{1}</math> = <math>right_{1}</math> - <math>left_{1}</math> + 1
+
     n<math>_{1}</math> = right<math>_{1}</math> - left<math>_{1}</math> + 1
     <math>n_{2}</math> = <math>right_{2}</math> - <math>left_{2}</math> + 1
+
     n<math>_{2}</math> = right<math>_{2}</math> - left<math>_{2}</math> + 1
     if <math>n_{1}</math> < <math>n_{2}</math>:
+
     if n<math>_{1}</math> < n<math>_{2}</math>:
         swap(<math>left_{1}</math>, <math>left_{2}</math>)
+
         swap(left<math>_{1}</math>, left<math>_{2}</math>)
         swap(<math>right_{1}</math>, <math>right_{2}</math>)
+
         swap(right<math>_{1}</math>, right<math>_{2}</math>)
         swap(<math>n_{1}</math>, <math>n_{2}</math>)
+
         swap(n<math>_{1}</math>, n<math>_{2}</math>)
 
      
 
      
     if <math>n_{1}</math> == 0:
+
     if n<math>_{1}</math> == 0:
 
         return
 
         return
 
     else
 
     else
         <math>mid_{1}</math> = (<math>left_{1}</math> + <math>right_{1}</math>) / 2
+
         mid<math>_{1}</math> = (left<math>_{1}</math> + right<math>_{1}</math>) / 2
         <math>mid_{2}</math> = binarySearch(T[<math>mid_{1}]</math>, T, <math>left_{2}</math>, <math>right_{2}</math>)
+
         mid<math>_{2}</math> = binarySearch(T[mid<math>_{1}</math>], T, left<math>_{2}</math>, right<math>_{2}</math>)
         <math>mid_{3}</math> = <math>left_{3}</math> + (<math>mid_{1}</math> - <math>left_{1}</math>) + (<math>mid_{2}</math> - <math>left_{2}</math>)
+
         mid<math>_{3}</math> = left<math>_{3}</math> + (mid<math>_{1}</math> - left<math>_{1}</math>) + (mid<math>_{2}</math> - left<math>_{2}</math>)
         A[<math>mid_{3}</math>] = T[<math>mid_{1}</math>]
+
         A[mid<math>_{3}</math>] = T[mid<math>_{1}</math>]
         '''spawn''' mergeMT(T, <math>left_{1}</math>, <math>mid_{1}</math> - 1, <math>left_{2}</math>, <math>mid_{2}</math> - 1, A, <math>left_{3}</math>)
+
         '''spawn''' mergeMT(T, left<math>_{1}</math>, mid<math>_{1}</math> - 1, left<math>_{2}</math>, mid<math>_{2}</math> - 1, A, left<math>_{3}</math>)
         mergeMT(T, <math>mid_{1}</math> + 1, <math>right_{1}</math>, <math>mid_{2}</math>, <math>right_{2}</math>, A, <math>mid_{3}</math> + 1)
+
         mergeMT(T, mid<math>_{1}</math> + 1, right<math>_{1}</math>, mid<math>_{2}</math>, right<math>_{2}</math>, A, mid<math>_{3}</math> + 1)
 
         '''sync'''
 
         '''sync'''
  
Оценим время выполнения данного алгоритма сверху при возможности запускать неограниченное количество потоков независимо друг от друга. Оба массива содержат <math>n_{1} + n_{2} = n</math> элементов. К моменту рекурсивных вызовов <math>n_{2} <= n_{1}</math>, значит, <math>n_{2} = 2 * n_{2} / 2 <= (n_{1} + n_{2}) / 2 = n / 2</math>. В худшем случае один из двух рекурсивных вызовов сольет <math>n_{1} / 2</math> элементов <math>T[left_{1} \dots right_{1}]</math> с <math>n_{2}</math> элементами <math>T[left_{2} \dots right_{2}]</math> и тогда количество элементов первых двух массивов в рекурсивном вызове будет равно <math>n_{1} / 2 + n_{2} <= n_{1} / 2 + n_{2} / 2 + n_{2} / 2 = (n_{1} + n_{2}) / 2 + n_{2} / 2 <= n / 2 + n / 4 = 3 * n / 4</math>. Так как рекурсивные вызовы функции выполняются параллельно, время их выполнения будет равно времени выполнения самого долгого вызова. В худшем случае это <math>T(3 * n / 4)</math>. Тогда сумарное время работы алгоритма слияния будет равно <math>Tmerge(n) = Tmerge(3 * n  / 4) + \Theta(\log(n)) = \Theta(\log^2(n))</math>, т.к. асимпототика каждого вызова функции - <math>\Theta(\log(n))</math>, т.е. время, затрачиваемое на бинарный поиск.  
+
Оценим время выполнения данного алгоритма сверху при возможности запускать неограниченное количество потоков независимо друг от друга. Оба массива содержат <math>n_{1} + n_{2} = n</math> элементов. К моменту рекурсивных вызовов <math>n_{2} \leqslant n_{1}</math>, значит, <math>n_{2} = 2 * n_{2} / 2 \leqslant (n_{1} + n_{2}) / 2 = n / 2</math>. В худшем случае один из двух рекурсивных вызовов сольет <math>n_{1} / 2</math> элементов <math>T[left_{1} \dots right_{1}]</math> с <math>n_{2}</math> элементами <math>T[left_{2} \dots right_{2}]</math> и тогда количество элементов первых двух массивов в рекурсивном вызове будет равно <math>n_{1} / 2 + n_{2} \leqslant n_{1} / 2 + n_{2} / 2 + n_{2} / 2 = (n_{1} + n_{2}) / 2 + n_{2} / 2 \leqslant n / 2 + n / 4 = 3 * n / 4</math>. Так как рекурсивные вызовы функции выполняются параллельно, время их выполнения будет равно времени выполнения самого долгого вызова. В худшем случае это <math>T(3 * n / 4)</math>. Тогда сумарное время работы алгоритма слияния будет равно <math>Tmerge(n) = Tmerge(3 * n  / 4) + \Theta(\log(n)) = \Theta(\log^2(n))</math>, т.к. асимпототика каждого вызова функции - <math>\Theta(\log(n))</math>, т.е. время, затрачиваемое на бинарный поиск.  
  
 
===Сортировка с многопоточным слиянием===
 
===Сортировка с многопоточным слиянием===
Приведем псевдокод алгоритма, использующего слияние из предыдущего раздела, сортирующего элементы A[leftA \dots rightA] и помещающего отсортированный массив в B[leftB \dots leftB + rightA - leftA]
+
Приведем псевдокод алгоритма, использующего слияние из предыдущего раздела, сортирующего элементы <math>A[leftA \dots rightA]</math> и помещающего отсортированный массив в <math>B[leftB \dots leftB + rightA - leftA]</math>
  
 
     mergeSortMT2(A, leftA, rightA, B, leftB):
 
     mergeSortMT2(A, leftA, rightA, B, leftB):
Строка 82: Строка 82:
 
             B[leftB] = A[leftA]
 
             B[leftB] = A[leftA]
 
         else
 
         else
             создадим новый массив T[1 \dots n]
+
             создадим новый массив T[1 <math>\dots</math> n]
 
             mid = (leftA + rightA) / 2
 
             mid = (leftA + rightA) / 2
 
             newMid = mid - leftA + 1
 
             newMid = mid - leftA + 1

Версия 10:59, 19 мая 2014

Многопоточная сортировка слиянием

Благодаря тому, что сортировка слиянием построена на принципе "Разделяй и властвуй", выполнение данного алгоритма можно весьма эффективно распараллелить.

Сортировка с однопоточным слиянием

Внесем в алгоритм сортировки слиянием следующую модификацию: будем сортировать левую и правую части массива параллельно.

   mergeSortMT(array, left, right):
       mid = (left + right) / 2
   
       spawn mergeSortMT(array, left, mid)
       mergeSortMT(array, mid + 1, right)
       sync
   
       merge(array, left, mid, right)

В данном алгоритме оператор spawn запускает новый поток, а оператор sync ожидает завершения этого потока. Функция merge аналогична функции merge из раздела слияние двух массивов.
Несмотря на наличие двух рекурсивных вызовов, при оценке будем считать, что совершается один вызов, т.к. оба вызова выполняются параллельно с одинаковой асимптотикой. Оценим время работы данного алгоритма: [math]T(n) = T(n / 2) + \Theta(n) = \Theta(n)[/math]. Данная асимптотика достигается при возможности запускать неограниченное количество потоков независимо друг от друга.
На практике на однопроцессорных компьютерах имеет смысл запускать алгоритм, ограничив количество допустимое количество потоков. Изменим код в соответствии с этими требованиями:

   mergeSortMTBounded(array, left, right):
       mid = (left + right) / 2
   
       if threadCount [math]\lt [/math] maxThreads:
           threadCount++
           spawn mergeSortMTBounded(array, left, mid)
       else:
           mergeSortMTBounded(array, left, mid)
       mergeSortMTBounded(array, mid + 1, right)
       if threadCount [math]\leqslant[/math] maxThreads:
           sync
           threadCount--
   
       merge(array, left, mid, right)

Где threadCount - глобальный счетчик, а maxThreads - ограничение по количеству потоков. Данный алгоритм будет иметь асимптотику: [math]\Theta((n / maxThreads) * \log((n / maxThreads)))[/math].

Многопоточное слияние

Как видно из оценки первого алгоритма, слияние выполняется слишком долго при том, что существует возможность его ускорить. Рассмотрим алгоритм рекурсивного слияния массивов [math]T[left_{1} \dots right_{1}][/math] и [math]T[left_{2} \dots right_{2}][/math] в массив [math]A[left_{3} \dots right_{3}][/math]:

  1. Убедимся, что размер [math]T[left_{1} \dots right_{1}][/math] больше либо равен размеру [math]T[left_{2} \dots right_{2}][/math]
  2. Вычислим [math]x = T[mid_{1}][/math] - середину первого массива ([math]x[/math] также является и медианой этого массива)
  3. При помощи бинарного поиска найдем [math]mid_{2}[/math] такое, что [math]\forall y \in T[left_{2} \dots mid_{2} - 1]: y \lt x[/math]
  4. [math]mid_{3} = left_{3} + (mid_{1} - left_{1}) + (mid_{2} - left_{2})[/math]
  5. [math]A[mid_{3}] = x[/math]
  6. Сольем [math]T[right_{1} \dots mid_{1} - 1][/math] и [math]T[right_{2} \dots mid_{2}][/math] в [math]A[right_{3} \dots mid_{3} - 1][/math]
  7. Сольем [math]T[mid_{1} + 1 \dots right_{1}][/math] и [math]T[mid_{2} \dots right_{2}][/math] в [math]A[mid_{3} + 1 \dots right_{3}][/math]

Рассмотрим псевдокод данного алгоритма:

   // если [math]right \leqslant left[/math] возвращает [math]left[/math]
   // если [math]x \leqslant T[left][/math], возвращает [math]left[/math]
   // иначе возвращает наибольший индекс [math]i[/math] из отрезка [math][left; right][/math] такой, что [math]array[i - 1] \lt  x[/math]
   binarySearch(x, array, left, right)
   
   // слияние [math]T[left_{1} \dots right_{1}][/math] и [math]T[left_{2} \dots right_{2}][/math] в [math]A[left_{3} \dots right_{1} - left_{1} + right_{2} - left_{2}][/math]
   mergeMT(T, left[math]_{1}[/math], right[math]_{1}[/math], left[math]_{2}[/math], right[math]_{2}[/math], A, left[math]_{3}[/math]):
   n[math]_{1}[/math] = right[math]_{1}[/math] - left[math]_{1}[/math] + 1
   n[math]_{2}[/math] = right[math]_{2}[/math] - left[math]_{2}[/math] + 1
   if n[math]_{1}[/math] < n[math]_{2}[/math]:
       swap(left[math]_{1}[/math], left[math]_{2}[/math])
       swap(right[math]_{1}[/math], right[math]_{2}[/math])
       swap(n[math]_{1}[/math], n[math]_{2}[/math])
   
   if n[math]_{1}[/math] == 0:
       return
   else
       mid[math]_{1}[/math] = (left[math]_{1}[/math] + right[math]_{1}[/math]) / 2
       mid[math]_{2}[/math] = binarySearch(T[mid[math]_{1}[/math]], T, left[math]_{2}[/math], right[math]_{2}[/math])
       mid[math]_{3}[/math] = left[math]_{3}[/math] + (mid[math]_{1}[/math] - left[math]_{1}[/math]) + (mid[math]_{2}[/math] - left[math]_{2}[/math])
       A[mid[math]_{3}[/math]] = T[mid[math]_{1}[/math]]
       spawn mergeMT(T, left[math]_{1}[/math], mid[math]_{1}[/math] - 1, left[math]_{2}[/math], mid[math]_{2}[/math] - 1, A, left[math]_{3}[/math])
       mergeMT(T, mid[math]_{1}[/math] + 1, right[math]_{1}[/math], mid[math]_{2}[/math], right[math]_{2}[/math], A, mid[math]_{3}[/math] + 1)
       sync

Оценим время выполнения данного алгоритма сверху при возможности запускать неограниченное количество потоков независимо друг от друга. Оба массива содержат [math]n_{1} + n_{2} = n[/math] элементов. К моменту рекурсивных вызовов [math]n_{2} \leqslant n_{1}[/math], значит, [math]n_{2} = 2 * n_{2} / 2 \leqslant (n_{1} + n_{2}) / 2 = n / 2[/math]. В худшем случае один из двух рекурсивных вызовов сольет [math]n_{1} / 2[/math] элементов [math]T[left_{1} \dots right_{1}][/math] с [math]n_{2}[/math] элементами [math]T[left_{2} \dots right_{2}][/math] и тогда количество элементов первых двух массивов в рекурсивном вызове будет равно [math]n_{1} / 2 + n_{2} \leqslant n_{1} / 2 + n_{2} / 2 + n_{2} / 2 = (n_{1} + n_{2}) / 2 + n_{2} / 2 \leqslant n / 2 + n / 4 = 3 * n / 4[/math]. Так как рекурсивные вызовы функции выполняются параллельно, время их выполнения будет равно времени выполнения самого долгого вызова. В худшем случае это [math]T(3 * n / 4)[/math]. Тогда сумарное время работы алгоритма слияния будет равно [math]Tmerge(n) = Tmerge(3 * n / 4) + \Theta(\log(n)) = \Theta(\log^2(n))[/math], т.к. асимпототика каждого вызова функции - [math]\Theta(\log(n))[/math], т.е. время, затрачиваемое на бинарный поиск.

Сортировка с многопоточным слиянием

Приведем псевдокод алгоритма, использующего слияние из предыдущего раздела, сортирующего элементы [math]A[leftA \dots rightA][/math] и помещающего отсортированный массив в [math]B[leftB \dots leftB + rightA - leftA][/math]

   mergeSortMT2(A, leftA, rightA, B, leftB):
       n = r - p + 1
       if n == 1:
           B[leftB] = A[leftA]
       else
           создадим новый массив T[1 [math]\dots[/math] n]
           mid = (leftA + rightA) / 2
           newMid = mid - leftA + 1
           spawn mergeSortMT2(A, leftA, mid, T, 1)
           mergeSortMT2(A, mid + 1, rightA, T, newMid + 1)
           sync
           mergeMT(T, 1, newMid, newMid + 1, n, B, leftB)

Оценим данный алгоритм сверху при условии, что возможен запуск неограниченного количества независимых потоков. Из предыдущих пунктов [math]TmergeSort(n) = TmergeSort(n / 2) + Tmerge(n) = TmergeSort(n / 2) + \Theta(\log^2(n)) = \Theta(\log^3(n))[/math].