битоническая сортировка

Битоническая
сортировка
Реализация алгоритма с использованием CUDA и MPI

Битоническая сортировка
 В основе этой сортировки лежит операция Bn (полуочиститель, half - cleaner)
над массивом, параллельно упорядочивающая элементы пар xi и xi + n / 2
 Сортировка основана на понятии битонической последовательности и
утверждении :
Если набор полуочистителей правильно сортирует произвольную
последовательность нулей и единиц, то он корректно сортирует
произвольную последовательность.
 Последовательность [a0, a1, …, an – 1] называется битонической, если она или
состоит из двух монотонных частей (т.е. либо сначала возрастает, а потом
убывает, либо наоборот), или получена путем циклического сдвига из такой
последовательности.
 Так, последовательность 5, 7, 6, 4, 2, 1, 3 битоническая, поскольку получена из 1, 3,
5, 7, 6, 4, 2 путем циклического сдвига влево на два элемента.
dmitry@protopopov.ru

 Доказано, что если применить полуочиститель Bn к битонической
последовательности [a0, a1, …, an–1], то получившаяся последовательность
обладает следующими свойствами :
1. обе ее половины также будут битоническими.
2. любой элемент первой половины будет не больше любого элемента
второй половины.
3. хотя бы одна из половин является монотонной.

 Применив к битонической последовательности [a0, a1, …, an–1]
полуочиститель Bn, получим две последовательности длиной n/2, каждая
из которых будет битонической, а каждый элемент первой не превысит
каждый элемент второй.
 Далее применим к каждой из получившихся половин полуочиститель Bn/2,
получим уже четыре битонические последовательности длины n/4.
 Применим к каждой из них полуочиститель Bn/2 и продолжим этот процесс
до тех пор, пока не придем к n/2 последовательностей из двух элементов.
 Применив к каждой из них полуочиститель B2, поскольку все
последовательности уже упорядочены, получим отсортированную
последовательность.

 Итак, последовательное применение полуочистителей Bn, Bn/2, …, B2
сортирует произвольную битоническую последовательность.
 Эту операцию называют битоническим слиянием и обозначают Mn.

Получение битонической
последовательности
 Пусть задан одномерный неотсортированный массив [a0, a1, …, an–1]
 Очевидно, что данный массив может быть преобразован к битонической
последовательности с помощью разделения массива на два подмассива и
сортировки одной половины по-возрастанию, а другой половины по
убыванию
 После того, как массив будет преобразован к битонической
последовательности к нему можно будет применить операцию
битонического слияния Mn и полученный массив станет отсортированным
 Для сортировки подмассивов может быть применён алгоритм
битонической сортировки, либо любой другой алгоритм сортировки
 В данной реализации для сортировки подмассивов применён алгоритм
битонической сортировки.

Степени двойки
 Поскольку в основе алгоритма лежит последовательное применение
полуочистителей Bn, Bn/2, …, B2 для массива [a0, a1, …, an–1], то очевидно,
что это накладывает ограничение на размер массива к которому может
быть применён алгоритм битонической сортировки – размер массива
должен быть равен степени двойки, то есть
n=2k
 Для сортировки массива произвольного размера N, исходный массив
должен быть разделён на подмассивы размера степени двойки. Каждый
подмассив сортируется битонической сортировкой, а затем производится
слияние уже отсортированных подмассивов в итоговый отсортированный
массив

Степени двойки
 Схема сортировки массива произвольного размера N = 2a+2b+…+2z
Исходный неотсортированный массив
2a 2b
2z
2a 2b 2z
Итоговый отсортированный массив

Параметры алгоритма
 Для определения порядка сортировки используется функция fn_compare,
со следующими свойствами
fn_compare(a,b) < 0 если a < b
fn_compare(a,b) > 0 если a > b
fn_compare(a,b) == 0 если a == b
 И параметр direction = 1, -1 – определяющий порядок сортировки
алгоритмом

Ограничения в реализации алгоритма
 Данная реализация алгоритма реализует сортировку массивов только из
целых чисел, но может быть легко изменена для сортировки массивов
требуемого типа данных
 Настройки реализации алгоритма для CUDA вынесены в макросы
///////////////////////////////////////////////////////////////////////////////////////
/////
// Настроечные аттрибуты
// _comparer - функция сравнения двух элементов массива
// _indexator - функция определения номера корзины для элемента массива
// _non_parallel_sort - фунция сортировки без использования паралельных вычислений
// _parallel_sort - фунция сортировки с использованием паралельных вычислений
#define fn_comparer device_comparer<long>
#define fn_indexator device_indexator<long>
#define fn_non_parallel_sort device_bubble_sort<long>
#define fn_parallel_sort host_bucket_sort<long>

Разделение на подмассивы размера
степени двойки
 Оптимальное разделение исходного массива на подмассивы размера
степени двойки является темой для отдельной задачи по оптимизации
алгоритма, поскольку это разделение может существенно влиять на
количество необходимых операций и на время вычислений на
параллельных вычислительных устройствах
 В данной реализации используется “естественное” разделение исходного
массива на подмассивы размера степени двойки – представление размера
массива в базисе степеней двойки, то есть если 𝑁 = 𝑎𝑖2𝑖
, то размер i-го
подмассива ni=ai2i
 Очевидно, что в этом случае i-ый подмассив начинается в исходном
массиве с индекса (N & ((1<<i)-1)), где & - операция побитового
умножения, а << - операция двоичного сдвига числа

Шаг алгоритма
 Поскольку в данной реализации для получения битонической
последовательности из исходного массива применяется сам алгоритм
битонической сортировки, то шагом алгоритма является применение
полуочистителя ко всему массиву.
for(int k=1; (1<<k) <= n ; k++) {
if ( n & (1<<k) ) {
for(int i = 0; i < k ; i++ ) {
for( int j = i; j >= 0 ; j-- ) {
// Определим оптимальное разбиения на процессы, нити и циклы
// одна нить в просессе будет будет выполнять цикл с указанным количеством итераций
int blocks = 1 << (max(1,(int)k/3));
int threads = 1 << (max(1,(int)k/3));
int loops = 1 << (k-2*max(1,(int)k/3)-1);
assert((1<<k) == 2*blocks*threads*loops);
// одинаковый шаг в каждом блоке гарантирует отсутствие коллизий (одновременного доступа к одним и тем же данным)
global_bitonic_worker<T> <<< blocks, threads >>>(&device_data[n&((1<<k)-1)], n&(1<<k), i, j, loops, direction);
}}}

Применение полуочистителя
 Поскольку мы используем сам битонический алгоритм для получения из
исходного массива [a0, a1, …, an – 1], где n=2k, битонической
последовательности, то принимаем правило, что левый подмассив мы
сортируем в требуемом порядке для итогового массива, а правый – в
обратном порядке
 Алгоритм мы начинаем с сортировки подмассивов размера 2 – применяя
полуочиститель B2
 Затем подмассивов размера 4 – применяя полуочистители B4,B2
 И так далее, до размера 2k – применяя полуочистители Bn, Bn/2, …, B2

Применение полуочистителя
 Очевидно, что перед применением полуочистителя мы должны знать в
каком порядке мы хотим отсортировать данный подмассив
 При применении полуочистетелей B2
i, B2
i-1, …, B2 к элементам подмассивов
размера 2i мы должны выбрать порядок сортировки основываясь на
старших разрядах индекса первого элемента подмассива в исходном
массиве
 В данной реализации используется чётность старших разрядах начального
индекса подмассива начиная с i-ого бита, хотя достаточно использовать
только значение i-го бита
int parity = (id >> i);
while(parity>1) parity = (parity>>1) ^ (parity&1);

Реализация алгоритма с
использованием CUDA
 При программировании для CUDA используется модель общей памяти,
доступной всем параллельным нитям.
 За один шаг применяется полуочиститель B2
j+1 для всех подмассивов
размера 2i, где j < i , i <= k и n=2k

 Основной цикл алгоритма
for(int k=1; (1<<k) <= n ; k++) {
if ( n & (1<<k) ) {
for(int i = 0; i < k ; i++ ) {
for( int j = i; j >= 0 ; j-- ) {
// Определим оптимальное разбиения на процессы, нити и циклы
// одна нить в просессе будет будет выполнять цикл с указанным количеством итераций
int blocks = 1 << (max(1,(int)k/3));
int threads = 1 << (max(1,(int)k/3));
int loops = 1 << (k-2*max(1,(int)k/3)-1);
assert((1<<k) == 2*blocks*threads*loops);
// одинаковый шаг в каждом блоке гарантирует отсутствие коллизий (одновременного доступа к одним и тем же данным)
global_bitonic_worker<T> <<< blocks, threads >>>(&device_data[n&((1<<k)-1)], n&(1<<k), i, j, loops, direction);
}}}

 Алгоритм применения полуочистителя параллельными нитями
// Получаем идентификатор нити
int block = blockDim.x*blockIdx.x + threadIdx.x;
int step = 1<<j;
for(int y=0; y<loops; y++) {
// Получаем идентификатор шага цикла
int id = block*loops+y;
int offset = ((id>>j)<<(j+1))+(id&((1<<j)-1));
int parity = (id >> i);
while(parity>1) parity = (parity>>1) ^ (parity&1);
parity = 1-(parity<<1); // теперь переменная parity может иметь только 2 значения 1 и -1
assert ((offset+step) < n) ;
int value = parity*direction*fn_comparer(&data[offset],&data[offset+step]);
if (value > 0) device_exchange<T>(&data[offset],&data[offset+step],1);
}

 Для слияния отсортированных массивов степеней двойки используется
алгоритм слияния отсортированных массивов, реализованный в одной
нити
for(int k=0; k<8*sizeof(int) ; k++ ) size[k] = n & (1<<k);
int total = n;
while(total > 0) {
int k = 8*sizeof(int);while( (k-->0) && (size[k] == 0) ) ;
for (int i=k; i-- ; ) {
if (size[i] > 0 &&
direction*fn_comparer(
&data[(n&((1<<k)-1))+size[k]-1],
&data[(n&((1<<i)-1))+size[i]-1]) < 0)
{
k = i;
}
}
total--;
size[k]--;
device_copy(&data2[total],&data[(n&((1<<k)-1))+size[k]],1);
}

использованием MPI
 Архитектура MPI предполагает модель независимых вычислительных
устройств, со своей неразделяемой памятью и использованием “хост”
процесса, отвечающего за ввод-вывод информации.
 Каждый процесс имеет свой уникальный идентификатор, получаемый
вызовом метода MPI_Comm_rank
 Общее количество процессов может быть получено вызовом метода
MPI_Comm_size
 В данной реализации все “дочерние” процессы переходят в режим
ожидания получения задания от другого процесса, который становится
ведущим по отношению к нему.
 При окончании работы алгоритма “хост” процесс посылает сигнал об
окончании работы всем “дочерним” процессам, после чего “дочерний”
процесс завершает свою работу.

 Алгоритм мы начинаем с сортировки подмассивов размера 2 – применяя
битоническое слияние M2
 Затем подмассивов размера 4 – применяя битоническое слияние M4
 И так далее, до размера 2k – применяя битоническое слияние Mn
 Поскольку применение битонического слияния M2
i является применением
полуочистителя B2
i к массиву размера 2i, а затем битонического слияния M2
i-1 к
левой и правой половинам массивам, то при применении битонического
слияния M2
i после применения полуочистителя B2
i к массиву размера 2i
текущий процесс может попытаться разделить работу с каким-нибудь другим
процессом, поручив ему задание применить битоническое слияние M2
i-1 к
правой половине массива, а самому продолжить применять битоническое
слияние M2
i-1 к левой половине массива, после чего соединить обратно
отсортированные левую и правую части массива.

 Для выбора ведомого процесса с которым текущий процесс может
разделить работу при применении битонического слияния M2
i, желательно
иметь единый диспечер процессов для оптимальной загрузки всех
процессов, но в данной реализации используется следующий алгоритм,
организующий все процессы в единое дерево ведущий-ведомый:
int child = myrank+shift;
if (k>0 && child < nrank) {
shift<<=1;
/* Отдаём половину массива на обработку процессу с номером child */
shift>>=1;
} else if (k>0) {
/* Обрабатываем всё сами */
}

 Очевидно, что время работы данной реализации алгоритма существенно
зависит от скорости обмена данными между отдельными процессами

Алгоритм битонической сортировки с
1. Разделить исходный массив размера N на подмассивы степеней двойки в
соответствии с представлением N в двоичном базисе
2. Для каждого массива размера 2k выполнить
1) Цикл для i от 1 до k
1) Цикл для j от i-1 до 0 с шагом -1
1) На GPU запускается процедура применения ко всем элементам массива полуочистителя B2
j
2) Конец цикла для j
2) Конец цикла для i
3. На GPU запускается процедура слияния всех отсортированных
подмассивов размера 2k k=0..31

Алгоритм битонической сортировки с
1. Хост-процесс формирует исходный массив
2. Хост-процесс разделяет исходный массив размера N на подмассивы степеней двойки в соответствии с представлением N в двоичном базисе
3. Для каждого массива размера 2k выполняется
1) Цикл для i от 1 до k
1) Разделить массив размера 2k на подмассивы размера 2i
2) Применить ко всем элементам массива размера 2i рекурсивную процедуру битонического слияния М2
i
1) К массиву применить полуочиститель
2) Разделить массив на левую и правую части
3) Если есть свободный процесс, то
1) Передать правую часть свободному процессу для применения битонического слияния М2
i-1
2) Применить рекурсивную процедуру битонического слияния М2
i-1 к левой части
3) Получить обратно правую часть
4) Иначе
i-1 к левой части
i-1 к правой части
3) Конец цикла
2) Конец цикла для i
4. Хост-процесс применяет процедуру слияния всех отсортированных подмассивов размера 2k k=0..31

Спасибо за внимание
 Контакты
 Дмитрий Протопопов, Москва, Россия
+7 916 6969591
Исходные коды и примеры использования доступны по адресу
https://github.com/dprotopopov/ParallelSorting

битоническая сортировка

Recommended

Recommended

More Related Content

Similar to битоническая сортировка

Similar to битоническая сортировка (20)

More from Dmitry Protopopov

More from Dmitry Protopopov (6)

битоническая сортировка