Алговики - Вклад [ru]

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-12-16T13:12:56Z

Evgeny Mortikov:

{{Assignment|Dan|Evgeny Mortikov}}

Автор: [[U:Сергей|Герасимов Сергей]] (619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n).

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

В силу того, что определить разреженную матрицу строго не получается, то разреженными матрицами можно считать именно те, для которых применение специализированных алгоритмов обработки и/или хранения является оправданным.

Огромные разрежённые матрицы часто возникают при решении дифференциальных уравнений именно численными методами.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен (имеется ввиду, что по индексу строки мы получаем информацию из массива pointer[] о расположении ''идущих по порядку элементов этой строки'' в массиве values[], а чтобы получить все элементы какого-то конкретного столбца придется пройтись по всему вектору pointer[]). Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N \cdot M (N \le M)</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>NZ-N</math> сложений(случай с нулевыми строками рассматривать не будем).

=== Макроструктура алгоритма ===

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

=== Схема реализации последовательного алгоритма ===

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

=== Последовательная сложность алгоритма ===

<math>\bullet \ NZ</math> умножений

<math>\bullet \ NZ-N</math> сложений.

Всего <math>2NZ-N</math> операций, где <math>NZ</math> - количество ненулевых элементов, а <math>N</math> - количество строк в матрице.

=== Информационный граф ===

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

Описанный граф изображен на Рис.2. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

=== Ресурс параллелизма алгоритма ===

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

=== Входные и выходные данные алгоритма ===

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N\cdot M (N \le M)</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм не обладает свойством детерминированности, так как количество элементов в строках может быть различным (в отличие от умножения плотной матрицы на вектор, структура которой определена заранее).

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом. Размерность матрицы в рассматриваемом эксперименте роли не играла, так генерировался сразу строчный формат хранения матрицы.

На следующем рисунке показана зависимость времени выполнения алгоритма от числа используемых процессоров и количества ненулевых элементов матрицы. Можно заметить, что скорость вычисления при переходе с последовательной на параллельную версию возросла значительно. Однако, дальнейшее увеличение числа вычислительных устройств не дает сильного прироста производительности. Это объясняется быстрым ростом накладных расходов на организацию параллельного выполнения.

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математический пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-14T22:58:51Z

Evgeny Mortikov:

{{Assignment|ASA|Evgeny Mortikov}}

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> <math>+ 1</math> функция <math>1</math> переменной
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Имеется в виду тот факт, что при рекурсивном вызове процесс, вызвавший IntTrap для двух подотрезков, будет ожидать завершения работы вызванных функций. При этом выполнять какую-то другую работу он не будет. При достаточно большой глубине рекурсии возникнет ситуация, когда много процессоров будут ожидать выполнения работы рекурсивных вызовов, сами при этом простаивая. При ограниченном числе процессоров это сильно замедлит выполнение программы, приблизив его к времени работы последовательного варианта. Однако, если учесть, что время порождения параллельных процессов существенно не равно нулю, время работы такой программы может стать даже больше времени выполнения последовательной версии.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга, так как у каждого процесса существует свой стек, и он работает только с отрезками, которые хранятся в нём. Поэтому не возникнет ситуации, когда один процесс не может продолжить свою работу из-за ожидания завершения другого процесса. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, если это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. В противном случае объем представления функции, подаваемый на вход, нельзя оценить. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI. При запусках использовалась связка openmpi/1.8.4-gcc + gcc/5.2.0, реализация - тут -> [https://github.com/Stalles/superprak1 ссылка на реализацию.]

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-12-08T16:33:27Z

Evgeny Mortikov:

{{Assignment|Dan|Evgeny Mortikov}}

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Метод минимальных невязок используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Приближённое решение в методе получается с помощью вектора в подпространстве Крылова. Для нахождения этого вектора используется алгоритм Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме. На основе этой формы происходит минимизация невязки.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.

Для вычисления векторов ортонормированного базиса используется алгоритм Арнольди:
# Значение первого вектора выбирается как <math>q_1 = b / ||b||</math>
# Оставшиеся векторы <math>q_j, j = 2 .. n</math> считаются по такому плану:
## Вычисляется вектор <math>z</math> путём умножения матрицы <math>A</math> на предыдущий вектор <math>q</math>: <math>z = Aq_{j-1}</math>.
## Вычисляются значения <math>h_{ij-1}</math> для всех <math>i = 1 .. j - 1</math> как скалярное произведение вектора <math>z</math> на вектор <math>q_i</math>: <math>h_{ij-1} = (z, q_i)</math>. После каждого такого вычисления значение вектора <math>z</math> понижается на <math>h_{ij-1} q_i</math>: <math>z = z - h_{ij-1} q_i</math>
## Затем вычисляется значение <math>h_{jj-1}</math> как норма вектора <math>z</math>: <math>h_{jj-1} = ||z||</math>. Алгоритм останавливается, если эта норма равна 0
## Если полученное значение нормы не равно 0, то <math>q_j = z /||z||</math> (что эквивалентно <math>q_j = z /h_{jj-1}</math>

Сложность алгоритма <math>O(n^2)</math>.

Получаемые в процессе работы алгоритма векторы <math>q_1, q_2, ..., q_m</math> образуют искомый ортонормированный базис Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_m = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>

== Вычислительное ядро алгоритма ==
Самая трудоёмкая и самая часто вызываемая операция в алгоритме - умножение матрицы на вектор. В первую очередь это связано с вычислением матрицы Хессенберга и ортонормированного базиса подпространства Крылова.
Число умножений матрицы на вектор: <math>n-1</math> в алгоритме Арнольди, K в выбранном алгоритме решения задачи минимальных квадратов и 1 в подсчёте результата.
Также в алгоритм входят <math>n*(n-1) / 2</math> операций скалярного произведения.

== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение (минимальную норму вектора невязки)
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>

== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.

== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор, поскольку является самым ресурсоёмким, но при этом умножать отдельные строки матрицы можно независимо друг от друга. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Операция вычисления скалярного произведения
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

Несмотря на то, что в теории итерации алгоритма можно выполнять параллельно после выполнения алгоритма Арнольди, на практике необходимая точность может быть достигнута раньше чем на n-й итерации, что потребует какого-нибудь способа прервать последующие итерации. Для избегания лишних вычислений возможно оптимально выполнять итерации алгоритма последовательно, вычисляя параллельно только векторно-матричные произведения.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для исследования масштабируемости алгоритма была использована параллельная реализация, найденная на просторах GitHub<ref>Parallel GMRES Algorithm for Solving Giant Sparse System of Linear Equations https://github.com/arrgasm/paraGMRES/</ref>. Эта реализация использует многопроцессорное выполнение с общей памятью и вычисляет параллельно скалярное произведение и умножение матрицы на вектор. Программа была запущена на суперкомпьютере BlueGene на разреженной матрице размера 90448х90448 с 1921955 ненулевыми элементами, расположенными около главной диагонали. Параметрами запуска являются 100 итераций алгоритма и 10 перезапусков алгоритм (повторный запуск алгоритма с использованием решения, полученного на предыдущем запуске, в качестве начального приближения). График зависимости времени выполнения от числа процессоров представлен на рисунке 2.
[[file:PlotLvs1.png|thumb|center|400px|Рис 2. График зависимости времени выполнения от числа процессоров]]
График эффективности для полученного времени выполнения указан на рисунке 3.
[[file:PlotLvs2.png|thumb|center|400px|Рис 3. График зависимости эффективности реализации от числа процессоров]]
Параметры компиляции:
<code>mpixlc_r -qsmp=omp -O3</code>

Параметры запуска:
<code>gmres mat.mtx void 100 0 10</code>

Надо заметить, что для этой матрицы на таком числе итераций решения с заданной точностью найдено не было. Она была выбрана с целью показать масштабируемость алгоритма. На матрицах более малого размера решение находится быстро.

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.

2016-12-03T03:13:29Z

Evgeny Mortikov:

{{Assignment|ASA|Evgeny Mortikov}}

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

= Свойства и структура алгоритма =

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными (например, операции вставки и удаления новых коэффициентов), а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

Важным приложением этих алгоритмов является вычисление векторов Ланцоша, необходимое при итерационном решении линейных уравнений методом сопряженных градиентов, а также при вычислении собственных значений и собственных векторов матрицы. Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция - это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

== Макроструктура алгоритма ==

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

== Схема реализации последовательного алгоритма ==

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

== Последовательная сложность алгоритма ==

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

* <math>O(l)</math> сложений,
* <math>O(l)</math> умножений.

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

== Информационный граф ==

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

Первая группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Естественно введённые координаты области таковы:

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

Результат срабатывания операции является ''промежуточным данным'' алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

== Ресурс параллелизма алгоритма ==

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

== Входные и выходные данные алгоритма ==

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

'''Объём выходных данных''': <math>n</math>.

== Свойства алгоритма ==

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейной''.

При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – ''константа''.

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным (в вопросе используемой памяти) для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

Распределение ненулевых и нулевых коэффициентов: 1:1. Однако стоит обратить внимание, что матрица генерировалась случайным образом, а значит, это лишь распределение, а не точное значение.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

= Литература =

Обсуждение участницы:Sannikovats

2016-12-03T02:37:14Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK) В работе нет исследования масштабируемости алгоритма. К содержанию есть несколько замечаний (отмечены моей подписью), помимо необходимости выполнения основных требований к работе.

== Статья [[Участница:Sannikovats/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (1)]] ==

* Не указан вклад обоих авторов
* Информационный граф выглядит странно
** Изображённое на рисунке в разделе 1.7 не является информационным графом. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:38, 8 ноября 2016 (MSK)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:15, 1 ноября 2016 (MSK)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:15, 1 ноября 2016 (MSK)
* Отсутствуют заголовки пунктов 2.2-2.6, соответственно пункт 2.1 должен иметь нумерацию 2.4, а пункт 2.2 должен иметь нумерацию 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 10:39, 8 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:00, 16 ноября 2016 (MSK)

----

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''Существуют различные последовательные методы построения адаптивных подвижных сеток, которые позволяют значительно повысить точность вычисления определенного интеграла за счет учета характера изменения подынтегральной функции.'''

Что подразумевается под «подвижностью сеток» для данного алгоритма?

== Пункт 1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''Но при распараллеливании этого алгоритма (т.е. при запуске попарно подпрограмм, обрабатывающих половинки разбиваемого интервала) можно столкнуться со следующей проблемой: в реальной системе число процессоров ограничено и время, необходимое для порождения параллельных процессов существенно не равно нулю.'''

Это утверждение сильно зависит от того, как реализована рекурсия. Можно столкнуться с такой проблемой, а можно и не столкнуться.

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

Нужно пояснить, что за программный стек, который недоступен программисту? В чем заключается проблема, если эти данные доступны только одному процессу.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''Стек выбран исключительно из соображений простоты реализации. Времена выполнения рассмотренных алгоритмов отличаются примерно на 5% в пользу локального стека, таким образом, алгоритм "локального стека" будем считать наилучшим из имеющихся в нашем распоряжении последовательных методов и на его примере построим дальнейшее описание.'''

Каких алгоритмов и где они рассмотрены? За счет чего образуется выигрыш в 5%? Чем, с точки зрения простоты реализации, стек лучше, по сравнению с очередью?

Все, что написано в разделах 1.1.1 и 1.1.2 сводится к тому, что для реализации рекурсии можно использовать стек. А такую реализацию рекурсии можно (относительно просто) адаптировать под параллельную архитектуру. Разделы написаны крайне путанно, поэтому хорошо бы их переписать.

== Пункт 1.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''<math> |sAB - sACB|\leq \epsilon * |sACB| </math>, что обеспечивает проверку условия устойчивости.'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2?

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''//проверка выполнения условия на порядок точности:'''
'''if(abs(sAB - sACB) >= eps*abs(sACB)) {'''

См. замечание к пункту 1.4

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

В качестве примера нужно привести хотя бы оценки, определяя некоторое разбиение (по возможности в наиболее общем виде) без учета функции.

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

См. п. 1.6.

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

Как задается функция или возможность расчета ее значений в алгоритме и реализации?
Нужно привести размер входных и выходных данных.

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''Рассмотренный алгоритм обладает свойством детерминированности, поскольку при определенных входных данных мы будем получать одинаковый результат.'''

Влияют ли на свойство детерминированности алгоритма выполнение свойства ассоциативности для операции сложения, а также свойства входной функции?

'''Кроме того, алгоритм обладает внутренним параллелизмом, так как является численно устойчивым как в последовательной, так и в параллельной версиях.'''

Как из численной устойчивости следует «обладание внутренним параллелизмом»?
Является ли алгоритм устойчивым для любой входной функции?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

Нет исследования масштабируемости.

== Пункт 2.7 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:37, 3 декабря 2016 (MSK)

'''В настоящее время проблемой вычисления определенного графа на адаптивной сетке по нашим сведениям занимались только М.В. Якобовский и Е.Ю. Кулькова, рассматривавшие в своей работе "РЕШЕНИЕ ЗАДАЧ НА МНОГОПРОЦЕССОРНЫХ ВЫЧИСЛИТЕЛЬНЫХ СИСТЕМАХ С РАЗДЕЛЯЕМОЙ ПАМЯТЬЮ" методы локального и глобального стеков.'''

Наверное, определенного интеграла на адаптивной сетке?

Обсуждение участника:Greno4ka

2016-12-03T02:22:12Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK) Работа не готова. Нет разделов 1.3, 1.4, 1.6-1.8, 1.10, 2.4; нет описания параллельного алгоритма и исследования масштабируемости. Есть несколько замечаний (ниже с моей подписью) к тому, что уже написано, помимо выполнения основных требований к работе

== Статья [[Участник:Greno4ka/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

* Нет краткой сводки свойств алгоритма в начале страницы
* В разделе 1.1 по сути нет описания алгоритма
* Разделы 1.6-1.8 пусты
* В разделах 1.3 и 1.4 хотелось бы видеть понятное словесное описание
* Содержимое раздела 1.4 должно быть внесено в раздел 1.5
* Не указан вклад каждого автора
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:59, 16 ноября 2016 (MSK)

== Пункт 1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

'''в некоторых точках значение функции будет вычисляться несколько раз'''

В каких точках в формуле для приближенного вычисления интеграла функция вычисляется несколько раз? В чем проблема сохранять рассчитанные значения функции и использовать их далее без перерасчета?

== Пункт 1.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

В этом разделе нужно явно описать вычислительное ядро алгоритма.

== Пункт 1.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

Вместо макроструктуры алгоритма здесь приведена реализация структуры данных для стека.

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

'''if (|sAB - sACB| ≥ ε|sACB|) {'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

Как задается входная функция в алгоритме и реализации?
Нужно указать размер входных-выходных данных.

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

Есть ли у алгоритма другие свойства, помимо того, что он адаптируется под заданную функцию?

Обсуждение участника:Greno4ka

2016-12-03T02:20:35Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK) Работа не готова. Нет разделов 1.3, 1.4, 1.6-1.8, 1.10, 2.4; нет описания параллельного алгоритма и исследования масштабируемости. Есть несколько замечаний (ниже с моей подписью) к тому, что уже написано, помимо выполнения основных требований к работе

== Статья [[Участник:Greno4ka/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

* Нет краткой сводки свойств алгоритма в начале страницы
* В разделе 1.1 по сути нет описания алгоритма
* Разделы 1.6-1.8 пусты
* В разделах 1.3 и 1.4 хотелось бы видеть понятное словесное описание
* Содержимое раздела 1.4 должно быть внесено в раздел 1.5
* Не указан вклад каждого автора
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:59, 16 ноября 2016 (MSK)

== Пункт 1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

'''в некоторых точках значение функции будет вычисляться несколько раз'''

В каких точках в формуле для приближенного вычисления интеграла функция вычисляется несколько раз? В чем проблема сохранять рассчитанные значения функции и использовать их далее без перерасчета?

== Пункт 1.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

В этом разделе нужно явно описать вычислительное ядро алгоритма.

== Пункт 1.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

Вместо макроструктуры алгоритма здесь приведена реализация структуры данных для стека.

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

if (|sAB - sACB| ≥ ε|sACB|) {

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

Как задается входная функция в алгоритме и реализации?
Нужно указать размер входных-выходных данных.

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:18, 3 декабря 2016 (MSK)

Есть ли у алгоритма другие свойства, помимо того, что он адаптируется под заданную функцию?

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-03T02:08:05Z

Evgeny Mortikov:

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI. При запусках использовалась связка openmpi/1.8.4-gcc + gcc/5.2.0, реализация - тут -> [https://github.com/Stalles/superprak1 ссылка на реализацию.]

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Обсуждение участника:Stalles

2016-12-03T02:06:42Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK) Хорошее описание метода и алгоритма. Есть несколько замечаний по содержанию и вопросы по исследованию масштабируемости (ниже с моей подписью)

== Пункт 1.2.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту.'''

Что подразумевается под недоступностью стека для программиста, если далее рассматривается работа с этим стеком? Нужно пояснить это утверждение.

== Пункт 1.2.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга.'''

Нужно описать немного подробнее, как из определения стека появляется возможность обрабатывать отрезки независимо друг от друга.

'''Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.'''

Где в работе были перечислены последовательные методы, которые здесь сравниваются? С какой точки зрения локальный стек является наилучшим, по сравнению с ними?

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2.1?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>.'''

Объём равен <math> O\left( 1 \right) </math> - это уже не любой вид представления функции.

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

Есть ли в реализации глобальный стек, который описан в работе?

----

== Статья [[Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

=== Замечания по тексту ===
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
** Граф на рис.1 не является графом алгоритма, как написано в подписи к нему. Граф на рис.2 также является каким-то гибридом информационного графа и графа управления - в частности, содержит ветвления, которых в информационном графе быть не должно. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:57, 14 ноября 2016 (MSK)
* В разделе 1.9 должны быть оценки объёмов входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* В части 2 должны быть все разделы 2.1-2.7 (некоторые могут быть пустыми). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-03T01:52:58Z

Evgeny Mortikov:

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n<sub>1</sub> и n<sub>2</sub> - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Обсуждение участника:Joinmek

2016-12-03T01:50:16Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK) К работе есть несколько замечаний по содержанию (ниже с моей подписью)

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках.'''

Наверное, на отрезках рассчитываются интегралы от новых функций, а их значения уже суммируются?

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2?

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

В качестве примера нужно привести хотя бы оценки, определяя разбиение отрезка (глубину, неравномерность и пр.) без учета функции.

== Пункт 1.7 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.'''

Хорошо бы пояснить в чем достоинства и недостатки такого подхода, по сравнению с тем, что описывается ранее?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

См. пункт 1.6

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''3. В параллельной версии алгоритма не требуется управляющий процесс'''

Нужно здесь уточнить, что рассматривается алгоритм с общей памятью. Будет ли нужен управляющий процесс при реализации глобального стека на системах с распределенной памятью?

'''4. Алгоритм является детерминированным'''

Влияют ли на свойство детерминированности алгоритма выполнение свойства ассоциативности для операции сложения, а также свойства входной функции?

'''7. Данный алгоритм является устойчивым'''

Алгоритм устойчив для любой функции?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

'''Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.'''

То, что данная реализация предназначена для систем с общей памятью, не означает, что она не является масштабируемой.
Почему нет графиков масштабируемости по ядрам одного узла для алгоритма с адаптивной сеткой, где глобальный стек реализован для общей памяти?

== Статья [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2)]] ==

* Нет краткой сводки свойств алгоритма в начале страницы (Исправлено)
* Нумерация подразделов не соответствует шаблону (Исправлено)
* Разделы 1.6 и 1.8 (6 и 8 в оригинальной статье) не заполнены (Исправлено)
* Картинка в разделе 1.7 (7) не является информационным графом (Исправлено)
** Если это информационный граф, из него следует, что алгоритм строго последовательный. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
** Приведённый граф очень мелкий, надписи практически нечитаемы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Раздел 2.7 отсутствует (Исправлено)
* Список литературы отсутствует (Исправлено)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:03, 16 ноября 2016 (MSK) (Исправлено)
* Рисунки в статье не подписаны и не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)

Обсуждение участника:Макарова Алёна

2016-12-03T01:32:54Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK) Хорошее и подробное описание метода GMRES. К сожалению, значительно меньше внимания уделено алгоритмическим особенностям, а исследования масштабируемости в работе нет. Есть несколько замечаний по содержанию, которые отмечены моей подписью.

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:13, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

= Пункт 1.2.3 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

'''Но об этом не верно говорить в общем. Согласно теореме (Greenbaum, Pták and Strakoš), для каждой монотонной последовательности <math> a_1,..., a_{m-1}, a_m = 0 </math>, найдётся матрица <math>A</math> такая что <math>||r_n|| = a_n</math> для всех <math>n</math>, где <math>r_n</math> невязка, определенная ранее.'''

Хорошо бы поставить ссылку на этот результат и указать работу в списке литературы. Чему здесь соответствует индекс <math>n</math> – номеру итерации?

Опечатка для границ <math>i</math>:
<math>
\mathcal{K}_i = span \{ e_n, e_{n-1}, ..., e_{n-i+1}\}, i \le i \le n
</math>

= Пункт 1.2.3.2 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

Опечатка: '''Если матрица <math>A</math> является симметрично ...'''

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

'''Пусть несимметричная матрица <math>A</math> имеет симметричный портрет и число ненулевых элементов в нижнем(верхнем) треугольнике равно <math>k</math>.'''

Зачем здесь нужно требование о симметричном потрете матрицы? Можно ли записать оценки для разреженной матрицы без этого условия?

= Пункт 1.7 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

Нужно привести более подробное описание графа, принятых обозначений и т.п. Рассматривается ли здесь разреженная матрица, для которой приведены оценки сложности последовательного алгоритма в пункте 1.6?

= Пункт 1.8 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

Опечатка: '''при вычислении невязок матрича ...'''
Опечатка: '''вычисления скалярных проихведений ...'''

В разделе рассматриваются 2 «интенсивных в вычислительном плане этапа», а граф в 1.7 строится только для умножения матрицы на вектор. С чем это связано?

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

'''Для систем с разряженной матрицей алгоритм требует гораздо меньшей вычислительной мощности.'''

Хорошо бы привести оценки в работе как для плотной, так и для разреженной матрицы, чтобы проиллюстрировать данное утверждение

'''Одной из важных практических особенностей метода является то, что на первых итерациях метод сходится гораздо быстрее, чем асимптотически. Для ускорения сходимости метода минимальных невязок целесообразно время о времени использовать один шаг двух-шагового метода минимальных невязок.'''

То, что целесообразно использовать один шаг двух-шагового метода минимальных невязок нужно описать подробнее. Что здесь понимается под двух-шаговым методом GMRES? Почему выполнение только одного шага дает выигрыш – нужны пояснения и/или ссылки.

= Пункт 2.3.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

'''При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры.'''

В чем рациональность такого подхода для тех задач, в которых размерность вектора не помещается в памяти?

'''Если процессор хранит строку матрицы и одиночные элементы векторов правой части и начального приближения, то общее число сохраняемых элементов имеет порядок . Если же процессор хранит строку матрицы и все элементы векторов, то общее число сохраняемых элементов также порядка .'''

Величина для "порядка" пропущена.

'''Таким образом, при дублировании и при разделении векторов требования к объему памяти из одного класса сложности.'''

Это утверждение нужно переформулировать и пояснить. Что здесь понимается под классом сложности?

= Пункт 2.3.2 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

'''нахождение взвешенной суммы векторов''' – линейной комбинации векторов?

= Пункт 2.3.3 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

Требуется ли выполнение объединений на каждой итерации метода?

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

Нет исследования масштабируемости

= Пункт 2.7 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:32, 3 декабря 2016 (MSK)

Опечатка: '''Список пакетов, в которых присутствует реализация методА минимизации обобщенной невязки:'''

Обсуждение участника:Анюшева Ирина

2016-12-03T01:10:12Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK) К работе есть несколько замечаний по содержанию (отмечены моей подписью), помимо выполнения требований к работе

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:13, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

----

= Пункт 1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком.'''

Что здесь подразумевается по «минимальным остатком»?

'''Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем.'''

Чем GMRES эффективнее с вычислительной точки зрения, например, других итерационных Крыловских методов для несимметричных матриц?

'''Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости.'''

Нужно пояснить, что подразумевается под ошибкоустойчивостью метода? Причем здесь параметр релаксации? Обычно вместо «суперлинейной сходимости», пишут сверхлинейная сходимость. Хорошо бы выделить класс методов, с которыми сравнивается GMRES в плане эффективности и преимуществ. Так, например, стабилизированный метод бисопряженных градиентов также «допускает эффективное распараллеливание и не требует нахождения параметра релаксации».

'''Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций.'''

Сохраняются ли преимущества метода для версии метода GMRES с рестартами? Например, сверхлинейная сходимость и ошибкоустойчивость? Свойства (достоинства и недостатки) GMRES(m) лучше описать подробнее.

Опечатка - '''подоразумевающая перезапуск метода каждые m итераций'''

= Пункт 1.2.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно уточнить какая норма здесь рассматривается. Также в нескольких местах (в этом и следующих разделах) при записи нормы пропущена одна правая вертикальная скобка.

= Пункт 1.5.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Выбрать произвольное <math>x_0</math>;'''

Для любого <math>x_0</math> достигается сходимость?

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно дополнить раздел оценками для разреженной матрицы по числу ненулевых элементов.

= Пункт 1.7 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Хорошо бы подробнее описать структуру алгоритма в блоках ортогонализации и минимизации невязки.

= Пункт 1.8 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки.'''

Можно ли рассматривать декомпозицию матрицы по «двумерным» блокам, а не только по строкам?

'''Обработка вектора решения дублируется на всех процессах.'''

В практических задачах размерность вектора решения может быть очень большой и не помещаться в память процессора. Как предлагается решать такие задачи? Если такие задачи не рассматриваются, то это нужно явно прописать.

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение'''

Нужно привести такие примеры и описать подробнее данные случаи или указать ссылку на работу, где такие примеры построены.

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно описать структуру матрицы, которая рассматривалась в экспериментах. Какое условие на выход из итерационного процесса использовалось в расчетах?

С чем связана такая низкая эффективность реализации?

'''Из рисунков видно, что при увеличении количества процессов, а также при увеличении размерности задачи, производительность параллельной реализации алгоритма уменьшается, что говорит о плохой масштабируемости.'''

Нужно объяснить в чем причина плохой масштабируемости алгоритма. Особенно с учетом того, что в разделе 1.1 Вы пишите о том, что метод GMRES «допускает эффективное распараллеливание».

----

Обсуждение участника:Анюшева Ирина

2016-12-03T01:06:14Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK) К работе есть несколько замечаний по содержанию (отмечены моей подписью), помимо выполнения требований к работе

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:13, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

----

= Пункт 1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Обобщенный метод минимальных невязок (GMRES) для решения системы линейных алгебраических уравнений аппроксимирует решение с помощью вектора в подпространстве Крылова с минимальным остатком.'''

Что здесь подразумевается по «минимальным остатком»?

'''Метод по праву считается одним из самых эффективных численных методов решения несимметричных систем.'''

Чем GMRES эффективнее с вычислительной точки зрения, например, других итерационных Крыловских методов для несимметричных матриц?

'''Метод обобщенных минимальных невязок популярен из-за наличия ряда преимуществ: он ошибкоустойчив, допускает эффективное распараллеливание, не требует нахождения параметра релаксации, обладает суперлинейной скоростью сходимости.'''

Нужно пояснить, что подразумевается под ошибкоустойчивостью метода? Причем здесь параметр релаксации? Обычно вместо «суперлинейной сходимости», пишут сверхлинейная сходимость. Хорошо бы выделить класс методов, с которыми сравнивается GMRES в плане эффективности и преимуществ. Так, например, стабилизированный метод бисопряженных градиентов также «допускает эффективное распараллеливание и не требует нахождения параметра релаксации».

'''Зато широкое распространение получила перезапускаемая версия метода, подоразумевающая перезапуск метода каждые m итераций.'''

Сохраняются ли преимущества метода для версии метода GMRES с рестартами? Например, сверхлинейная сходимость и ошибкоустойчивость? Свойства (достоинства и недостатки) GMRES(m) лучше описать подробнее.

Опечатка - '''подоразумевающая перезапуск метода каждые m итераций'''

= Пункт 1.2.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно уточнить какая норма здесь рассматривается. Также в нескольких местах (в этом и следующих разделах) при записи нормы пропущена одна правая вертикальная скобка.

= Пункт 1.5.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Выбрать произвольное <math>x_0</math>;'''

Для любого <math>x_0</math> достигается сходимость?

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно дополнить раздел оценками для разреженной матрицы по числу ненулевых элементов.

= Пункт 1.7 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Хорошо бы подробнее описать структуру алгоритма в блоках ортогонализации и минимизации невязки.

= Пункт 1.8 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Для нахождения матрично-векторных произведений при вычислении невязок матрица СЛАУ должна быть подвергнута декомпозиции на строчные блоки, размеры которых определяются требованиями равномерности загрузки.'''

Можно ли рассматривать декомпозицию матрицы по «двумерными» блокам, а не только по строкам?

'''Обработка вектора решения дублируется на всех процессах.'''

В практических задачах размерность вектора решения может быть очень большой и не помещаться в память процессора. Как предлагается решать такие задачи? Если такие задачи не рассматриваются, то это нужно явно прописать.

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

'''Однако, есть примеры, в которых видно, что первые <math>m-1</math> итераций дают невязку, равную некой константе, а на итерации под номером <math>m</math> получаем точное решение'''

Нужно привести такие примеры; описать подробнее или указать ссылку на работу, где такие примеры построены.

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:05, 3 декабря 2016 (MSK)

Нужно описать структуру матрицы, которая рассматривалась в экспериментах. Какое условие на выход из итерационного процесса использовалось в расчетах?

С чем связана такая низкая эффективность реализации?

'''Из рисунков видно, что при увеличении количества процессов, а также при увеличении размерности задачи, производительность параллельной реализации алгоритма уменьшается, что говорит о плохой масштабируемости.'''

Нужно объяснить в чем причина плохой масштабируемости алгоритма. Особенно с учетом того, что в разделе 1.1 Вы пишите о том, что метод GMRES «допускает эффективное распараллеливание».

----

Участник:Alexander34396/Обобщенный метод минимальных невязок

2016-12-02T02:47:53Z

Evgeny Mortikov:

Основные авторы описания: [[#Участник:Alexander34396|А.А.Ульянов]] (разделы [[#Общее описание алгоритма|1.1]], [[#Математическое описание алгоритма|1.2]], [[#Вычислительное ядро алгоритма|1.3]], [[#Макроструктура алгоритма|1.4]], [[#Схема реализации последовательного алгоритма|1.5]], [[#Последовательная сложность алгоритма|1.6]], [[#Входные и выходные данные алгоритма|1.9]], [[#Существующие реализации алгоритма|2.7]]), [[#Участник:Kpetrov|К.Петров]] (разделы [[#Информационный граф|1.7]], [[#Ресурс параллелизма алгоритма|1.8]], [[#Свойства алгоритма|1.10]], [[#Масштабируемость алгоритма и его реализации|2.4]]).

{{algorithm
| name = Обобщенный метод минимальных невязок
| serial_complexity = <math> O(nm^2) </math>
| input_data = <math> (n + 1)^2 </math>
| output_data = <math> n </math>
}}

= Свойства и структура алгоритмов =

== Общее описание алгоритма ==

'''Обобщённый метод минимальных невязок''' ({{lang-en|Generalized minimal residual method, GMRES}}) - итерационный метод численного решения системы линейных алгебраических уравнений с невырожденной матрицей. Метод основан на минимизации квадратичного функционала невязки на подпространствах Крылова. Разработан Юсефом Саадом и Мартином Шульцем<ref> Y.Saad, M.H. Schultz, GMRES: A generalized minimal residual algorithm for solving nonsymmetric linear systems, SIAM J. Scientific and Stat. Comp. 7: 856-869 (1986) </ref> в 1986 году как обобщение метода MINRES<ref>C. C. Paige and M. A. Saunders. Solution of sparse indefinite systems of linear equations, SIAM J. Numerical Analysis 12, 617-629 (1975)</ref> на случай систем с несимметричными матрицами.

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

'''Исходные данные:'''
* система линейных алгебраических уравнений вида <math> Ax = b </math>, где <math> A </math> — невырожденная матрица размера <math>n</math>-на-<math> n </math>;
* <math> x_0 </math> - начальное приближение.
'''Вычисляемые данные:'''
* <math> x_m </math> - приближённое решение исходной системы.

Метод GMRES приближает точное решение исходной системы <math> Ax = b </math> вектором <math> x_m </math>, который минимизирует Евклидову норму невязки <math> r_m = Ax_m - b</math> на подпространстве Крылова:
: <math> K_m = K_m(A,b) = \operatorname{span} \, \{ b, Ab, A^2b, \ldots, A^{m-1}b \} </math>, где <math> \operatorname{span} \, \{ a_1, a_2, \ldots, a_m \} </math> - линейная оболочка системы векторов <math> \{ a_1, a_2, \ldots, a_m \} </math>.

На каждой итерации метода решение уточняется поправкой, представленной в виде разложения по ортонормированному базису пространства <math> K_m </math>:
: <math> x_m = x_0 + z_m </math>, где <math> x_0 </math> - некоторое начальное приближение, <math> z_m \in K_m </math> - поправка решения.

=== Ортогонализация Арнольди ===

Для построения ортонормированного базиса <math> v_1, v_2, \ldots, v_m </math> пространства Крылова <math> K_m </math> метод использует процесс Арнольди.

Идея процесса Арнольди состоит в том, что для нахождения вектора <math> v_{j+1} </math> при известных векторах <math> v_1, v_2, \ldots, v_j </math> необходимо вычислить вектор <math> Av_j </math> и ортонормировать этот вектор относительно <math> v_1, v_2, \ldots, v_j </math>:
: <math> v_{j+1} = \frac{\hat{v}_{j+1}}{\|\hat{v}_{j+1}\|_2} </math>, где <math> \hat{v}_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>.

Коэффициенты <math> h_{ij} = (Av_j, v_i) </math> определяются из условия ортогональности:
: <math> A(v_j, v_k) - \sum_{i=1}^j h_{ij}(v_{i}, v_k) = 0 </math>, где <math> \quad k=1,\ldots,j </math>.

Результат процедуры Арнольди совпадает с результатом процесса Грамма-Шмидта, применённого к векторам <math> \{b, Ab, A^2b, \ldots, A^{m-1}b\} </math>.

'''Исходные данные:'''
* <math> v_1 </math>, такой что <math> \|v_1\|_2 = 1 </math>;
* матрица <math> A </math> размером <math> n </math>-на-<math> n </math>.

'''Вычисляемые данные:'''
* <math> v_1, v_2, \ldots, v_m </math> - ортонормированный базис пространства Крылова <math> K_m </math>.

'''Алгоритм процесса:'''

Выполнять для <math> \quad j=1,\ldots,m </math>:
# <math> h_{ij} = (Av_j, v_i), \quad i=1,\ldots,j </math>;
# <math> \hat{v}_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>;
# <math> h_{j+1j} = \|\hat{v}_{j+1}\|_2 </math>;
# <math> v_{j+1} = \frac{\hat{v}_{j+1}}{h_{j+1j}} </math>.

'''При введении матричных обозначений можно записать:'''

Поправка решения:
: <math> z_m = V_my_m </math>, где <math> y_m \in \mathbb{R}^m </math> - вектор коэффициентов, <math> V_m = [v_1|v_2|...|v_m] </math>.

Матричное представление процесса Арнольди:
: <math> AV_m = V_{m+1}H_{m+1m} = V_mH_m + h_{m+1m}v_{m+1} e_m^T </math>,
где
: <math>H_{m+1m} = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>
- верхняя матрица Хессенберга размерности <math> m+1 </math> на <math> m </math>.

=== Минимизация функционала невязки ===

Невязка исходной системы имеет вид:
: <math> r_m = b - A(x_0 + z_m) = r_0 - AV_my_m = \beta v_1 - V_{m+1}H_{m+1m}y_m</math>, где <math> \beta = \|r_0\|_2</math>.

C учетом того, что матрица <math> V_{k+1} </math> составлена из ортонормированных векторов:
: <math> r_m = \beta V_{m+1}e_1 - H_{m+1m}y_m</math>, где <math> e_1 = (1,0,0,\ldots,0)^T </math>.

Норма невязки <math> r_m </math>:
: <math> \|r_m\|_2 = \|\beta e_1 - H_{m+1m}y_m\|_2 </math>.

Норма <math> \|r_m\|_2 </math> достигает минимума при <math> \beta e_1 = H_{m+1m}y_m </math>.

Для нахождения решения такой системы, матрица <math> H_{m+1m} </math> приводится к верхнему треугольному виду с помощью <math> m </math> последовательных [[Метод_Гивенса_(вращений)_QR-разложения_квадратной_матрицы_(вещественный_вариант)|вращений Гивенса]].

=== Общая схема метода ===

В общем виде m-aя итерация алгоритма GMRES может быть записан следующим образом:

# найти ортонормированный базис <math> V_m </math> подпространства <math> K_m </math> с помощью ортогонализации Арнольди;
# найти <math> y_m </math>, минимизирующий <math> \|r_m\|_2 </math>;
# вычислить <math> x_m = x_0 + V_my_m </math>, где <math> x_0 </math> - начальное приближение;
# вычислить <math> r_m </math> и остановиться,если требуемая точность была достигнута, иначе повторить.

== Вычислительное ядро алгоритма ==

Вычислительное ядро последовательной версии метода GMRES состоит из двух частей:
* Вычисление ортонормированного базиса <math> K_m </math>;
* Формирование приближенного решения <math> x_m </math>.

Для вычисления ортонормированного базиса <math> K_m </math> метод использует процесс Арнольди:
: <math> h_{j+1j}v_{j+1} = Av_j - \sum_{i=1}^j h_{ij}v_{j} </math>, где <math> h_{ij} = (Av_j, v_i)</math>, <math> \quad j=1,\ldots,m </math>.

Для нахождения приближённого решения <math> x_m </math> метод использует формулу:
: <math> x_m = x_0 + V_my_m </math>.

== Макроструктура алгоритма ==

В алгоритме можно выделить следующие макрооперации:

* Умножение матрицы на вектор;
* Вычисление скалярного произведения векторов;
* Вычисление Евклидовой нормы вектора;
* Умножение вектора на скаляр;
* Деление вектора на скаляр.

== Схема реализации последовательного алгоритма ==

На практике используется перезапускаемая версия метода - GMRES(m):

'''1 Подготовка перед итерационным процессом:'''
:1.1 Выбрать начальное приближение <math> x_0 </math>;
:1.2 Посчитать невязку <math> r_0 = b - Ax_0 </math>;
:1.3 Вычислить <math> v_1 = \frac{r_0}{\|r_0\|_2} </math>.

'''2 Построение ортонормированного базиса <math> K_m </math>:'''

: Для всех <math> j </math> от 1 до m по нарастанию выполнять:
:2.1 <math> h_{ij} := (Av_j, v_i), \quad i=1,\ldots,j </math>;
:2.2 <math> \hat{v}_{j+1} := Av_j - \sum_{i=1}^j h_{ij}v_{i} </math>;
:2.3 <math> h_{j+1j} = \|\hat{v}_{j+1}\|_2 </math>;
:2.4 <math> v_{j+1} = \frac{\hat{v}_{j+1}}{h_{j+1j}} </math>.

'''3 Вычисление <math> x_m </math>:'''
:3.1 <math> x_m = x_0 + V_my_m </math>, где <math>y_m</math> минимизирует <math>\|r_0 - AV_my_m\|_2</math>;
:3.2 Вычислить <math> r_m </math>;
:3.3 Если требуемая точность достигнута, остановиться.

'''4 Перезапуск:'''
:4.1 <math>x_0 = x_m</math>;
:4.2 <math>v_1 = \frac{r_m}{\|r_m\|_2}</math>;
:4.3 Перейти к шагу 2.

== Последовательная сложность алгоритма ==

Если пренебречь сложностью вычисления <math> y_m </math>, то общую сложность алгоритма GMRES можно разделить на две части:

'''1. Сложность вычисления ортонормированного базиса пространства <math> K_m </math>:'''
:a) Для вычисления <math> j </math>-го вектора базиса <math> K_m, j < m </math> требуется:
:: <math> NZ + (2j + 1)n </math> мультипликативных операций, где <math> NZ </math> - количество ненулевых элементов матрицы <math> A </math>.
:b) Вычисление последнего вектора базиса требует:
:: <math> n(m + 1) </math> мультипликативных операций.
:c) Общая мультипликативная сложность вычисления ортонормированного базиса <math> K_m </math>:
:: <math> O(nm^2) </math>.

'''2. Сложность вычисления приближённого решения <math> x_m </math>:'''
:a) Вычисление этой формулы требует <math> nm </math> мультипликативных операций.

== Информационный граф ==

[[File: Drawing.png|thumb|center|350px|'''Рис. 1'''
'''input''' - входные данные алгоритма (квадратная матрица, вектор правой части, начальное приближение, точность решения);
'''<math> A_i </math>''' - шаги алгоритма Арнольди, <math> x_i </math> - нахождение невязки на <math> i </math>-ой итерации;
'''if''' - вычисление <math> r_m </math> и в случае достижения нужной точности - остановка.]]
Шаги алгоритма Арнольди выполняются строго последовательно, но вычисление <math> i </math>-ой невязки может происходить параллельно
с <math> (i + 1) </math>-ым шагом алгоритма Арнольди.

== Ресурс параллелизма алгоритма ==

В ходе анализа перезапускаемого метода обобщенных минимальных невязок был выявлен ряд подзадач, выполняющихся неоднократно: умножение матрицы на вектор, вычисление скалярного произведения векторов, нахождение нормы вектора, нормирование вектора, нахождение взвешенной суммы векторов. Наиболее трудоемкой среди перечисленных операций является умножение матрицы на вектор.

Выполнение перечисленных операций занимает большую часть времени работы алгоритма GMRES. Поэтому при увеличении эффективности использования вычислительных ресурсов и ресурсов памяти вычислительной машины при выполнении этих операций повышается эффективность метода в целом. Достигается это применением при выполнении перечисленных операций аппарата параллельных вычислений.

При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры. Для рассматриваемой задачи решения СЛАУ такой подход распределения допустим, т.к. векторы содержат столько же элементов, сколько и одна строка или один столбец матрицы коэффициентов.

Подзадачи можно разделить на 2 группы: операции между матрицей и вектором (например, умножение матрицы на вектор) и операции между двумя векторами (например, скалярное умножение). Подзадачи умножения константы на вектор и определение нормы вектора можно относить ко второй группе, так как их трудоемкость одного порядка.

Результатом выполнения рассматриваемых операций является, вектор, части которого расположены на участвовавших в вычислениях процессорах. Для объединения результатов расчета и получения полного вектора на каждом процессоре вычислительной системы необходимо выполнить операцию сбора данных.

== Входные и выходные данные алгоритма ==

'''Входные данные:'''
* <math> A </math> – квадратная матрица размера <math> n </math>-на-<math> n </math>;
* <math> b </math> – вектор правой части размера <math> n </math>;
* <math> x_0 </math> – начальное приближение размера <math> n </math>;
* <math> \epsilon </math> – погрешность решения.

'''Для перезапускаемой версии алгоритма дополнительно:'''
* <math> m </math> – число итераций.

'''Объём входных данных''': <math> n^2 + 2n + 1 </math>.

'''Выходные данные''':
* <math> x_m </math> - вектор приближённого решения размера <math> n </math>.

'''Объём выходных данных''': <math> n </math>.

== Свойства алгоритма ==

Обобщенный метод минимальных невязок предназначен для решения несимметричных систем линейных уравнений. GMRES использует перезазапуски для контроля требований к хранению данных.

Если используется неперезапускаемый метод, GMRES будет сходиться за не более <math> n </math> шагов. Но это не имеет практического применения, когда <math> n </math> велико. Кроме того, требования к памяти и вычислениям при отсутствии перезапусков являются очень высокими. Важнейшим элементом для успешного применения <math> GMRES(m)</math> являются перезапуски; то есть выбор <math> m </math>. Существуют примеры, для которых метод застаивается и сходимость есть только на <math>m</math>-м шаге. Для таких систем, любой выбор <math> m </math> меньше, чем <math> n </math> - не сходится.

Основным недостатком GMRES является то, что объемы работ и ресурсы памяти, требуемые для итерации, линейно возрастают с увеличением числа итераций. Если не удалось получить чрезвычайно быструю сходимость - затраты будут очень высокими. Основной способ преодолеть это ограничение - это перезапуск итерации. После выбранного числа итераций <math> m </math> накопленные данные будут очищены и промежуточные результаты используются в качестве входных данных для последующих итераций. Эта процедура повторяется до тех пор, пока сходимость не будет достигнута. Трудность заключается в выборе подходящего значения <math> m </math>. Если <math> m </math> слишком мало, <math>GMRES(m)</math> может быть медленно сходиться, или не сойтись совсем. Значение <math> m </math>, большее, чем это необходимо, включает в себя чрезмерную работы и использует больше памяти. К сожалению, нет определенных правил, регулирующих выбор <math> m </math>; выбирая , когда делать перезапуск - это вопрос опыта.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

Масштабируемость рассматривалась в работах <ref>https://arxiv.org/pdf/1606.08740.pdf</ref> и <ref>https://smartech.gatech.edu/bitstream/handle/1853/55635/PRATAPA-DISSERTATION-2016.pdf</ref>.
Для исследования масштабируемости была использована параллельная реализация с использованием объекта KSP(решатель СЛАУ) бибилиотеки PETSc(содержащей структуры, типы данных и подпрограммы для параллельной реализации методов на подпространствах Крылова), найденная на GitHub <ref>https://github.com/erdc-cm/petsc-dev/tree/master/src/ksp/ksp/impls/gmres</ref>.

Вычисления проводились на вычислительном кластере, состоящем из 16 узлов, со следующей конфигурацией:
Altus 1804i Server - 4P Interlagos Node, Quad AMD Opteron 6276, 16C,
2.3 GHz, 128GB, DDR3-1333 ECC, 80GB SSD, MLC, 2.5" HCA, Mellanox ConnectX 2, 1-port QSFP, QDR, memfree, CentOS, Version 5.

На рис. 2 представлен график сильной масштабируемости.

[[File:scaling.JPG|thumb|center|500px|'''Рис. 2''' Зависимость производительности от числа процессоров (запуск производился на 1, 8, 27, 64, 216, 512, 1000 процессорах)]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Реализации алгоритма GMRES присутствуют во многих программных пакетах:
* [http://www.netlib.org/linpack/ LINPACK]
* [http://math.nist.gov/tnt/download.html/ JAMA/C++]
* [http://math-atlas.sourceforge.net/ ATLAS]
* [http://software.intel.com/mkl‎/ Intel MLK]
* [http://math.nist.gov/iml++/ IML++]
* [http://netlib.org/lapack/ LAPACK]
* [http://osl.iu.edu/research/mtl/ MTL]
* [http://www-users.cs.umn.edu/~saad/software/SPARSKIT/ SPARSKIT]
* [http://researcher.watson.ibm.com/researcher/view_group.php?id=1426 WSMP]

= Литература =
<references \>

Обсуждение участника:Alexander34396

2016-12-02T02:43:01Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK) К вашей работе есть несколько замечаний по содержанию и вопросы по пункту с масштабируемостью. Новая серия замечаний стоит с моей подписью.

----

== Пункт 1.2.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

'''вычислить <math> r_m </math> и остановиться,если требуемая точность была достигнута, иначе повторить.'''

Как здесь предлагается оценивать достижение требуемой точности?

== Пункт 1.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

'''Умножение вектора на скаляр;'''

'''Деление вектора на скаляр.'''

В чем с вычислительной точки зрения принципиальная разница между умножением и делением вектора на скаляр? Деление всегда можно записать в виде умножение на обратную величину.

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

'''На практике используется перезапускаемая версия метода - GMRES(m):'''

Более распространенное название – версия GMRES с рестартами. Хорошо бы в этом разделе пояснить, почему «на практике используется» именно такая версия.

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

'''Если пренебречь сложностью вычисления <math> y_m </math>, то общую сложность алгоритма GMRES можно разделить на две части:'''

Нужно пояснить почему сложностью расчета <math> y_m </math> можно пренебречь.

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

'''...нахождение взвешенной суммы векторов.''' Линейная комбинация векторов?

'''Поэтому при увеличении эффективности использования вычислительных ресурсов и ресурсов памяти вычислительной машины при выполнении этих операций повышается эффективность метода в целом. Достигается это применением при выполнении перечисленных операций аппарата параллельных вычислений.'''

Этот абзац не понятен и его нужно переформулировать. Например, применение параллельных вычислений не обязательно приводит к эффективности использованию вычислительных ресурсов.

'''При выполнении параллельного алгоритма решения систем линейных алгебраических уравнений необходимо распределить входные данные наиболее рациональным способом. Матрица коэффициентов разбивается на непрерывные горизонтальные полосы. Распределение вектора правой части и начального приближения выполнено по принципу дублирования, т.е. все элементы векторов скопированы на все процессоры.'''

Почему данный подход является «наиболее рациональным»? Например, n (размер вектора) может быть очень большим и вектор не будет помещаться в память одного процессора.

'''Результатом выполнения рассматриваемых операций является, вектор, части которого расположены на участвовавших в вычислениях процессорах. Для объединения результатов расчета и получения полного вектора на каждом процессоре вычислительной системы необходимо выполнить операцию сбора данных.'''

Требуются ли сборки данных в таком подходе на каждой итерации метода?

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

'''Если используется неперезапускаемый метод, GMRES будет сходиться за не более <math> n </math> шагов.'''

Будет просто сходиться с некоторой точностью, или в точной арифметике – это прямой метод за n шагов?

'''Существуют примеры, для которых метод застаивается и сходимость есть только на <math>m</math>-м шаге. Для таких систем, любой выбор <math> m </math> меньше, чем <math> n </math> - не сходится.'''

Т.е. за n-1 шагов ошибка может быть сколь угодно большой? Нужно привести пример, ссылку или пояснить – в каком случае метод не сходится менее чем за n шагов?

Опечатка - '''включает в себя чрезмерную работы'''

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:42, 2 декабря 2016 (MSK)

Запускалась ли данная реализация GMRES в PETSc самостоятельно на указанном кластере?

C чем связано то, что авторы работы [3] из списка литературы получили практически точно такой же график масштабируемости, но для предобусловленного метода GMRES, с помощью той же библиотеки PETSc и на том же самом кластере?

Соответствует ли разбиение входных данных по параллельным процессам в реализации PETSc тому, что приведено в пункте 1.8? Описание алгоритма и то, что тестируется должно быть согласовано. Входит ли в замер времени счета описанная в пункте 1.8 сборка вектора решения на управляющем процессоре?

Нужно также указать размерность задачи, описать структуру матрицы в экспериментах, условие на окончание итерационного процесса.

----

Добрый день. Начал проверять статью и оставил следующие заметки

Здравствуйте. Немного исправил статью, исходя из ваших замечаний.

= 1.2 =
На мой взгляд, нужны определения
span?
l2-норма?

: [[Участник:Alexander34396|Alexander34396]] Дано пояснение обозначения span.Вместо l2-норма теперь используется Евклидова норма.

= 1.2.1 =
Вот я читаю этот раздел как человек со стороны и вижу много формул. Почему они именно такие? В чем суть этого алгоритма?

: [[Участник:Alexander34396|Alexander34396]] Перед алгоритмом добавлено описание идеи алгоритма и пояснения к формулам.

= 1.2.2 =
Новые определения

: [[Участник:Alexander34396|Alexander34396]] Добавлены некоторые пояснения.Добавлена ссылка на статью - вращения Гивенса.

Затем я остановился, и у меня главные вопрос. Возможно ли сделать статью такой, чтобы для ее прочтения не требовалось обращаться к куче дополнительных источников? Вот я человек со стороны, хотя и заканчивал мехмат. Я могу разобраться со всем написанным здесь, но для этого мне придется гуглить кучу материалов. Но, насколько я понимаю, цель таких статей - быть более полными.

: [[Участник:Alexander34396|Alexander34396]] На мой взгляд, формат статей algo-wiki не подразумевает подробных объяснений и выводов формул, поэтому я добавил только некоторые пояснения, которые делают повествование более последовательным и несколько более понятным. При этом для полного понимания описанного метода для человека со стороны всё равно придётся обращаться к сторонним источникам.

Можете или добавить объяснений или возразить мне. В любом случае, пока с прочтением остановился, жду ответа или исправление (а лучше и того, и другого)

= 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 19:09, 30 ноября 2016 (MSK) '''принято'''

Участник:Lvs/Итерационный метод решения системы линейных алгебраических уравнений GMRES

2016-12-02T02:19:44Z

Evgeny Mortikov:

= Свойства и структура алгоритмов =
== Общее описание алгоритма ==
Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения. Метод основан на процессе Арнольди, посредством которого матрица СЛАУ приводится к (верхней) хессенберговой форме.

== Математическое описание алгоритма ==
Дана система линейных алгебраических уравнений <math>Ax = b</math>, где <math>A</math> - квадратная матрица размера <math>n \times n</math>.

Вычисляется последовательность приближённых решений уравнения <math> x_m </math>, которая сходится к точному решению уравнения <math>x^*</math>.

Подпространство Крылова размерности <math>m</math>, порожденное вектором <math>b</math> и матрицей <math>A</math> – линейное пространство
<math>K_m(A, v)</math>, являющееся линейной оболочкой векторов <math>b, Ab, A^2b, ..., A^{m-1}b</math>.

Приближённое решение считается по формуле <math> x_m = Q_my_m</math>, где <math>Q_m</math> - матрица размера <math>n \times m</math>, составленная из векторов ортонормированного базиса пространства <math>K_m(A, v)</math>, <math>y_m \in \mathbb{R}^m</math>.

Итоговым считается решение, минимизирующее норму невязки (<math>||r||_2 = ||b - Ax_m||_2</math>) с заданной точностью.

Для вычисления векторов ортонормированного базиса используется алгоритм Арнольди:
<source>
q[1] = b/||b||
for j = 1, ..., n-1 do
z = Aq[j]; //очередной вектор
for i = 1,..., j do
h[i][j] = (z, q[i]);
z = z − h[i][j]q[i];
end i
h[j+1][j] = ||z||;
if (h[j+1][j] == 0) break;
q[j+1] = z/h[j+1][j];
end j
</source>
Сложность алгоритма <math>O(n^2)</math>.

На каждом шаге алгоритма получаются векторы <math>q_1, q_2, ..., q_m</math>, являющиеся ортонормированным базисом Крыловского пространства <math>K_m(A, b)</math>.

Значения <math>h_{i,j}</math> образуют верхнюю матрицу Хессенберга (обозначим как <math>H_m</math>, размерность <math>m+1 \times m</math>).

<math>H_k = \begin{bmatrix}h_{11} & h_{12} & h_{13} &... & h_{1m-1} & h_{1m} \\ h_{21} & h_{22} & h_{23} & ... & h_{2m-1} & h_{2m} \\ 0 & h_{32} & h_{33} &...& h_{3m-1} & h_{3m} \\ ... & ... & ... & ... & ... & ... \\ 0 & 0 & 0 & ... & h_{m m-1} & h_{mm} \\0 & 0 & 0 & ... & 0 & h_{m+1 m}\end{bmatrix}</math>.

Вектор невязки задан уравнением <math>r_m = H_my_m - ||b - Ax_0||e_1</math>, где <math>x_0</math> - вектор начального приближения. Минимизация второй нормы вектора невязки представляет из себя решение линейной задачи минимальных квадратов размера <math>n</math>.

Приближённое решение вычисляется по формуле <math> x_m = Q_my_m</math> после нахождения соответствующего значения минимизирующего вторую невязку вектора. Сложность вычислений <math>O(nm)</math>
== Вычислительное ядро алгоритма ==
Самая трудоёмкая и самая часто вызываемая операция в алгоритме - умножение матрицы на вектор. В первую очередь это связано с вычислением матрицы Хессенберга.
== Макроструктура алгоритма ==
# Алгоритм Арнольди
# Решение линейной задачи минимальных квадратов
# Вычисление решения
== Схема реализации последовательного алгоритма ==
<source>
Вычислить ортонормированный базис размера m
Вычислить минимальное приближение
if (приближение < заданная точность)
Вычислить результат
return;
else
Повторить для m = m+1
</source>
== Последовательная сложность алгоритма ==
Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.

Сложность решения задачи минимальных квадратов <math>O(m^2)</math>, но при последовательном выполнении алгоритма можно понизить сложность до <math>O(m)</math> путём использования подсчитанных на прошлых итерациях значений.

Сложность вычисления решения <math>O(nm)</math>, поэтому его целесообразно вычислять только в конце.
== Информационный граф ==
Основной ресурс параллелизма - умножение матрицы на вектор, поскольку является самым ресурсоёмким, но при этом умножать отдельные строки матрицы можно независимо друг от друга. Для этой операции информационный граф представлен на рисунке.

[[file:GraphLvs2FM.jpg|thumb|center|700px|Рис.1. Информационный граф умножения матрицы на вектор]]

== Ресурс параллелизма алгоритма ==
# Параллельное умножение матрицы на вектор выполняется в <math> n </math> ярусов умножений и сложений.
# Шаги алгоритма Арнольди выполняются строго последовательно, однако последующее нахождение невязки можно выполнять параллельно с запуском следующего шага алгоритма.
# Сложность решения задачи минимальных квадратов зависит от используемого алгоритма. В отличие от последовательного метода данные, полученные на прошлых шагах здесь использовать нельзя.
# Вычисление результата выполняется один раз, его можно выполнить параллельно в <math> n </math> ярусов умножений и сложений.

== Входные и выходные данные алгоритма ==
'''Входные данные:''' Матрица <math>A</math>, вектор <math>b</math>, точность <math>t</math>. Объём: <math>n^2 + n + 1</math>

'''Выходные данные:''' Вектор <math>x_m</math>. Объём: <math>n</math>

== Свойства алгоритма ==
Теоретически на каждой итерации алгоритма сложность вычислений составляет <math>n + X</math> операций умножения, где <math>X</math> - сложность алгоритма для решения задачи минимальных квадратов. Таким образом в худшем случае сложность будет примерно равна <math>n^2 + X*n + n</math> операций умножения.

Несмотря на то, что в теории итерации алгоритма можно выполнять параллельно после выполнения алгоритма Арнольди, на практике необходимая точность может быть достигнута раньше чем на n-й итерации, что потребует какого-нибудь способа прервать последующие итерации. Для избегания лишних вычисление возможно оптимально оставить эту часть последовательной.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==
== Локальность данных и вычислений ==
== Возможные способы и особенности параллельной реализации алгоритма ==
== Масштабируемость алгоритма и его реализации ==
Для исследования масштабируемости алгоритма была использована параллельная реализация, найденная на просторах GitHub<ref>Parallel GMRES Algorithm for Solving Giant Sparse System of Linear Equations https://github.com/arrgasm/paraGMRES/</ref>. Программа была запущена на суперкомпьютере BlueGene на разреженной матрице размера 90448х90448. Параметрами запуска являются 100 итераций алгоритма и 10 перезапусков алгоритм (повторный запуск алгоритма с использованием решения, полученного на предыдущем запуске, в качестве начального приближения). График зависимости времени выполнения от числа процессоров представлен на рисунке 2.
[[file:PlotLvs1.png|thumb|center|400px|Рис 2. График зависимости времени выполнения от числа процессоров]]
График эффективности для полученного времени выполнения указан на рисунке 3.
[[file:PlotLvs2.png|thumb|center|400px|Рис 3. График зависимости эффективности реализации от числа процессоров]]
Параметры компиляции:
<code>mpixlc_r -qsmp=omp -O3</code>

Параметры запуска:
<code>gmres mat.mtx void 100 0 10</code>

== Динамические характеристики и эффективность реализации алгоритма ==
== Выводы для классов архитектур ==
== Существующие реализации алгоритма ==
Реализации алгоритма GMRES присутствуют во многих программных продуктах как части стандартных библиотек, например Matlab или DEFORM3D. Также существую отдельные библиотеки, например MGMRES для языка С++.

= Литература =
[1] Тыртышников Е. Е. Методы численного анализа — М., Академия, 2007.

[2] М. Дана, А. Г. Зыков, Х. Д. Икрамов Метод минимальных невязок для специального класса линейных систем с нормальными матрицами коэффициентов - Ж. вычисл. матем. и матем. физ., 2005, том 45, номер 11

Обсуждение участника:Lvs

2016-12-02T02:19:31Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK) Хорошая работа, нужно исправить несколько замечаний по содержанию. Новая серия замечаний стоит с моей подписью.

----

= Пункт 1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения.'''

Дважды повторяется, что GMRES – метод решения систем линейных уравнений.

= Пункт 1.2 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''z = Aq[j]; //очередной вектор'''

Что здесь Aq[j] в рамках обозначений выше?

Индексы в определении матрицы Хессенберга не согласованы (матрица <math>H_k</math>, элементы – <math>h_{mm}</math>).

= Пункт 1.3 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

Нужно привести какие еще матрично-векторные операции входят в алгоритм.
Сколько раз требуется выполнить матрично-векторное умножение и, например, расчет скалярных произведений двух векторов?

= Пункт 1.5 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Вычислить минимальное приближение'''

Что здесь подразумевается под минимальным приближением?

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.'''

Это утверждение нужно пояснить. Получается так, что если увеличивать размерность матрицы, то на каком-то шаге измениться степень в оценке сложности (размер будет расти как n^2, число ненулевых элементов, например, как n, и матрица будет «более разреженной»)? С чем это связано?

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Несмотря на то, что в теории итерации алгоритма можно выполнять параллельно после выполнения алгоритма Арнольди, на практике необходимая точность может быть достигнута раньше чем на n-й итерации, что потребует какого-нибудь способа прервать последующие итерации. Для избегания лишних вычисление возможно оптимально оставить эту часть последовательной.'''

Какую здесь часть лучше оставить последовательной – проверку достижения сходимости или прерывания итераций? Почему оптимально оставлять ее последовательной?

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

Нужно дополнить раздел описанием структуры матрицы, выбранной для численных экспериментов; помимо размера матрицы, привести число ненулевых элементов в ней; описать то, как реализовано разбиение данных по параллельным процессам в выбранной реализации GMRES.

В тексте нужно уточнить достигается ли сходимость при 100 итерациях. Почему были выбраны именно такие параметры – 100 итераций и 10 рестартов?

----

= Пункт 1.2 =
Это определение пространства Крылова?
Не совсем понятно описание алгоритма, если не знаешь, о чем речь

= Пункт 1.3 =
Он достаточно длинный. Посмотрите описания готовых алгоритмов на алговики. Псевдокод здесь не читается, ядро должно лучше восприниматься

= Пункт 1.4 =
Если макроструктура это указанные 3 пункта, то нужно пояснить, почему именно пункт 1 является ядром. Он самый ресурсоемкий?

= Пункт 1.7 =
Почему это основной ресурс. Это основная операция в алгоритме? Требуются пояснения

^^ эти пункты я тоже редактировал (как-то)

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:03, 23 ноября 2016 (MSK) '''принято'''

Обсуждение участника:Lvs

2016-12-02T02:16:27Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK) Хорошая работа, нужно исправить несколько замечаний по содержанию. Новая серия замечаний стоит с моей подписью.

----

= Пункт 1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Итерационный метод решения системы линейных алгебраических уравнений GMRES (или обобщенный метод минимальных невязок) используется для решения систем линейных алгебраических уравнений с заданной точностью приближения.'''

Дважды повторяется, что GMRES – метод решения систем линейных уравнений.

= Пункт 1.2 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''z = Aq[j]; //очередной вектор'''

Что здесь Aq[j] в рамках обозначений выше?

Индексы в определении матрицы Хессенберга не согласованы (матрица <math>H_k</math>, элементы – <math>h_{mm}</math>).

= Пункт 1.3 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

Нужно привести какие еще матрично-векторные операции входят в алгоритм.
Сколько раз требуется выполнить матрично-векторное умножение и, например, расчет скалярных произведений двух векторов?

= Пункт 1.5 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Вычислить минимальное приближение'''

Что здесь подразумевается под минимальным приближением?

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Сложность вычислений собственных векторов на каждом шаге - <math>O(n^2)</math>, но может уменьшиться до <math>O(n)</math> при более разреженной матрице.'''

Это утверждение нужно пояснить. Получается так, что если увеличивать размерность матрицы, то на каком-то шаге измениться степень (размер будет расти как n^2, число ненулевых элементов, например, как n, и матрица будет «более разреженной»)? С чем это связано?

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

'''Несмотря на то, что в теории итерации алгоритма можно выполнять параллельно после выполнения алгоритма Арнольди, на практике необходимая точность может быть достигнута раньше чем на n-й итерации, что потребует какого-нибудь способа прервать последующие итерации. Для избегания лишних вычисление возможно оптимально оставить эту часть последовательной.'''

Какую здесь часть лучше оставить последовательной – проверку достижения сходимости или прерывания итераций? Почему оптимально оставлять ее последовательной?

= Пункт 2.4 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:15, 2 декабря 2016 (MSK)

Нужно дополнить раздел описанием структуры матрицы, выбранной для численных экспериментов; помимо размера матрицы, привести число ненулевых элементов в ней; описать то, как реализовано разбиение данных по параллельным процессам в выбранной реализации GMRES.

В тексте нужно уточнить достигается ли сходимость при 100 итерациях. Почему были выбраны именно такие параметры – 100 итераций и 10 рестартов?

----

= Пункт 1.2 =
Это определение пространства Крылова?
Не совсем понятно описание алгоритма, если не знаешь, о чем речь

= Пункт 1.3 =
Он достаточно длинный. Посмотрите описания готовых алгоритмов на алговики. Псевдокод здесь не читается, ядро должно лучше восприниматься

= Пункт 1.4 =
Если макроструктура это указанные 3 пункта, то нужно пояснить, почему именно пункт 1 является ядром. Он самый ресурсоемкий?

= Пункт 1.7 =
Почему это основной ресурс. Это основная операция в алгоритме? Требуются пояснения

^^ эти пункты я тоже редактировал (как-то)

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:03, 23 ноября 2016 (MSK) '''принято'''

Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.

2016-12-01T23:56:21Z

Evgeny Mortikov:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(l)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2l+m+n+1</math>
| output_data = <math>n</math>
}}
Выполнила: [[Участник:Blizn|И.В. Близнякова]] (611 группа).

= Свойства и структура алгоритма =

== Общее описание алгоритма<ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988.</ref> ==
'''Разрежённая матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается '''''плотной'''''.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:
* есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;
* в каждой строке не превышает 10 в типичном случае;
* ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данного алгоритма и вычислительной системы имеет смысл извлекать выгоду из наличия в ней нулей.

=== Хранение разреженной матрицы ===
==== Формат RR(C)O ====
Рассмотрим сначала формат '''RR(C)O'''. Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Ordered"'' (строчное представление, полное и упорядоченное). В данном формате вместо одного двумерного массива, используются три одномерных. Значения ненулевых элементов матрицы и соответствующие им столбцовые индексы хранятся в этом формате по строкам в двух массивах <math>AN</math> и <math>JA</math>. Массив указателей <math>IA</math>, используется для ссылки на компоненты массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Последняя компонента массива <math>IA</math> содержит указатель первой свободной компоненты в массивах <math>AN</math> и <math>JA</math>, т.е. равна числу ненулевых элементов матрицы, увеличенному на единицу. Здесь уместно привести пример.

Рассмотрим матрицу <math>A</math>:
:<math>\begin{pmatrix}
0 & 0 & 0 & 2 & 0 \\
1 & 0 & 3 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 \\
0 & 6 & 0 & 0 & 0 \\
0 & 0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
тогда ее представление в формате '''RR(C)O''' будет иметь вид:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 1 3 2 3 ]
AN = [ 2 1 3 6 4 ]
Т.е. массив <math>AN</math> содержит все не нулевые элементы исходной матрицы <math>A</math>, массив <math>JA</math> номер столбца в котором находится соответствующий элемент из <math>AN</math> и наконец массив <math>IA</math> содержит номер с которого начинается описание элементов в массивах <math>JA</math> и <math>AN</math>. Таким образом информация об элементах 2-ой строки матрицы хранится в элементах с <math>IA[2] = 2</math> по <math>IA[3] - 1 = 3</math> включительно массивов <math>JA</math> и <math>AN</math>. Можно обратить внимание, что <math>IA[3] = IA[4] = 4</math>, а это означает, что 3-я строка матрицы <math>A</math> нулевая.

В общем случае описание <math>r</math>-й строки матрицы A хранится в компонентах с <math>IA[r]</math> до <math>IA[r + 1] - 1</math> включительно массивов <math>AN</math> и <math>JA</math>. Если <math>IA[r + 1] = IA[r]</math>, то это означает, что <math>r</math>-я строка нулевая. Количество элементов в массиве <math>IA</math> на единицу больше, чем число строк исходной матрицы, а количество элементов в массивах <math>JA</math> и <math>AN</math> равно числу ненулевых элементов исходной матрицы.

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, ''упорядоченным'', поскольку элементы каждой строки матрицы <math>A</math> хранятся в соответствии с возрастанием столбцовых индексов, и строчным, поскольку информация о матрице <math>A</math> указывается по строкам.

Массивы <math>IA</math> и <math>JA</math> представляют портрет (структуру) матрицы <math>A</math>, задаваемый как множество списков смежности ассоциированного с <math>A</math> графа. Если алгоритм, реализующий какую-либо операцию над разреженными матрицами, разбит на этапы символической обработки, на котором определяется портрет результирующей матрицы, и численной обработки, на котором определяются значения элементов результирующей матрицы, то массивы <math>IA</math> и <math>JA</math> заполняются на первом этапе, а массив <math>AN</math> - на втором.

==== Формат RR(C)U ====

Рассмотрим теперь формат '''RR(C)U'''.

Сокращенное название данного формата происходит от английского словосочетания ''"Row - wise Representation Complete and Unordered"'' (строчное представление, полное, но неупорядоченное). Формат '''RR(C)U''' отличается от '''RR(C)O''' тем, что в данном случае соблюдается упорядоченность строк, но внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Для матрицы <math>A</math> нашего примера вполне можно было бы использовать и строчное представление, полное, но неупорядоченное такое:
IA = [ 1 2 4 4 5 6 ]
JA = [ 4 3 1 2 3 ]
AN = [ 2 1 3 6 4 ]
Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

==== Замечания ====

Несколько замечаний по поводу рассмотренных форматов представления:
# Очевидно, что представление матрицы в формате '''RR(C)O''' так же является и представлением в формате '''RR(C)U''', но не наоборот.
# Из представления матрицы в формате '''RR(C)''' нельзя получить информацию о точном количестве столбцов исходной матрицы.
# Целесообразно (в вопросе экономии памяти) использовать представления '''RR(C)''' в случае, если матрица содержит значительное число нулевых элементов.

=== Умножение разреженной матрицы на вектор ===

Важным приложением этих алгоритмов является вычисление векторов Ланцоша, необходимое при итерационном решении линейных уравнений методом сопряженных градиентов, а также при вычислении собственных значений и собственных векторов матрицы. Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция - это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.

Мы рассмотрим умножение разреженной матрицы общего вида, хранимой в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math> на заполненный вектор-столбец.

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

Исходные данные: разреженная матрица общего вида <math>A</math> с элементами <math>a_{ij}</math> (<math>i = 1,...,n</math> и <math>j = 1,...,m</math>). Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> (<math>j =1,...,m</math>).

Вычисляемые данные: заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>l_{i}</math> - количество ненулевых элементов строки <math>i</math> матрицы <math>A</math>, <math>j(k)</math> - индекс <math>k</math>-го ненулевого элемента матрицы <math>A</math>.

== Вычислительное ядро алгоритма ==
Вычислительное ядро последовательной версии умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений строк матрицы:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>.

== Макроструктура алгоритма ==

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>c_{i} = \sum\limits_{k = 1}^{l_{i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

которые могут вычисляться в произвольном порядке.

== Схема реализации последовательного алгоритма ==

Далее предполагаем, что разреженная матрица общего вида <math>A</math> хранится в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>.
Последовательность исполнения метода следующая:

Выполнять для <math>i</math> от <math>1</math> до <math>n</math>
# <math>c_{i} = 0</math>
# <math>IAA = IA[i]</math>
# <math>IAB = IA[i + 1] - 1</math>
# <math>c_{i} = \sum\limits_{k = IAA}^{IAB} AN[k]b_{JA[k]}</math>.
После этого (если <math>i \le n</math>) происходит переход к шагу 1 с бо́льшим <math>i</math>.

== Последовательная сложность алгоритма ==

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:

* <math>l</math> сложений,
* <math>l</math> умножений.

Умножения и сложения составляют ''основную часть алгоритма''.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам <math>O(l)</math>.

== Информационный граф ==

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

Первая группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Естественно введённые координаты области таковы:

* <math>i</math> — меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math> - элемент ''входных данных'', а именно <math>AN[IA_{i}+j-1]</math>.
* <math>b</math> - элемент ''входных данных'', а именно <math>b[IA_{i}+j-1]</math>.

Результат срабатывания операции является ''промежуточным данным'' алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a + b</math>.
Естественно введённые координаты области таковы:
* <math>i</math> - меняется в диапазоне от <math>1</math> до <math>n</math>, принимая все целочисленные значения;
* <math>j</math> - меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все целочисленные значения,
где <math>k = k(i) = IA[i+1]-IA[i]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>j = 1</math> - результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j)</math>;
** при <math>j > 1</math> - результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>(i, j - 1)</math>;
* <math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>(i, j + 1)</math>.

Результат срабатывания операции:
* при <math>j < k - 1</math> является ''промежуточным данным'' алгоритма;
* при <math>j = k - 1</math> является ''выходным данным'' <math>c_{i}</math>.

Описанный граф можно посмотреть на рис.1. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.
[[file:Bliznalg.png|thumb|center|1000px|Рисунок 1. Граф алгоритма умножения разреженной матрицы на вектор]]

== Ресурс параллелизма алгоритма ==

Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размерности <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* Не более чем <math>m</math> сложений и умножений (<math>n</math> вычислений в каждом из ярусов)

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(m)</math>. При классификации по ширине ЯПФ его сложность будет <math>O(n)</math>.

== Входные и выходные данные алгоритма ==

'''Входные данные''': разреженная матрица общего вида <math>A</math> размерности <math>n \times m</math>, хранимая в форме '''RR(C)U''' посредством массивов <math>IA</math>, <math>JA</math>, <math>AN</math>. Заполненный вектор-столбец <math>b</math> с элементами <math>b_{j}</math> размерности <math>m \times 1</math>.

'''Объём входных данных''': <math>2l+m+n+1</math>, где <math>l</math> - количество ненулевых элементов в матрице <math>A</math>.

'''Выходные данные''': заполненный вектор-столбец <math>c</math> с элементами <math>c_{i}</math> (<math>i = 1,...,n</math>).

'''Объём выходных данных''': <math>n</math>.

== Свойства алгоритма ==

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейной''.

При этом вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – ''константа''.

Пусть <math>l</math> - количество ненулевых элементов матрицы <math>A</math> размерности <math>n \times m</math>. Пусть <math>x</math> - объем памяти, используемый для хранения значения элемента матрицы, <math>y</math> - объём памяти, используемый для хранения номера столбца или строки. В таком случае для хранения матрицы в стандартном представлении нам потребуется объем памяти, равный <math>x \cdot n \cdot m</math>, для хранения в формате '''RR(C)''' - <math>y(n + 1) + (x + y)l</math>. Таким образом хранение в формате '''RR(C)''' не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==

Параллельная реализация алгоритма заключается в следующем:

# Каждый процессор считывает входные данные из файла, зависящего от его номера. Данные имеют вид: вектор <math>b</math> и набор определённых строк матрицы <math>A</math> в формате '''RR(C)U''' в зависимости от номера процессора и их числа;
# Процессоры проводят вычисления значений вектора <math>c</math> в зависимости от имеющихся данных;
# Все процессоры отправляют результаты вычисления процессору, выбранному главным, и главный процессор выводит результат вычислений.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Текст использованной в экспериментах реализации (язык ''С++''):
<div class="mw-collapsible-content">
<source lang="c++">
#include <mpi.h>
#include <memory>
#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
#include <string>
#include <iterator>

typedef std::shared_ptr<std::vector<std::vector<int> > > MyData;

MyData ReadData(const std::string& data_path) {
std::ifstream file_stream;
MyData retval(new std::vector<std::vector<int> >());
file_stream.open(data_path);

while (!file_stream.eof()) {
std::string str;
std::getline(file_stream, str);

std::istringstream iss(str);
auto temp_1 = (std::istream_iterator<std::string>(iss));
auto temp_2 = (std::istream_iterator<std::string>());

std::vector<std::string> coordinates{ temp_1, temp_2};
retval->push_back(std::vector<int>());
for (auto& e : coordinates) {
retval->back().push_back(std::stoi(e));
}
}

return retval;
}

// input: vector b, vector ia, vector ja, vector an
int main(int argc, char** argv){
MPI_Init(&argc, &argv);
int pid, np;
MPI_Status *s = new MPI_Status;
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
MPI_Comm_size(MPI_COMM_WORLD, &np);
if (argc == 2){
int n;
int indx = 0;
int stp;
double strttime = MPI_Wtime();
std::vector<int> b;
std::vector<int> ia;
std::vector<int> ja;
std::vector<int> an;
auto data = ReadData("data_" + std::to_string(static_cast<long long>(pid)) + ".txt");
b = (*data)[0];
ia = (*data)[1];
ja = (*data)[2];
an = (*data)[3];
n = (*data)[0].size();
std::vector<int> c;
stp = n / np + ((n % np > pid) ? 1 : 0);
if (pid == 0){
c.resize(n, 0);
}
else{
c.resize(stp, 0);
}
for (int i = 0; i < stp; i++){
int strt = ia[i] - ia[0];
int lstr = ia[i + 1] - ia[i];
for (int j = 0; j < lstr; j++){
c[i] += an[strt + j] * b[ja[strt + j]];
}
}
if (pid == 0){
for (int i = 1; i < np; i++){
indx += n / np + ((n % np > i - 1) ? 1 : 0);
stp = n / np + ((n % np > i) ? 1 : 0);
MPI_Recv(&c[indx], stp, MPI_INT, i, 0, MPI_COMM_WORLD, s);
}
}
else{
MPI_Send(&c[0], stp, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (pid == 0){
for (int e : c) {
std::cout << e << "\n";
}
double endtime = MPI_Wtime();
std::cout << "Success! Time = " << endtime - strttime << "\n";
}
}
MPI_Finalize();
return 0;
}
</source>
</div></div>

<div class="mw-collapsible mw-collapsed" style="width:100%">
Для формирования входных данных использовался следующий алгоритм (язык ''Python''):
<div class="mw-collapsible-content">
<source lang="python">
from scipy import sparse as sp
from numpy.random import randint
from os import mkdir
from os.path import join as jn

n = 10000
np = [1, 2, 4, 8, 16, 32, 64, 128]

a = sp.csr_matrix(randint(0, 2, (n, n)))
b = randint(1, 5, n)
i = 0

for j in np:
mkdir('data_' + str(j))
indx = 0
for i in range(0, j):
stp = n / j + (1 if (n % j > i) else 0)
ael = a.indptr[indx + stp] - a.indptr[indx]
strt = a.indptr[indx]
with open(jn('data_' + str(j), 'data_' + str(i) + '.txt'), 'w') as fout:

for e in b:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indptr[indx:indx + stp + 1]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.indices[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

s = a.data[strt:strt + ael]
for e in s:
fout.write('{0} '.format(e))
fout.write('\n')

indx = indx + n / j + (1 if (n % j > i) else 0)
</source>
</div></div>

Проведём исследование масштабируемости параллельной реализации алгоритма умножения разреженной матрицы на вектор. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета]. Входные данные формировались на персональном компьютере в силу того, что интерпретатор на суперкомпьютере "Ломоносов" не удовлетворял нужным требованиям, и потом отправлялись на суперкомпьютер для последующей обработки.

Программа была собрана на узле компиляции суперкомпьютера "Ломоносов", с помощью компилятора ''intel/15.0.090'' и компилятора ''openmpi/1.6.5-icc'', на языке ''С++11''.

<div class="mw-collapsible mw-collapsed" style="width:100%">
Сборка производилась с помощью ''CMakeLists.txt'', его содержание прилагается:
<div class="mw-collapsible-content">
<pre>
cmake_minimum_required(VERSION 2.8)

project(task1)

set(CMAKE_CXX_STANDARD 11)

set(CXX_STANDARD_REQUIRED)

set(CMAKE_C_COMPILER mpicc)
set(CMAKE_CXX_COMPILER mpicxx)

find_package(MPI REQUIRED)

include_directories(${MPI_INCLUDE_PATH})

SET(CMAKE_CXX_COMPILER mpicc)

if(MPI_COMPILE_FLAGS)
set_target_properties(task1 PROPERTIES
COMPILE_FLAGS "${MPI_COMPILE_FLAGS}")
endif()

set(CMAKE_CXX_FLAGS "-std=c++11 -fpermissive " ${MPI_COMPILE_FLAGS})

set(SOURCE_EXE task1.cpp)

add_executable(task1 ${SOURCE_EXE})

target_link_libraries(task1)
</pre>
</div></div>

Запуск производился на вычислительных узлах суперкомпьютера "Ломоносов".

Набор и границы значений изменяемых параметров запуска реализации алгоритма:

* число процессоров [1 : 128] по степеням 2;
* размер матрицы [1000 : 10000] с шагом 1000.

[[file:Blizntime.png|thumb|center|1000px|Рисунок 2. Время работы программы в зависимости от количества процессоров и размера матрицы]]

Можно заметить, что при небольшом количестве входных данных, и большом количестве процессоров эффективность распараллеливания падает до нуля, поскольку время вычисления элементов вектора <math>c</math> становится несоизмеримо малым по сравнению с временем, затраченным на пересылку в пункте (3).

[[file:Efficiency(paral).png|thumb|center|1000px|Рисунок 4. Эффективность распараллеливания в зависимости от количества процессоров и размера матрицы]]

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Существующие реализации:

SciPy [https://docs.scipy.org/doc/scipy-0.18.1/reference/index.html],

MatLab [https://www.mathworks.com/help/matlab/math/sparse-matrix-operations.html],

Intel MKL [https://software.intel.com/en-us/articles/intel-math-kernel-library-inspector-executor-sparse-blas-routines].

= Литература =

Обсуждение участника:Blizn

2016-12-01T23:53:30Z

Evgeny Mortikov:

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK) К Вашей работе есть несколько замечаний по содержанию.

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''- есть <math>O(n)</math>. Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;'''

'''- в каждой строке не превышает 10 в типичном случае;'''

'''- ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.'''

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

== Пункт 1.1.1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''В данном формате вместо одного двумерного массива, используются три одномерных.'''

Плотную матрицу можно представить и, например, в виде одномерного массива. Тогда получается обычный формат хранения лучше?

== Пункт 1.1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Такие неупорядоченные представления могут быть очень удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.'''

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

== Пункт 1.1.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Важным приложением этих алгоритмов является вычисление векторов Ланцоша, необходимое при итерационном решении линейных уравнений методом сопряженных градиентов, а также при вычислении собственных значений и собственных векторов матрицы.'''

Умножение разреженной матрицы на вектор используется и во многих других алгоритмах, методах и задачах, чем примечательны именно эти?

'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция - это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Для умножения разреженной матрицы общего вида, хранимой в форме '''RR(C)U''', размером <math>n \times m</math> на заполненный вектор <math>m \times 1</math> в последовательном (наиболее быстром) варианте требуется:'''

''' <math>l</math> сложений,'''

''' <math>l</math> умножений.'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>l</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

'''Таким образом хранение в формате RR(C) не является эффективным для матриц, в которых <math>l > \frac{xnm - y(n+1)}{x+y}</math>.'''

Нужно уточнить по какому критерию сравнивается «эффективность». Просто занимает меньше памяти? Или, например, сравнивается скорость доступа к памяти или время выполнения матричных операций?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:50, 2 декабря 2016 (MSK)

Нужно явно написать в тексте, что рассматривался целочисленный алгоритм. Почему не вещественное матрично-векторное умножение? Приводимые оценки для числа операций алгоритма (п.1.6, 1.8) разве учитывают вспомогательные целочисленные операции, например, для организации циклов?

'''размер матрицы [1000 : 10000] с шагом 1000.'''

Здесь размер матрицы – это число ненулевых элементов? Нужно привести и размер матрицы, и число ненулевых элементов.

Какая структура матрицы, которая использовалась в экспериментах? Какова доля операций чтения из файла в экспериментах?

== Статья [[Участник:Blizn/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор.]] ==

=== Отсутствующие части ===
* Нет информации в разделе 2.7. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:27, 16 ноября 2016 (MSK)

=== Замечания по тексту ===
* В разделе 1.4 не нужно дублировать написанное в разделе 1.3, а требуется описание алгоритма на верхнем уровне. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:47, 27 октября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 2 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)
* В разделе 2.4 не приведён сам текст использованной в экспериментах реализации алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 11:09, 30 ноября 2016 (MSK)

Обсуждение участника:Lexaloris

2016-12-01T23:25:27Z

Evgeny Mortikov:

Основной вопрос. Ядро это все-таки умножение матрицы или строки матрицы? Соответственно под это нужно подстраивать и остальной текст, потому что можно понять и так, и так.

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)
К Вашей работе есть несколько замечаний по содержанию

= Пункт 1.1.1.1 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

'''Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для умножения разреженной матрицы на вектор.'''

Минимальные требования к памяти, по отношению к любым другим способам хранения разреженных матриц даже специального вида? Нужно также пояснить в чем удобство именно этого подхода, по отношению к другим.

= Пункт 1.1.1.2 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

'''Неупорядоченные представления могут быть очень удобны. Результаты большинства матричных операций получаются не упорядоченными, и упорядочение их стоило бы больших затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы представления были упорядоченными.'''

Хорошо бы привести примеры матричных операций, для которых неупорядоченное представление дает выигрыш, по сравнению с упорядоченным.

= Пункт 1.5 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

Псевдокод и схема алгоритма написаны с ошибками и отличаются друг от друга.

= Пункт 1.6 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

Нужно привести точное число операций для данного алгоритма и описать какие операции используются.

= Пункт 1.8 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

'''При классификации по высоте ЯПФ, алгоритм имеет линейную сложность. При классификации по высоте ЯПФ также линейную.'''

Дважды описывается сложность по высоте ЯПФ.

= Пункт 1.10 =
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

'''Алгоритм в рамках выбранной версии полностью детерминирован.'''

Будет ли влиять выполнение свойства ассоциативности для сложения на детерминированность алгоритма?

= Пункт 2.4 =
[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 14:17, 17 ноября 2016 (MSK) необходимо доработать:

Требования были такие:
- Реализация: полностью собственная или обращение к библиотечной функции (Intel MKL, PETSc, FFTW, ScaLAPACK). В любом случае, текст исследуемой программы должен быть представлен в отчете.
- Компьютерная платформа может быть любой (Ломоносов, BlueGene или что-то иное). Описание компьютерной платформы должно быть в отчете.
- Должен быть представлен график сильной масштабируемости (зависимости производительности от числа процессов; если при этом
ещё и зависимость от размера задачи - это только в плюс). График должен выглядеть пристойно и понятно, оси и единицы измерения должны быть подписаны. К графику обязательно должны быть словесные пояснения! Требовалось подобрать такие размеры задачи и числа процессоров, чтобы отразить на графике характерные точки, описывающие свойства алгоритма и программы.

[[Участник:Dan|Dan]] ([[Обсуждение участника:Dan|обсуждение]]) 11:00, 21 ноября 2016 (MSK)
- Приведите код, параметры компиляции.

- График построен по каким значениям?

- Укажите все параметры, при которой исследовалась задача: размер матрицы и т.д.

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 02:21, 2 декабря 2016 (MSK)

'''Параллельная реализация алгоритма позволяет до некоторой степени сократить время вычислений в несколько раз.'''

Почему в несколько раз, если на графике время счета уменьшается почти на порядок?

В разделе нужно пояснить, какая программная реализация использовалась в экспериментах с (RR (С) U) форматом, входит ли в расчет генерация матрицы, ее преобразование в разреженный формат, операции записи-чтения. Также нужно указать размерность и структуру матрицы в экспериментах и привести ссылку на описание кластера.

Участник:Руфина Третьякова/Хранение ненулевых элементов разреженных матриц. Умножение разреженной матрицы на вектор

2016-12-01T00:18:50Z

Evgeny Mortikov:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math>O(n)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

Руфина Третьякова отвечает за программную реализацию алгоритма, Екатерина Буторина - за написание статьи.

==ЧАСТЬ. Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
Разрежённая матрица — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.
Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты.
Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных или операции с графами.
При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.
Сложность операции с разреженными матрицами чаще всего определяется не их размером но числом ненулевых элементов. Далее будет показано, что умножение разреженной матрицы на плотный вектор можно произвести ровно за столько умножений сколько в матрице ненулевых элементов.

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^n</math>

Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.

Рассмотрим CSR-представление разреженной матрицы: пусть число ненулевых элементов матрицы равно <math>nnz</math>
CSR-формат представляет матрицу <math>M</math> в виде 3-х одномерных массивов:

массив <math>A</math> размера <math>nnz</math> содержит ненулевые значения матрицы,
<math>JA</math> размера <math>nnz</math> - номера столбцов ненулевых элементов.,
<math>IA</math> размера <math>n</math>- содержит номер с которого начинается описание элементов строки в массивах <math>A</math> и <math>JA</math>.

Этот формат позволяет производить перемножение матрицы <math>M</math> на вектор <math>x</math> за <math>O(nnz)</math> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле
<math>y_i = \sum_{k = 1}^{n} A_{ik} x_k</math>,
то в случае разреженной матрицы достаточно выполнять умножения только для ненулевых элементов <math>A_ik</math>, которые хранятся в массиве <math>A</math> в части соответствующей строке <math>i</math> (элементы с индексами от <math>IA_i</math> до <math>IA_{i+1}</math>). Необходимо также знать на какой элемент вектора должен быть домножен данный ненулевой элемент массива, то есть нужен столбцовый индекс каждого элемента <math>A</math>. Для этого используется массив <math>JA</math>. Таким образом, каждый элемент итогового вектора определятся формулой
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
Нетрудно заметить, что общее число операций умножения равно числу элементов <math>A</math>, то есть числу ненулевых элементов разреженной матрицы.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 0 \\
2 & 0 & 0 & 1 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 2 1 3 4 ]
IA = [ 0 0 2 3 4 ]
JA = [ 0 3 2 1 ]
домножим ее на вектор
x = [ 5 6 7 8 ]
получим
y[0] = 0
y[1] = a[0]*x[0] + a[1]*x[3] = 18
y[2] = a[2]*x[2] = 21
y[3] = a[3]*x[1] = 24

Алгоритм умножения матрицы на вектор полностью детерминирован и не зависит от порядка хранения элементов принадлежащих одной строке.

=== Вычислительное ядро алгоритма ===
Вычислительным ядром алгоритма является формула умножения разреженной матрицы на плотный вектор:
:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>
для всех <math>i = 1,n</math>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''n'';
разреженная матрица в формате CSR:
строчные указатели ''IA'',
столбцовые указатели''JA'',
ненулевые элементы ''A'';
вектор ''x''.
'''Выходные данные''': произведение матрицы на вектор ''y''.
'''read CSR''' ''n'', ''IA'', ''JA'', ''A'';
'''read''' ''x''
'''for''' ''i'' = 1,n:
'''for''' ''k'' = ''IA(i)'', ''IA(i+1)-1'':
''y(i)'' += ''A(k)''*''x(JA(k))'';
'''write''' ''y'';

=== Схема реализации последовательного алгоритма ===
Метод можно описать следующим образом:
# привести матрицу <math>M</math> к формату CSR
# для <math>i</math> от <math>0</math> до <math>n-1</math> вычислить <math>y_i</math> по формуле <math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</math>

=== Последовательная сложность алгоритма ===
Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:

* <math>nnz</math> сложений,
* <math>nnz</math> умножений.

=== Информационный граф ===

Для того чтобы построить информационный граф рассмотрим процесс вычисления значения одного элемента результирующего вектора <math>y_i</math>. Число последовательных ярусов равно числу последовательных операций -- <math> AI_{i+1} - AI_i </math> (в данном случае умножение и сложение будем считать за одну операцию).
Если же вычисления всех <math>y_i</math> производить параллельно, на каждом ярусе будет производиться <math>n</math> операций.

[[Файл:Pic.jpg|800x800px|center|thumb|Информационный граф алгоритма умножения разреженной матрицы на плотный вектор
(Рисунок составлен самостоятельно)]]

=== Ресурс параллелизма алгоритма ===

Возможность параллельной реализации алгоритма появляется благодаря независимости вычисления каждого элемента результирующего вектора <math>y_i</math>. Предположим, что имеется неограниченное число процессоров (теоретически, для максимальной эффективности требуется <math>n</math> процессоров). Каждый процессор работает с одной строкой разреженной матрицы и хранит в памяти только те части массивов
<math> AJ </math> и <math> A </math>, которые соответствуют данной строке. Вектор <math> x </math> хранится в памяти всех процессоров. Таким образом достигается экономия памяти (объем данных для i-ого процессора <math> 2(AI_{i+1} - AI_i) + n </math>). На данном процессоре выполняется
<math> AI_{i+1} - AI_i </math> последовательных операций умножения и сложения. Число ярусов для i-ого процессора равно <math> AI_{i+1} - AI_i </math>. Поскольку изначальная разреженная матрица имеет произвольную структуру, число ярусов на различных процессорах может быть различно. В худшем случае (если в строке все элементы ненулевые) число ярусов будет равно <math>n</math>.

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

* не более чем <math>n</math> ярусов умножений и сложений,
* в каждом из ярусов не более чем <math>n</math> операций.

При классификации по высоте ЯПФ, таким образом, алгоритм умножения матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по ширине ЯПФ его сложность также будет ''линейной''.

''Замечание:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

=== Входные и выходные данные алгоритма ===
Входными данными алгоритма являются:
# размер разреженной матрицы <math> n </math>;
# вектор <math> AI </math> размерности <math> n+1 </math>;
# вектор <math> AJ </math> размерности <math> nnz </math>;
# вектор <math> A </math> размерности <math> nnz </math>;
# вектор <math> x </math> размерности <math> n </math>.

Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>

Выходными данными является
# вектор <math> y </math> размерности <math> n </math>.

Объем выходных данных: <math> n </math>.

=== Свойства алгоритма ===

Если размерность матрицы <math>n</math>, число ненулевых элементов <math>nnz</math>, для вычисления используется <math>k</math> процессоров тогда:

*Каждый процессор оперирует с <math>\frac{n}{k}</math> строками, в каждой из которых примерно <math>\frac{nnz}{n}</math> элементов. Параллельная сложность алгоритма - <math>O(\frac{nnz}{k})</math>.

*Вычислительная мощность алгоритма (отношение числа операций к суммарному объему входных и выходных данных) - <math>O(\frac{nnz}{2nnz + 3n}) = O(1)</math> - для последовательного алгоритма; <math>O(\frac{nnz}{n} / (2\frac{nnz}{n} + n)) = O(1) </math> - для параллельного алгоритма.

== ЧАСТЬ. Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===
Наитивная реализация алгоритма следующая:
# один процессор назначается управляющим
# управляющий процессор считывает или генерирует (если матрица задается известной формулой) матрицу в CSR формате <math> [ AI, AJ, A ] </math>
# управляющий процессор считывает или генерирует вектор <math> x </math>
# управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор
# все процессоры вычисляют произведение своего блока матрицы на вектор
# управляющий процессор собирает результаты
Данный алгоритм несмотря на кажщуюся простоту оказывается весьма неэффективен, так как время пересылок оказывается на порядки больше времени вычисления. Более того, при большом количестве процессоров время выполнения параллельной программы оказывается больше времени выполнения последовательной программы. Производительность и эффективность работы данного алгоритма показаны на рисунках 1 и 2.
<div><ul>
<li style="display: inline-block;"> [[File:perf_drto.png|thumb|none|800px|Рисунок 1: производительность умножения разреженной матрицы на вектор при считывании управляющим процессором (время считывания и пересылок учтено)]] </li>
<li style="display: inline-block;"> [[File:effc_drto.png|thumb|none|800px|Рисунок 2: эффективность умножения разреженной матрицы на вектор при считывании управляющим процессором (время считывания и пересылок учтено)]] </li>
</ul></div>

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

Улучшенный алгоритм:
# каждый процессор вычисляет блок матрицы (индексы строк) с которым ему предстоит работать в зависимости от своего порядкового номера
# каждый процессор генерирует или считывает (при помощи процедур параллельного чтения) свой блок матрицы, и вектор
# каждый процессор вычисляет произведение своего блока матрицы на вектор
# управляющий (нулевой) процессор собирает результат или же каждый процессор записывает свою часть результата (при помощи процедур параллельной записи)

Данный алгоритм отличается лучшим быстродействием (по крайней мере, время работы параллельной программы уменьшается с увеличением числа процессоров). Производительность и эффективность алгоритма можно увидеть на рисунках 3-6.

<div><ul>
<li style="display: inline-block;"> [[File:perf_drtc.png|thumb|none|800px|Рисунок 3: производительность умножения разреженной матрицы на вектор при параллельном считывании (время считывания и пересылок учтено)]] </li>
<li style="display: inline-block;"> [[File:effc_drtc.png|thumb|none|800px|Рисунок 4: эффективность умножения разреженной матрицы на вектор при параллельном считывании (время считывания и пересылок учтено)]] </li>
</ul></div>

<div><ul>
<li style="display: inline-block;"> [[File:perf_clrc.png|thumb|none|800px|Рисунок 5: производительность умножения разреженной матрицы на вектор при параллельном считывании (учитывается только время вычислений)]] </li>
<li style="display: inline-block;"> [[File:effc_clrc.png|thumb|none|800px|Рисунок 6: эффективностьь умножения разреженной матрицы на вектор при параллельном считывании (учитывается только время вычислений)]] </li>
</ul></div>

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

Если производить анализ алгоритма по суммарному времени работы программы (рис. 3,4), то эффективность уменьшается практически до нуля при увеличении числа процессоров, а производительность выше при малом числе процессоров и малом размере матрицы, за исключением нескольких "пиков" на средних размерах матрицы и большом числе процессоров. Если же анализировать непосредственно время вычислений, то производительность и эффективность оказываются значительно выше. На "пиках" наблюдается сверхлинейное ускорение (рис. 6), и в целом эффективность лучше для больших размеров матрицы. Производительность также имеет данные "пики", и становится выше для больших размеров матрицы.

Тестирование производилось на кластере cluster2 ИВМ РАН.
''Я бы с удовольствием выполнила задание на Ломоносове или BlueGene, если бы мне дали доступ к ним!''

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Последовательная реализация имеется в пакете SPARSKIT [http://w3.pppl.gov/~hammett/work/2006/gmres/SPARSKIT2/BLASSM/matvec.f], Python.Scipy [https://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.sparse.csr_matrix.html]

Параллельный алгоритм реализован в библиотеке Matlab [http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.6692&rep=rep1&type=pdf], Intel MKL [https://software.intel.com/en-us/node/468536#D09FB46A-B404-44CC-94ED-1C434C41B6E1]

== Литература ==
[1] С. Писсанецки. Технология разреженных матриц. Изд. Мир, 1988.

[2] В. В. Воеводин, Вл.В. Воеводин. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002.

Обсуждение участницы:Trrufina

2016-12-01T00:12:00Z

Evgeny Mortikov:

Хорошая работа. Есть несколько замечаний

= Пункт 1.1 =

'''Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных или операции с графами.'''

Это предложение нужно переформулировать. Разреженные матрицы часто возникают при решении дифференциальных уравнений именно численными методами.

= Пункт 1.2 =
'''Наиболее удобным форматом для вычисления произведения матрицы на вектор является "Compressed Sparse Row" или сокращенно CSR-формат.'''

С какой точки зрения данный формат является «наиболее удобным»?

Данный раздел хорошо бы дополнить хотя бы кратким упоминанием других способов хранения разреженных матриц.

'''Алгоритм умножения матрицы на вектор полностью детерминирован и не зависит от порядка хранения элементов принадлежащих одной строке.'''

Будет ли влиять выполнение свойства ассоциативности для сложения на детерминированность алгоритма?

= Пункт 1.5 =

Лучше использовать одинаковую индексацию для псевдокода алгоритма (1.4) и для схемы реализации алгоритма.

= Пункт 1.6 =

'''Для вычисления матрично-векторного произведения матрицы размера <math>n*n</math> и вектора размера n в последовательном варианте требуется:'''

'''* <math>nnz</math> сложений,'''
'''* <math>nnz</math> умножений.'''

Оценка для числа сложений похоже не совсем правильная для алгоритма в 1.5 (например, для матрицы с одним ненулевым элементом).

= Пункт 1.8 =

Можно ли записать параллельный алгоритм, использующий больше чем n процессоров, где n - число строк(столбцов)?

= Пункт 1.9 =

'''Суммарная размерность входных данных: <math> 2(nnz + n) + 1 </math>'''

В оценке не учитывается пункт 1 – размер разреженной матрицы.

= Пункт 2.4 =

Непонятно какая реализация алгоритма использовалась в экспериментах. Если это собственная реализация, то нужно кратко описать язык программирования, библиотеки, которые использовались и т.п.

'''4. управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор'''

Разделение матрицы идет только по строкам или по блокам матрицы?

Опечатка - '''Данный алгоритм несмотря на кажщуюся простоту'''

Нужно описать, что подразумевается под «Matrix size» на рисунках, число ненулевых элементов или размерность матрицы, и указать обе величины в численных экспериментах.

'''Улучшенный алгоритм:'''
'''4. управляющий (нулевой) процессор собирает результат или же каждый процессор записывает свою часть результата (при помощи процедур параллельной записи)'''

Если в расчет и 1-го алгоритма и «улучшенного алгоритма» входила параллельная запись в файл, а не просто сборка данных на управляющем процессоре, то нужно это явно уточнить в тексте.

Опечатки - Следует заметить, что в данной реализации матрица генерировалась при помощи случайных '''числел''', и кроме того кластер, на котором '''прозиводились''' эксперименты не является однородным, различные ядра имеют различные характеристики, вследствие чего возникает "рельефность" производительности и эффективности.

'''Тестирование производилось на кластере cluster2 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?

Участник:Janyell/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-30T23:52:37Z

Evgeny Mortikov:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>O(nz)</math>
| pf_height = <math>O(m)</math>
| pf_width = <math>O(n)</math>
| input_data = <math>nz + m</math>
| output_data = <math>n</math>
}}

'''Авторы описания:''' [[Участник:Janyell|Е.А. Сычева]] (разделы [[#Диагональная схема хранения ленточных матриц|1.1.1.1]],
[[#Профильная схема хранения симметричных матриц|1.1.1.2]],
[[#Умножение разреженной матрицы на вектор|1.1.2]],
[[#Математическое описание алгоритма|1.2]] - [[#Последовательная сложность алгоритма|1.6]],
[[#Входные и выходные данные алгоритма|1.9]],
[[#Свойства алгоритма|1.10]]) и [[Участник:ahahalin|А.С. Хахалин]] (разделы [[#Связные схемы разреженного хранения|1.1.1.3]] - [[#Хранение блочных матриц|1.1.1.6]],
[[#Информационный граф|1.7]],
[[#Ресурс параллелизма алгоритма|1.8]],
[[#Масштабируемость алгоритма и его реализации|2.4]],
[[#Существующие реализации алгоритма|2.7]])

= Свойства и структура алгоритмов =

== Общее описание алгоритма ==
'''Разреженная матрица''' — матрица с большим количеством нулевых элементов.

Среди специалистов нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разреженной. Матрицу порядка <math>n</math> называют ''разреженной'', если число ее ненулевых элементов <ref>С.Писсанецки. Технология разреженных матриц. - М.: Мир, 1988</ref>:

* есть <math>O(n)</math>. Приведенное определение полезно только для теоретических целей типа попытки оценить асимптотическое поведение алгоритма.
* ограничено в строке, в типичном случае от 2 до 10.
* выражается как <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.
* таково, что для данной матрицы, данного алгоритма и данной вычислительной машины имеет смысл извлекать выгоду из наличия в ней многих нулей.

Всякую разреженную матрицу можно обрабатывать так, как если бы она была плотной: напротив, всякую плотную, или заполненную, матрицу можно обрабатывать алгоритмами для разреженных матриц. В обоих случаях получатся правильные численные результаты, но вычислительные затраты возрастут. Приписывание матрице свойства разреженности эквивалентно утверждению о существовании алгоритма, использующего ее разреженность и делающего вычисления с ней дешевле по сравнению со стандартными алгоритмами.

Три основных идеи, которые направляли развитие большей части технологии разреженных матриц:
* '''хранить только ненулевые элементы'''. Разреженная матрица, будучи множеством чисел, не имеющим регулярности, не может быть представлена в памяти машины тем же простым способом, что и полная матрица - регулярным числовым массивом. Поэтому возникает необходимость дополнительно хранить индексную информацию, указывающую расположение каждого элемента в регулярном массиве.
* '''оперировать только с ненулевыми элементами'''. Число операций, производимых машиной при исполнении алгоритма, пропорционально числу ненулевых элементов, а не числу всех элементов матрицы.
* '''сохранять разреженность'''. Хороший алгоритм для разреженных матриц пытается сохранить разреженность, по возможности уменьшая заполнение.

В целях упрощения операций с разреженными матрицами многие алгоритмы разрешают также хранить небольшое количество нулевых элементов и оперировать с ними как с ненулевыми.

=== Хранение ненулевых элементов разреженной матрицы ===

==== Диагональная схема хранения ленточных матриц ====
Матрицу <math>A</math> называют ''ленточной'', если все ее ненулевые элементы заключены внутри ленты, образованной диагоналями, параллельными главной диагонали. Таким образом, <math>a_{ij} = 0</math>, если <math>|i - j| > b</math>, и <math>a_{k, k-b} \ne 0</math>, либо <math>a_{k, k+b} \ne 0</math> хотя бы для одного значения <math>k</math>. Здесь <math>b</math> — ''полуширина'', а <math>2b + 1</math> — ''ширина ленты''. ''Лентой'' матрицы <math>A</math> называется множество элементов, для которых <math>|i - j| \leq b</math>. Другими словами, для всякой строки <math>i</math> ленте принадлежат все элементы со столбцовыми индексами от <math>i - b</math> до <math>i + b</math>, т. е. <math>2b + 1</math> элементов.

Если матрица симметрична, то достаточно хранить ее ''полуленту''. Верхняя полулента состоит из элементов, находящихся в верхней части ленты, т. е. таких, что <math>0 < j - i \leq \beta </math>; нижняя полулента состоит из элементов нижней части ленты, т. е. таких, что <math>0 < i - j \leq \beta</math>; в обоих случаях в строке <math>\beta</math> элементов.

С ленточными матрицами связана простейшая и наиболее широко применяемая стратегия использования нулевых элементов матрицы. ''Диагональная схема'' хранения симметричной ленточной матрицы <math>A</math> порядка <math>n</math> и полуширины ленты <math>\beta</math> представляет собой массив <math>AN (I, J)</math> размером <math>n \times (\beta + 1)</math>. Главная диагональ хранится в последнем столбце, а нижние кодиагонали — в остальных столбцах со сдвигом на одну позицию вниз при каждом смещении влево.

Для несимметричной матрицы <math>A</math> необходим массив размером <math>n \times(2\beta + 1)</math>; нижняя полулента и главная
диагональ хранятся прежним образом, а верхние кодиагонали — в правой части массива со сдвигом на одну позицию вверх при каждом смещении вправо. Диагональная схема удобна, если <math>\beta << n </math>. Она является схемой прямого доступа в том смысле, что имеется простое взаимно однозначное соответствие между положением элемента в матрице <math>A</math> и его положением в массиве: <math>a_{ij}</math>
хранится компонентой <math>AN (i, j - i + \beta + 1)</math>.

==== Профильная схема хранения симметричных матриц ====
Ленточная матрица высокого порядка может иметь широкую ленту и большое число нулей внутри ее. Для такой матрицы диагональная схема может быть очень неэкономной. ''Профильная схема'' или ''схема переменной ленты'' является более эффективной схемой хранения симметричных матриц.

Для каждой строки <math>i</math> симметричной матрицы <math>A</math> положим:

<math>\beta_{i} = i - j_{min} (i)</math>,

где <math>j_{min} (i)</math> — минимальный столбцовый индекс строки <math>i</math>, для которого <math>a_{ij} \ne 0</math>. Таким образом, первый ненулевой элемент строки <math>i</math> находится на <math>\beta_{i}</math>- позиций левее главной диагонали.

''Оболочка'' матрицы <math>A</math> — это множество элементов <math>a_{ij}</math>, для которых <math>0 < i - j < \beta_{i}</math> В строке <math>i</math> оболочке принадлежат все элементы со столбцовыми индексами от <math>j_{min} (i)</math> до <math>i - 1</math>, всего <math>\beta_{i}</math> элементов. Диагональные элементы не входят в оболочку. ''Профиль'' матрицы <math>A</math> определяется как число элементов в оболочке:

<math>profile (A) = \sum\limits_{i}\beta_{i}</math>

При использовании профильной схемы все элементы оболочки, упорядоченные по строкам, хранятся, включая нули, в одномерном массиве <math>AN</math>. Диагональный элемент данной строки помещается в ее конец. Длина массива <math>AN</math> равна сумме профиля и порядка <math>A</math>. Кроме того, необходим массив указателей <math>IA</math>; элементы этого массива - указатели расположения диагональных элементов в <math>AN</math>. Так, при <math>i > 1</math> элементы строки <math>i</math> находятся в позициях от <math>IA (i - 1) + 1</math> до <math>IA (i)</math>. Единственный элемент <math>a_{11}</math> 1-й строки хранится в <math>AN (1)</math>.

Схема переменной ленты строчно-ориентирована в том смысле, что любая строка матрицы сканируется эффективно; в то же время всякая попытка сканировать столбцы будет неэффективной. Кроме того, схема является ''статической'' - заготовленной до начала численной обработки, - потому что включение нового элемента, лежащего вне оболочки, требует изменения всей структуры.

==== Связные схемы разреженного хранения ====

Рассмотрим разреженную матрицу <math>A</math>. Ее ненулевые элементы, которых очень мало в сравнении с числом нулей, рассеяны по всей матрице, образуя ''портрет'' матрицы или ''шаблон нулей—ненулей''. Опишем схему хранения предложенную Кнутом. Ненулевые элементы хранятся в компактной форме и в произвольном порядке в одномерном массиве <math>AN</math>. Информация о положении элементов может храниться двумя дополнительными параллельными одномерными массивами <math>I</math> и <math>J</math>; здесь для каждого ненулевого элемента содержатся его строчный и столбцовый индексы. Таким образом, для каждого <math>a_{ij}\ne0</math> в памяти находится тройка <math>(a_{ij},i,j)</math>. Далее, чтобы можно было легко отыскать элементы произвольной строки или столбца, необходимы ещё пара указателей для каждой тройки, а также ''указатели входа'' для ''строк'' и ''столбцов'', сообщающие начало каждого строчного или столбцового списка. Пусть <math>NR</math> ("next nonzero element in the same row" — "следующий ненулевой элемент той же строки") — массив, хранящий строчные указатели, а <math>NC</math> ("next nonzero element in the same column" — "следующий ненулевой элемент того же столбца") — массив столбцовых указателей. Пять массивов <math>AN,I,J,NR,NC</math> имеют общую длину, и их одноименные позиции соответствуют друг другу. Пусть <math>JR</math> и <math>JC</math> — массивы, содержащие указатели входа для строк и столбцов, расположенные в соответствии с порядком строк и столбцов матрицы. Тогда, например, для просмотра <math>i</math> строки необходимо:
# определить входной индекс <math>j=JR[i]</math>
# определить элемент <math>AN[j]</math>
# найти индекс следующего элемента <math>j=NR[j]</math>
# если <math>j=0</math>, то мы обошли все элемент <math>i</math>-ой строки, иначе, перейти в п.2
Заметим, что рассмотренная схема требует пять ячеек памяти для каждого ненулевого элемента, а также 2 массива указателей входа для строк и столбцов. Вследствие большой накладной памяти такая схема весьма неэкономна. Достоинства её в том, что в любом месте можно включить или исключить элемент, а также можно эффективно сканировать строки и столбцы.

==== Разреженный строчный формат ====

Рассмотрим матрицу <math>A</math>(рис. 1).

[[File:SuperSparseStoreAndMultiplyMatrix1.png|thumb|center|200px|Рисунок 1. Матрица A]]

Значения ненулевых элементов и соответствующие столбцовые индексы хранятся в этой схеме по строкам в двух массивах — <math>AN</math> и <math>JA</math> соответственно. Дополнительно также используется массив указателей <math>IA</math>, отмечающих позиции массивов <math>AN</math> и <math>JA</math>, с которых начинается описание очередной строки. Дополнительная компонента в <math>IA</math> содержит указатель первой свободной позиции в <math>AN</math> и <math>JA</math>. В общем случае описание <math>r</math>-й строки <math>A</math> хранится в позициях с <math>IA (r)</math> до <math>IA (r + 1) - 1</math> массивов <math>JA</math> и <math>AN</math>, за исключением равенства <math>IA (r + 1) = IA (r)</math>, означающего, что <math>r</math>-я строка пуста. Если матрица <math>A</math> имеет <math>m</math> строк, то <math>IA</math> содержит <math>m + 1</math> позиций. [[File:SuperSparseStoreAndMultiplyRRCOFormat.png|thumb|right|300px|Рисунок 2. Формат RR (C) O на примере матрицы А(рис.1)]]

Данный способ представления называют ''полным'', поскольку представлена вся матрица <math>A</math>, и ''упорядоченным'', поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов. Таким образом, это строчное представление, полное и упорядоченное, или сокращенно '''RR (C) O''' (рис. 2). Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Ordered" (строчное представление, полное и упорядоченное).

Схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разряженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямым, так и итерационными методами.

==== Неупорядоченные представления ====

Рассмотрим формат '''RR(C)U''' (рис. 3). Сокращенное название данного формата происходит от английского словосочетания "Row - wise Representation Complete and Unordered" (строчное представление, полное, но неупорядоченное).

Аналогично RR(C)O формат RR(C)U представлен тремя массивами — <math>AN,JA,IA</math>, но элементы в массивах <math>AN,JA</math> относящиеся к одной строке, могут идти в произвольном порядке.[[File:SuperSparseStoreAndMultiplyRRCUFormat.png|thumb|right|300px|Рисунок 3. Формат RR (C) U на примере матрицы А (рис.1)]]

Формат RR(C)U вводится по следующим причинам. Представления разреженных матриц необязательно должны быть упорядочены в том смысле, что, хотя упорядоченность строк соблюдается, внутри каждой строки элементы исходных матриц могут храниться в произвольном порядке. Такие неупорядоченные представления могут быть весьма удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.

Ещё одним форматом неупорядоченного представления является '''RR (U) U''' (рис. 4). Сокращенное название формата RR (U) U происходит от английского словосочетания "Row - wise Representation, Upper, Unordered" (строчное представление, верхний треугольник, неупорядоченное).[[File:SuperSparseStoreAndMultiplyRRUUFormat.png|thumb|right|300px|Рисунок 4. Формат RR (U) U на примере матрицы А (рис.1)]]

Данный формат используется для симметричных и верхних треугольных матриц, у которых большинство диагональных элементов отличны от нуля. В этом формате представляется только верхний треугольник матрицы (внутри каждой строки элементы могут храниться в произвольном порядке), а ее диагональные элементы хранятся в отдельном одномерном массиве. Верхняя треугольная матрица представляется тремя массивами <math>AN,JA,IA</math>, которые аналогичны массивам в формате RR(C)U.

==== Хранение блочных матриц ====

Идея разбиения большой матрицы на подматрицы или блоки возникает естественным образом. С блоками можно обращаться, как если бы они были элементами матрицы, и блочная матрица превращается в матрицу из матриц. Разбиение на блоки играет важную роль в технологии разреженных матриц, потому что многие алгоритмы, сконструированные первоначально для числовых матриц, можно обобщить на случай матриц из матриц. Большая гибкость, связанная с понятием разбиения, может давать определенные вычислительные преимущества. С другой стороны, разбиение можно рассматривать просто как инструмент управления данными, помогающий организовать обмен информацией между оперативной памятью и внешними запоминающими устройствами.

Хранение блочной матрицы подразумевает хранение множества её подматриц. Рассмотрим ''неявную схему хранения'', предназначенную главным образом для симметричных матриц с квадратными диагональными блоками. Диагональные блоки рассматриваются так, как если бы они составляли единую матрицу, и хранятся в соответствие с [[#Профильная схема хранения симметричных матриц|профильной схемой]]. Численные значения элементов хранятся по строкам в массиве <math>AN</math>, а указатели на диагональные элементы каждой строки — в целом массиве <math>IA</math>. Поддиагональные блоки рассматриваемые так, как если бы они составляли единую матрицу, хранятся посредством [[#Разреженный строчный формат|разреженного строчного формата]]. Ненулевые элементы размещаются по строкам в вещественном массиве <math>AP</math>, а соответствующие столбцовые индексы — в параллельном целом массиве <math>JA</math>. Указатели начала строк хранятся в массиве <math>IP</math>.

=== Умножение разреженной матрицы на вектор ===

'''Умножение разреженной матрицы на вектор''' используется при вычислении векторов Ланцоша, необходимом при итерационном решении линейных уравнений методом сопряженных градиентов, а также при вычислении собственных значений и собственных векторов матрицы. Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется. Следовательно, наиболее релевантными для этих задач являются статические схемы хранения.

В зависимости от формы представления матрицы используются различные алгоритмы. Далее рассмотрим простейший случай — это когда матрица, прямоугольная или квадратная, хранится в форме RR (С) U.

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

Исходные данные: разреженная матрица общего вида <math>A</math> (элементы <math>a_{ij}</math>, <math>i = 1, \ldots, n</math>, <math>j = 1, \ldots, m</math>), заполненный вектор-столбец <math>b</math> (элементы <math>b_{j}</math>, <math>j = 1, \ldots, m</math>)

Вычисляемые данные: заполненный вектор-столбец <math>c</math> (элементы <math>c_{i}</math>, <math>i = 1, \ldots, n</math>).

Формулы метода:

<math>c_{i} = \sum\limits_{k = 1}^{nz{_i}} a_{i,j=j(k)}b_{j=j(k)}</math>,

где <math>nz{_i}</math> - количество ненулевых элементов <math>a_{ij}</math>, <math>j = 1, \ldots, m</math>,

<math>j = j(k)</math> - индексная информация, указывающая расположение ненулевого элемента <math>a_{ij}</math>, <math>i = 1, \ldots, n</math> и соответствующего элемента <math>b_{j}</math>.

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

== Вычислительное ядро алгоритма ==

Вычислительное ядро умножения разреженной матрицы на вектор можно составить из множественных (всего их <math>n</math>) вычислений скалярных произведений вектор-строк <math>a^i</math> (элементы <math>a^i_{k}</math>, <math>k = 1, \ldots, nz_{i}</math>), состоящих из ненулевых элементов <math>a_{i, j=j(k)}</math>, на вектор-столбцы <math>b^i</math> (элементы <math>b^i_{k}</math>, <math>k = 1, \ldots, nz_{i}</math>), состоящих из элементов <math>b_{j=j(k)}</math>, <math>i = 1, \ldots, n</math>:

<math>\sum\limits_{k = 1}^{nz_{i}} a^i_k b^i_k</math>

в ''режиме накопления'' или без него, в зависимости от требований задачи.

== Макроструктура алгоритма ==

Как записано и в [[#Вычислительное ядро алгоритма|описании ядра алгоритма]], основную часть метода составляют множественные (всего <math>n</math>) вычисления сумм:

<math>\sum\limits_{k = 1}^{nz_{i}} a^i_k b^i_k</math>

в режиме накопления или без него.

== Схема реализации последовательного алгоритма ==

Последовательность исполнения метода следующая:

Далее описывается простейший случай — матрица <math>A</math> хранится в форме RR (С) U.

1. <math>k^0_{nz} = IA(1)</math>

Далее для всех <math>i</math> от <math>1</math> до <math>n</math> по нарастанию выполняются

2. <math>c_i = 0</math>

3. <math>k^i_0 = k^{i - 1}_{nz}</math>

4. <math>k^i_{nz} = IA(i + 1) - 1</math>

5. <math>c_{i} = \sum\limits_{k = k^i_0}^{k^i_{nz}} AN(k) b_{JA(k)}</math>

После этого (если <math>i \le n</math>) происходит переход к шагу 2 с бо́льшим <math>i</math>.

Особо отметим, что вычисления <math>c_{i}</math> производят в режиме накопления сложением произведений <math>AN(k) b_{JA(k)}</math> для <math>k</math> от <math>k^i_0</math> до <math>k^i_{nz}</math>, c нарастанием <math>k</math>.

== Последовательная сложность алгоритма ==

Для алгоритма умножения разреженной матрицы размером <math>n \times m</math>, представленной в формате RR (C) U, на вектор длины <math>m</math> в последовательном (наиболее быстром) варианте требуется:

* <math>nz</math> сложений (вычитаний),
* <math>nz</math> умножений,

где <math>nz</math> - количество ненулевых элементов матрицы <math>A</math>.

Умножения и сложения (вычитания) составляют ''основную часть алгоритма''.

При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности, что ещё больше увеличивает долю умножений и сложений/вычитаний во времени, требуемом для выполнения умножения разреженной матрицы на вектор.

При классификации по последовательной сложности, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам со сложностью <math>O(nz)</math>.

== Информационный граф ==

Опишем [[глоссарий#Граф алгоритма|граф алгоритма]]<ref>Воеводин В.В. Математические основы параллельных вычислений// М.: Изд. Моск. ун-та, 1991. 345 с.</ref><ref>Воеводин В.В., Воеводин Вл.В. Параллельные вычисления. – СПб.: БХВ - Петербург, 2002. – 608 с.</ref><ref>Фролов А.В.. Принципы построения и описание языка Сигма. Препринт ОВМ АН N 236. М.: ОВМ АН СССР, 1989.</ref> как аналитически, так и в виде рисунка. Далее предполагается, что матрица <math>A</math> представлена в формате RR (C) U.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a*b</math>. Естественно введённые координаты области таковы:

*<math>i</math> — меняется в диапазоне от 1 до <math>k</math>, принимая все целочисленные значения;
*<math>j</math>— меняется в диапазоне от 1 до <math>n</math>, принимая все целочисленные значения.

Здесь <math>k</math> зависит от <math>j</math> и соответствует числу ненулевых элементов в <math>j</math>-ой строке матрицы <math>A</math>, которое равно <math>IA[j+1] - IA[j]</math>.

Аргументы операции следующие:
*<math>a</math> — элемент массива <math>AN</math> с индексом <math>IA_{j} + i</math>;
*<math>b</math> — элемент входного вектора <math>b</math> с индексом <math>JA[IA_{j} + i]</math>.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция <math>a+b</math>. Естественно введённые координаты области таковы:

*<math>i</math> — меняется в диапазоне от 3 до <math>k+1</math>, принимая все целочисленные значения;
*<math>j</math>— меняется в диапазоне от 1 до <math>n</math>, принимая все целочисленные значения.

Здесь <math>k</math> зависит от <math>j</math> и соответствует числу ненулевых элементов в <math>j</math>-ой строке матрицы <math>A</math>, которое равно <math>IA[j+1] - IA[j]</math>.

Аргументы операции следующие:
*<math>a</math>:
** при <math>i=3</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>i - 2, j</math>;
** при <math>i>3</math> — результат срабатывания операции, соответствующей вершине из второй группы, с координатами <math>i - 1, j</math>;
*<math>b</math> — результат срабатывания операции, соответствующей вершине из первой группы, с координатами <math>i - 1, j</math>.

Результат срабатывания операции является ''промежуточным данным'' алгоритма.

Описанный граф можно посмотреть на рис. 5. Граф отображает параллельную версию произведения разреженной матрицы на вектор, где каждая строка показывает ядро алгоритма (произведение строки на вектор). Вершины, соответствующие входным и выходным данным обозначены прямоугольниками, а вершины, соответствующие операциям — окружностями. Здесь вершины первой группы обозначены зеленым цветом и буквосочетанием multi, вершины второй — синим цветом и знаком сложения.

[[file:SuperSparseStoreAndMultiply_RRCU.png|thumb|center|1200px|Рисунок 5. Граф алгоритма. multi — произведение.]]

== Ресурс параллелизма алгоритма ==

Для алгоритма умножения разреженной матрицы размером <math>n\times m</math>, представленной в формате RR (C) U, на вектор длины <math>m</math> в параллельном варианте требуется последовательно выполнить следующие ярусы:

* по <math>nz_{\max}</math> ярусов умножений и сложений (в каждом из ярусов — <math>n</math> операций),
где <math>nz_{\max} = \max_{1 \leq i \leq n} nz_i \leq m</math>.

При этом использование режима накопления требует совершения умножений и сложений в режиме двойной точности, а в параллельном варианте это означает, что практически все промежуточные вычисления для выполнения алгоритма в режиме накопления должны быть двойной точности. В отличие от последовательного варианта это означает некоторое увеличение требуемой памяти.

При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по высоте ЯПФ его сложность также будет ''линейной''.

== Входные и выходные данные алгоритма ==

'''Входные данные:'''

* разреженная матрица общего вида <math>A</math> (элементы <math>a_{ij}</math>, <math>i = 1, \ldots, n</math>, <math>j = 1, \ldots, m</math>), заданная в формате RR (C) U;

* заполненный вектор-столбец <math>b</math> (элементы <math>b_{j}</math>, <math>j = 1, \ldots, m</math>).

'''Объём входных данных:'''

* <math>nz</math> (без учета индексной информации, составляющей накладные расходы - массивы <math>JA, IA</math>);

* <math>m</math>.

'''Выходные данные:''' заполненный вектор-столбец <math>c</math> (элементы <math>c_{i}</math>, <math>i = 1, \ldots, n</math>).

'''Объём выходных данных:''' <math>n</math>.

== Свойства алгоритма ==

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов равно <math>O(\frac{nz}{n})</math>.

При этом вычислительная мощность алгоритма умножения разреженной матрицы на вектор, как отношение числа операций к суммарному объему входных и выходных данных – ''константа''.

При этом алгоритм умножения матрицы на вектор полностью детерминирован. Использование другого порядка выполнения ассоциативных операций в данной версии нами не рассматривается.

= Программная реализация алгоритма =

== Особенности реализации последовательного алгоритма ==

== Локальность данных и вычислений ==

== Возможные способы и особенности параллельной реализации алгоритма ==

== Масштабируемость алгоритма и его реализации ==
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы в формате RR(C)U на вектор. Исследование проводилось на [http://hpc.cmc.msu.ru/bgp вычислительном комплексе IBM Blue Gene/P]<ref>Вычислительный комплекс IBM Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. В качестве программной реализации была использована модифицированная версия [https://github.com/taoito/matvec-mpi программы]<ref>Thao Nguyen A sparse matrix-vector parallel multiplication implementation using MPI</ref>.

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1, 10, 25, 50, 100]
* количество ненулеввых элементов в матрице [1500, 40000, 150000, 600000, 3750000].

На следующем рисунке приведен график времени выполнения выбранной реализации умножение разреженной матрицы в формате RR(C)U на вектор в зависимости от изменяемых параметров запуска.

[[file:RRCOMultiplaction Graphic.png|thumb|center|700px|Рисунок 6. Параллельная реализация умножение разреженной матрицы в формате RR(C)U на вектор.]]

Можно заметить, что скорость вычисления при переходе с последовательной на параллельную версию возросла значительно. В то время как дальнейшее увеличение числа вычислительных устройств не дает такого эффекта. Это объясняется быстрым ростом накладных расходов на организацию параллельного выполнения. Это подтверждает предположение о том, что накладные расходы начинают сильно превалировать над вычислениями.

== Динамические характеристики и эффективность реализации алгоритма ==

== Выводы для классов архитектур ==

== Существующие реализации алгоритма ==

Алгоритм умножения разреженной матрицы на вектор входит в состав таких библиотек для вычислений с разреженными матрицами, как: SparseLib++[http://math.nist.gov/sparselib++/], uBLAS [http://www.boost.org/doc/libs/1_62_0/libs/numeric/ublas/doc/], Intel MKL [https://software.intel.com/en-us/intel-mkl], cuSPARSE [http://docs.nvidia.com/cuda/cusparse/] и др.

= Литература =

<references \>

Обсуждение участника:Janyell

2016-11-30T23:51:11Z

Evgeny Mortikov:

Добрый день. Подключаюсь к проверке. Статья мне в целом понравилась, и тем больше от этого хочется добавить замечаний, чтобы довести ее до того вида, чтобы она могла остаться на Алговики.

'''Уважаемые авторы, к Вашей работе есть новые замечания - они для удобства отделены горизонтальной линией от прошлых.'''

= Пункт 1.1 =
Разреженная матрица, будучи множеством чисел, не имеющим регулярности, '''не может быть представлена в памяти машины тем же простым способом, что и полная матрица'''. Поэтому возникает необходимость дополнительно хранить индексную информацию, указывающую расположение каждого элемента в регулярном массиве.

Что означает фраза, выделенная жирным? Или как-то переформулируйте утверждение, оно не понятно

'''Однако многие схемы хранения допускают определенную долю нулей, и алгоритм обрабатывает их, как если бы они не были нулями.'''
Тоже непонятно

__

Поправили

----

'''Разреженная матрица — матрица с большим количеством нулевых элементов.'''

Все же матрица с большим количеством нулей может быть сильно плотной и так лучше не писать.

'''* есть <math>O(n)</math>. Приведенное определение полезно только для теоретических целей типа попытки оценить асимптотическое поведение алгоритма.'''

'''* ограничено в строке, в типичном случае от 2 до 10.'''

'''* выражается как <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.'''

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 2 и 10 (а, например, 1?) и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''Всякую разреженную матрицу можно обрабатывать так, как если бы она была плотной: напротив, всякую плотную, или заполненную, матрицу можно обрабатывать алгоритмами для разреженных матриц.'''

Как можно обрабатывать плотную матрицу алгоритмами для разреженных матриц, если ее нужно представить в специальном виде?

'''* сохранять разреженность. Хороший алгоритм для разреженных матриц пытается сохранить разреженность, по возможности уменьшая заполнение.'''

Это свойство нужно пояснить. Не во всех задачах можно или желательно уменьшать заполнение.

'''В целях упрощения операций с разреженными матрицами многие алгоритмы разрешают также хранить небольшое количество нулевых элементов и оперировать с ними как с ненулевыми.'''

Почему именно небольшое количество нулевых элементов?

= Пункт 1.1.1.1 =
Поставьте определение ленточной матрицы в начало. Потому что, начиная читать первую фразу, сначала задаешься вопросом, что это такое

__

Поправили

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

__

Поправили

----

Можно ли описанную схему использовать для хранения несимметричной ленточной матрицы? И общих (необязательно ленточных) симметричных матриц?

= Пункт 1.1.1.5 =

----

'''Такие неупорядоченные представления могут быть весьма удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.'''

Хорошо бы привести несколько примеров операций, для которых неупорядоченные представления дают выигрыш.

'''Данный формат используется для симметричных и верхних треугольных матриц, у которых большинство диагональных элементов отличны от нуля.'''

В чем здесь причина требования «большинство диагональных элементов отличны от нуля»? Формат предназначен для только симметричных или только верхних треугольных? Или и для тех и других?

= Пункт 1.1.1.6 =

----

'''Идея разбиения большой матрицы на подматрицы или блоки возникает естественным образом. С блоками можно обращаться, как если бы они были элементами матрицы, и блочная матрица превращается в матрицу из матриц.'''

Это не так, поскольку матричные произведения необязательно коммутативны.

'''Разбиение на блоки играет важную роль в технологии разреженных матриц, потому что многие алгоритмы, сконструированные первоначально для числовых матриц, можно обобщить на случай матриц из матриц. Большая гибкость, связанная с понятием разбиения, может давать определенные вычислительные преимущества.'''

Хорошо бы пояснить какие вычислительные преимущества это дает.

'''С другой стороны, разбиение можно рассматривать просто как инструмент управления данными, помогающий организовать обмен информацией между оперативной памятью и внешними запоминающими устройствами. '''

Нужно подробнее пояснить какие преимущества блочное разбиение дает при организации обменов информации между оперативной памятью и внешними запоминающими устройствами.

'''Рассмотрим ''неявную схему хранения'', предназначенную главным образом для симметричных матриц с квадратными диагональными блоками.'''

В чем заключается неявность в такой схеме хранения?

= Пункт 1.1.2 =
'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''
Опять непонятно

__

Не совсем понятно, что именно непонятно. Добавили комментарий

----

'''Умножение разреженной матрицы на вектор используется при вычислении векторов Ланцоша, необходимом при итерационном решении линейных уравнений методом сопряженных градиентов, а также при вычислении собственных значений и собственных векторов матрицы.'''

Умножение разреженной матрицы на вектор используется и во многих других алгоритмах, методах и задачах, чем примечательны именно эти?

'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

'''Следовательно, наиболее релевантными для этих задач являются статические схемы хранения.'''

Есть ли такие схемы хранения, которые при выполнении матрично-векторного произведения изменяют матрицу или требуют изменения структуры данных?

= Пункт 1.3 =
Почему вычислительное ядро только последовательной версии?
Вычислительное ядро (computational kernel) алгоритма - это часть алгоритма, на которую приходится основное время его работы.

__

Поправили

= Пункт 1.4 =
Наверное, вопрос в том, что алгоритм делает помимо запуска вычислительных ядер?

__

Присвоение элементам заполненного вектора-столбца <math>c</math> результатов запуска вычислительных ядер.

= Пункт 1.5 =
Как была выбрана форма хранения матрицы? Это нужно прокомментировать

__

Комментарий был ранее, в пункте 1.1.2. Продублировали

= Пункт 1.6 =

----

'''Для алгоритма умножения разреженной матрицы размером <math>n \times m</math>, представленной в формате RR (C) U, на вектор длины <math>m</math> в последовательном (наиболее быстром) варианте требуется:'''

'''* <math>nz</math> сложений (вычитаний),'''
'''* <math>nz</math> умножений,'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>nz</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

'''При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности, что ещё больше увеличивает долю умножений и сложений/вычитаний во времени, требуемом для выполнения умножения разреженной матрицы на вектор.'''

Непонятное предложение. Увеличивается и доля сложений и доля умножений? Что меняется, с точки зрения числа операций, если делать расчет с двойной точностью?

= Пункт 1.7 =
Правильно я понимаю, что на рисунке изображено вычисление всего произведения матрицы на вектор? Аналогичные блоки для разных строк. А разве не должен быть рисунок, изображающий ядро (то есть произведение одной строки на вектор)?
(я не уверен, поэтому спрашиваю. Возможно, это как-то надо лучше подписать)

__

Нам показалось верным отобразить на рисунке именно параллельную версию, на которой будет видно как и произведение одной строки на вектор, так и вычисление всех элементов. Как следует из определения [[глоссарий#Граф алгоритма|графа алгоритма]], он должен давать удобное представление не только ядра, но и позволять рассмотреть алгоритм с параллельной точки зрения. Внесли небольшое пояснение для рисунка.

= Пункт 1.8 =

----

'''При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по высоте ЯПФ его сложность также будет ''линейной''.'''

Два раза повторяется сложность при классификации по высоте ЯПФ

= Пункт 2.4 =
Пока пустой?

__

Поправили

----

Помимо ненулевых элементов нужно указать размерность матрицы и описать матрицу (случайная или нет, если нет, то какая), которая использовалась в экспериментах.

'''Это объясняется быстрым ростом накладных расходов на организацию параллельного выполнения. Это подтверждает предположение о том, что накладные расходы начинают сильно превалировать над вычислениями.'''

Хорошо бы поподробнее описать с чем связаны накладные расходы – обращением к файловой системе или межпроцессорными коммуникациями и какого вида.

Обсуждение участника:Janyell

2016-11-30T23:40:37Z

Evgeny Mortikov:

Добрый день. Подключаюсь к проверке. Статья мне в целом понравилась, и тем больше от этого хочется добавить замечаний, чтобы довести ее до того вида, чтобы она могла остаться на Алговики.

= Пункт 1.1 =
Разреженная матрица, будучи множеством чисел, не имеющим регулярности, '''не может быть представлена в памяти машины тем же простым способом, что и полная матрица'''. Поэтому возникает необходимость дополнительно хранить индексную информацию, указывающую расположение каждого элемента в регулярном массиве.

Что означает фраза, выделенная жирным? Или как-то переформулируйте утверждение, оно не понятно

'''Однако многие схемы хранения допускают определенную долю нулей, и алгоритм обрабатывает их, как если бы они не были нулями.'''
Тоже непонятно

__

Поправили

----

'''Разреженная матрица — матрица с большим количеством нулевых элементов.'''

Все же матрица с большим количеством нулей может быть сильно плотной и так лучше не писать.

'''* есть <math>O(n)</math>. Приведенное определение полезно только для теоретических целей типа попытки оценить асимптотическое поведение алгоритма.'''

'''* ограничено в строке, в типичном случае от 2 до 10.'''

'''* выражается как <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.'''

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 2 и 10 (а, например, 1?) и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

'''Всякую разреженную матрицу можно обрабатывать так, как если бы она была плотной: напротив, всякую плотную, или заполненную, матрицу можно обрабатывать алгоритмами для разреженных матриц.'''

Как можно обрабатывать плотную матрицу алгоритмами для разреженных матриц, если ее нужно представить в специальном виде?

'''* сохранять разреженность. Хороший алгоритм для разреженных матриц пытается сохранить разреженность, по возможности уменьшая заполнение.'''

Это свойство нужно пояснить. Не во всех задачах можно или желательно уменьшать заполнение.

'''В целях упрощения операций с разреженными матрицами многие алгоритмы разрешают также хранить небольшое количество нулевых элементов и оперировать с ними как с ненулевыми.'''

Почему именно небольшое количество нулевых элементов?

= Пункт 1.1.1.1 =
Поставьте определение ленточной матрицы в начало. Потому что, начиная читать первую фразу, сначала задаешься вопросом, что это такое

__

Поправили

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

__

Поправили

----

Можно ли описанную схему использовать для хранения несимметричной ленточной матрицы? И общих (необязательно ленточных) симметричных матриц?

= Пункт 1.1.1.5 =

----

'''Такие неупорядоченные представления могут быть весьма удобны в практических вычислениях. Результаты большинства матричных операций получаются неупорядоченными, а их упорядочение стоило бы значительных затрат машинного времени. В то же время, за немногими исключениями, алгоритмы для разреженных матриц не требуют, чтобы их представления были упорядоченными.'''

Хорошо бы привести несколько примеров операций, для которых неупорядоченные представления дают выигрыш.

'''Данный формат используется для симметричных и верхних треугольных матриц, у которых большинство диагональных элементов отличны от нуля.'''

В чем здесь причина требования «большинство диагональных элементов отличны от нуля»? Формат предназначен для только симметричных или только верхних треугольных? Или и для тех и других?

= Пункт 1.1.1.6 =

----

'''Идея разбиения большой матрицы на подматрицы или блоки возникает естественным образом. С блоками можно обращаться, как если бы они были элементами матрицы, и блочная матрица превращается в матрицу из матриц.'''

Это не так, поскольку матричные произведения необязательно коммутативны.

'''Разбиение на блоки играет важную роль в технологии разреженных матриц, потому что многие алгоритмы, сконструированные первоначально для числовых матриц, можно обобщить на случай матриц из матриц. Большая гибкость, связанная с понятием разбиения, может давать определенные вычислительные преимущества.'''

Хорошо бы пояснить какие вычислительные преимущества это дает.

'''С другой стороны, разбиение можно рассматривать просто как инструмент управления данными, помогающий организовать обмен информацией между оперативной памятью и внешними запоминающими устройствами. '''

Нужно подробнее пояснить какие преимущества блочное разбиение дает при организации обменов информации между оперативной памятью и внешними запоминающими устройствами.

'''Рассмотрим ''неявную схему хранения'', предназначенную главным образом для симметричных матриц с квадратными диагональными блоками.'''

В чем заключается неявность в такой схеме хранения?

= Пункт 1.1.2 =
'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''
Опять непонятно

__

Не совсем понятно, что именно непонятно. Добавили комментарий

----

'''Умножение разреженной матрицы на вектор используется при вычислении векторов Ланцоша, необходимом при итерационном решении линейных уравнений методом сопряженных градиентов, а также при вычислении собственных значений и собственных векторов матрицы.'''

Умножение разреженной матрицы на вектор используется и во многих других алгоритмах, методах и задачах, чем примечательны именно эти?

'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''

Достоинство этих процедур, по сравнению с какими? В некоторых итерационных методах, например, требуется также умножение и транспонированной матрицы на вектор.

'''Следовательно, наиболее релевантными для этих задач являются статические схемы хранения.'''

Есть ли такие схемы хранения, которые при выполнении матрично-векторного произведения изменяют матрицу или требуют изменения структуры данных?

= Пункт 1.3 =
Почему вычислительное ядро только последовательной версии?
Вычислительное ядро (computational kernel) алгоритма - это часть алгоритма, на которую приходится основное время его работы.

__

Поправили

= Пункт 1.4 =
Наверное, вопрос в том, что алгоритм делает помимо запуска вычислительных ядер?

__

Присвоение элементам заполненного вектора-столбца <math>c</math> результатов запуска вычислительных ядер.

= Пункт 1.5 =
Как была выбрана форма хранения матрицы? Это нужно прокомментировать

__

Комментарий был ранее, в пункте 1.1.2. Продублировали

= Пункт 1.6 =

----

'''Для алгоритма умножения разреженной матрицы размером <math>n \times m</math>, представленной в формате RR (C) U, на вектор длины <math>m</math> в последовательном (наиболее быстром) варианте требуется:'''

'''* <math>nz</math> сложений (вычитаний),'''
'''* <math>nz</math> умножений,'''

Что здесь понимается как «наиболее быстрый вариант»? Есть ли какие-то более медленные альтернативы? Оценка <math>nz</math> сложений похоже не совсем правильная. Например, сколько нужно сложений для матрицы с одним ненулевым элементом в алгоритме 1.5?

'''При этом использование режима накопления требует совершения умножений и вычитаний в режиме двойной точности, что ещё больше увеличивает долю умножений и сложений/вычитаний во времени, требуемом для выполнения умножения разреженной матрицы на вектор.'''

Непонятное предложение. Увеличивается и доля сложений и доля умножений? Что меняется, с точки зрения числа операций, если делать расчет с двойной точностью?

= Пункт 1.7 =
Правильно я понимаю, что на рисунке изображено вычисление всего произведения матрицы на вектор? Аналогичные блоки для разных строк. А разве не должен быть рисунок, изображающий ядро (то есть произведение одной строки на вектор)?
(я не уверен, поэтому спрашиваю. Возможно, это как-то надо лучше подписать)

__

Нам показалось верным отобразить на рисунке именно параллельную версию, на которой будет видно как и произведение одной строки на вектор, так и вычисление всех элементов. Как следует из определения [[глоссарий#Граф алгоритма|графа алгоритма]], он должен давать удобное представление не только ядра, но и позволять рассмотреть алгоритм с параллельной точки зрения. Внесли небольшое пояснение для рисунка.

= Пункт 1.8 =

----

'''При классификации по высоте ЯПФ, таким образом, алгоритм умножения разреженной матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по высоте ЯПФ его сложность также будет ''линейной''.'''

Два раза повторяется сложность при классификации по высоте ЯПФ

= Пункт 2.4 =
Пока пустой?

__

Поправили

----

Помимо ненулевых элементов нужно указать размерность матрицы и описать матрицу (случайная или нет, если нет, то какая), которая использовалась в экспериментах.

'''Это объясняется быстрым ростом накладных расходов на организацию параллельного выполнения. Это подтверждает предположение о том, что накладные расходы начинают сильно превалировать над вычислениями.'''

Хорошо бы поподробнее описать с чем связаны накладные расходы – обращением к файловой системе или межпроцессорными коммуникациями и какого вида.

Обсуждение участника:Janyell

2016-11-30T22:45:15Z

Evgeny Mortikov:

Добрый день. Подключаюсь к проверке. Статья мне в целом понравилась, и тем больше от этого хочется добавить замечаний, чтобы довести ее до того вида, чтобы она могла остаться на Алговики.

----
----

= Пункт 1.1 =
Разреженная матрица, будучи множеством чисел, не имеющим регулярности, '''не может быть представлена в памяти машины тем же простым способом, что и полная матрица'''. Поэтому возникает необходимость дополнительно хранить индексную информацию, указывающую расположение каждого элемента в регулярном массиве.

Что означает фраза, выделенная жирным? Или как-то переформулируйте утверждение, оно не понятно

'''Однако многие схемы хранения допускают определенную долю нулей, и алгоритм обрабатывает их, как если бы они не были нулями.'''
Тоже непонятно

__

Поправили

= Пункт 1.1.1.1 =
Поставьте определение ленточной матрицы в начало. Потому что, начиная читать первую фразу, сначала задаешься вопросом, что это такое

__

Поправили

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

__

Поправили

= Пункт 1.1.2 =
'''Достоинство этих процедур, с вычислительной точки зрения, состоит в том, что единственная требуемая матричная операция — это повторное умножение матрицы на последовательность заполненных векторов; сама матрица не меняется.'''
Опять непонятно

__

Не совсем понятно, что именно непонятно. Добавили комментарий

= Пункт 1.3 =
Почему вычислительное ядро только последовательной версии?
Вычислительное ядро (computational kernel) алгоритма - это часть алгоритма, на которую приходится основное время его работы.

__

Поправили

= Пункт 1.4 =
Наверное, вопрос в том, что алгоритм делает помимо запуска вычислительных ядер?

__

Присвоение элементам заполненного вектора-столбца <math>c</math> результатов запуска вычислительных ядер.

= Пункт 1.5 =
Как была выбрана форма хранения матрицы? Это нужно прокомментировать

__

Комментарий был ранее, в пункте 1.1.2. Продублировали

= Пункт 1.7 =
Правильно я понимаю, что на рисунке изображено вычисление всего произведения матрицы на вектор? Аналогичные блоки для разных строк. А разве не должен быть рисунок, изображающий ядро (то есть произведение одной строки на вектор)?
(я не уверен, поэтому спрашиваю. Возможно, это как-то надо лучше подписать)

__

Нам показалось верным отобразить на рисунке именно параллельную версию, на которой будет видно как и произведение одной строки на вектор, так и вычисление всех элементов. Как следует из определения [[глоссарий#Граф алгоритма|графа алгоритма]], он должен давать удобное представление не только ядра, но и позволять рассмотреть алгоритм с параллельной точки зрения. Внесли небольшое пояснение для рисунка.

= Пункт 2.4 =
Пока пустой?

__

Поправили

Участник:Сергей/Хранение ненулевых элементов разреженной матрицы. Умножение разреженной матрицы на вектор

2016-11-30T22:36:38Z

Evgeny Mortikov:

Автор: [[U:Сергей|Герасимов Сергей]] (619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Разреженная матрица''' — это матрица с преимущественно нулевыми элементами. В противном случае, если бо́льшая часть элементов матрицы ненулевые, матрица считается плотной.

Нет единства в определении того, какое именно количество ненулевых элементов делает матрицу разрежённой. Разные авторы предлагают различные варианты. Для матрицы порядка n число ненулевых элементов:

~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;

~ в каждой строке не превышает 10 в типичном случае;

~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.

Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.

При хранении и преобразовании разрежённых матриц в компьютере бывает полезно, а часто и необходимо, использовать специальные алгоритмы и структуры данных, которые учитывают разрежённую структуру матрицы. Операции и алгоритмы, применяемые для работы с обычными, плотными матрицами, применительно к большим разрежённым матрицам работают относительно медленно и требуют значительных объёмов памяти. Однако разрежённые матрицы могут быть легко сжаты путём записи только своих ненулевых элементов, что снижает требования к компьютерной памяти.

'''Существуют различные форматы хранения разреженных матриц.''' Одни предназначены для хранения матриц специального вида (например, ленточных), другие обеспечивают работу с матрицами общего вида. Ниже рассмотрим некоторые весьма распространенные способы представления разреженных матриц.

По-видимому, наиболее очевидным способом хранения произвольной разреженной матрицы является '''координатный формат''': хранятся только ненулевые элементы матрицы, и их координаты (номера строк и столбцов). При данном подходе хранение матрицы A можно обеспечить в трех одномерных массивах:

~ массив ненулевых элементов матрицы A (обозначим его как values);

~ массив номеров строк матрицы A, соответствующих элементам массива values (обозначим его как rows);

~ массив номеров столбцов матрицы A, соответствующих элементам массива values (обозначим его как cols);

Данный способ представления называют полным, поскольку представлена вся матрица А, и неупорядоченным, поскольку элементы матрицы могут храниться в произвольном порядке.

Хотя многие математические библиотеки поддерживают матрично-векторные операции в координатном формате, данный формат обеспечивает медленный доступ к элементам матрицы, и является затратным по используемой памяти. В рассмотренном выше примере избыточность по памяти образом проявляется в массиве rows, в котором строчные координаты хранятся неоптимальным образом.

Перейдем далее к рассмотрению более экономных форматов хранения. '''Разреженный строчный формат''' - это одна из наиболее широко используемых схем хранения разреженных матриц. Эта схема предъявляет минимальные требования к памяти и в то же время оказывается очень удобной для нескольких важных операций над разреженными матрицами: сложения, умножения, перестановок строк и столбцов, транспонирования, решения линейных систем с разреженными матрицами коэффициентов как прямыми, так и итерационными методами и т. д.

В соответствии с рассматриваемой схемой для хранения матрицы A требуется три одномерных массива:

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его опять как values);

~ массив номеров столбцов для соответствующих элементов массива values (обозначим его как cols);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его pointer). Описание k-й строки хранится в позициях с pointer[k]-й по (pointer[k+1]–1)-ю массивов values и cols. Если pointer[k]=pointer[k+1], то k-я строка пустая. Если матрица A состоит из n строк, то длина массива pointer будет n+1.

Данный способ представления также является полным, и упорядоченным, поскольку элементы каждой строки хранятся в соответствии с возрастанием столбцовых индексов.

Очевидно, что объем памяти, требуемый для хранения вектора pointer, значительно меньше, чем для хранения вектора rows. Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.

Существует также '''разреженный столбцовый формат''', который строится аналогичным способом.

Теперь, разобравшись со способами хранения разреженных матриц, можно перейти к ''алгоритму умножения разреженной матрицы на вектор''. Умножение матрицы на вектор является подзадачей для нахождения решений СЛАУ итерационными методами.

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

Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>

Условимся использовать строчный формат хранения матрицы, который описан выше.

На входе у нас 4 массива: val(ненулевые элементы матрицы), col(номера столбцов), row(массив указателей) и vec(вектор, на который мы умножаем матрицу).

На выходе получим вектор out.

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}, \ i=\overline{0,N-1}</math>, где <math>N</math> - число строк матрицы.

=== Вычислительное ядро алгоритма ===

Ядром алгоритма является вычисление сумм произведений:

<math>out_i = \sum_{j=row_i}^{row_{i+1} - 1} val_j \cdot vec_{col_j}</math>

Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).

=== Макроструктура алгоритма ===

Метод состоит из вычисления неполных скалярных произведений.

[[Файл:sparse.jpg|thumb|center|500px|Рис.1 Умножение разреженной матрицы на вектор]]

Элементы из массива val умножаются на элементы из массива vec с соответствующим индексом. Черным отмечены ненулевые элементы.

=== Схема реализации последовательного алгоритма ===

Предполагается, что матрица представлена в разреженном строчном формате.

for(i=0; i<N; i++)
{
out[i]=0;
for(j=row[i]; j<row[i+1]; j++)
{
out[i] += val[j]*vec[col[j]];
}
}

Внешний цикл - цикл по элементам выходного вектора. Внутренний - цикл по строкам разреженной матрицы.
Во внутреннем цикле реализовано накопление сумм произведений в выходной элемент.
Индекс ''j'' показывает с какого по какой элемент нужно считать из ''val'' (вектор с ненулевыми значениями матрицы), а также позволяет определить в каких столбцах расположены эти значения в матрице (с помощью вектора ''col'').
Минимальное и максимальное значение ''j'' узнается из вектора ''row''.

=== Последовательная сложность алгоритма ===

<math>\bullet \ NZ</math> умножений

<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).

Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.

=== Информационный граф ===

Опишем граф алгоритма.

Граф алгоритма состоит из двух групп вершин, расположенных в целочисленных узлах двух областей одной размерности.

'''Первая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a \cdot b</math>. Координаты области следующие:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math> k </math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>. (На рисунке вместо обозначения ''row'' использовано обозначение ''r'').

Результаты операции - '''промежуточные''' данные алгоритма.

'''Вторая''' группа вершин расположена в двумерной области, соответствующая ей операция вычисляет функцию <math>a + b</math>.
Координаты области таковы:

<math>\cdot</math> <math>i</math> — меняется в диапазоне от <math>0</math> до <math>N-1</math>, принимая все натуральные значения;

<math>\cdot</math> <math>j</math> — меняется в диапазоне от <math>1</math> до <math>k-1</math>, принимая все натуральные значения,

где <math>k = k(i) = row[i+1]-row[i]</math>.

Результат операции:

<math>\cdot</math> при <math>j < k - 1</math> является '''промежуточным''' данным алгоритма;

<math>\cdot</math> при <math>j = k - 1</math> является '''выходным''' данным <math>out[i]</math>.

Описанный граф изображен на Рис.2. Здесь вершины первой группы обозначены красным цветом и отмечены знаком умножения, вершины второй - зелёным цветом и знаком сложения. Вершины, соответствующие входным данным обозначены белым цветом и выходным - синим.

[[Файл:new_sparse.png|thumb|center|1000px|Рис.2 Умножение разреженной матрицы на вектор. Информационный граф]]

=== Ресурс параллелизма алгоритма ===

При наличии бесконечного числа процессоров для умножения разреженной матрицы на вектор потребуется:

~ 1 ярус умножений

~ <math>Z-1</math> операция сложения, где Z - максимальное число ненулевых элементов в строке.

Максимальное число требуемых процессоров - NZ.

=== Входные и выходные данные алгоритма ===

'''Входные данные:'''

~ массив ненулевых элементов матрицы A, в котором они перечислены по строкам от первой до последней (обозначим его как val);

~ массив номеров столбцов для соответствующих элементов массива val (обозначим его как col);

~ массив указателей позиций, с которых начинается описание очередной строки (обозначим его row);

~ вектор, на который будет умножаться матрица (обозначим его vec).

'''Объем входных данных:'''

Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,

~ вектор val - NZ элементов;

~ вектор col - NZ элементов;

~ вектор row - N+1 элемент;

~ вектор vec - M элементов.

'''Выходные данные:'''

Вектор out размером N.

=== Свойства алгоритма ===

Соотношение последовательной и параллельной сложности в случае неограниченных ресурсов, как хорошо видно, является ''линейным''.

Вычислительная мощность алгоритма, как отношение числа операций к суммарному объему входных и выходных данных – чуть меньше ''единицы''.

Данный алгоритм обладает свойством детерминированности.

== Программная реализация алгоритма ==

=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

=== Возможные способы и особенности параллельной реализации алгоритма ===

=== Масштабируемость алгоритма и его реализации ===
Проведём исследование масштабируемости параллельной реализации умножения разреженной матрицы на вектор. Исследование проводилось на вычислительном комплексе [http://hpc.cmc.msu.ru/bgp Blue Gene/P]<ref> Blue Gene/P http://hpc.cmc.msu.ru/bgp</ref>. Вычисления проводились с помощью следующего программного [https://www.dropbox.com/s/gx0s5r0jg58y8wa/main.c кода]<ref>Sparse matrix-vector MPI multiplication </ref>.
Матрицы генерировались случайным образом.

На следующем рисунке показана зависимость времени выполнения алгоритма от числа используемых процессоров и количества ненулевых элементов матрицы. Можно заметить, что скорость вычисления при переходе с последовательной на параллельную версию возросла значительно. Однако, дальнейшее увеличение числа вычислительных устройств не дает сильного прироста производительности. Это объясняется быстрым ростом накладных расходов на организацию параллельного выполнения.

[[Файл:plot_more_points.png|thumb|center|1000px|Рис.3 Умножение разреженной матрицы на вектор. Масштабируемость]]

На рисунке ниже изображен график эффективности в зависимости от числа процессоров и размера задачи. Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.

[[Файл:plot_eff_new.png|thumb|center|1000px|Рис.4 Умножение разреженной матрицы на вектор. Эффективность]]

=== Динамические характеристики и эффективность реализации алгоритма ===

=== Выводы для классов архитектур ===

=== Существующие реализации алгоритма ===

Эффективная работа с разреженными матрицами реализована во многих библиотеках, например, [https://software.intel.com/en-us/intel-mkl Intel Math Kernel Library], базирующуюся на библиотеках BLAS и LAPACK, также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.

== Литература ==

[1] Писсанецки С. Технология разреженных матриц. - М.: Мир, 1988. — 410 с.

[2] https://software.intel.com/sites/default/files/m/d/4/1/d/8/LW_SparseMM_ppt.pdf

Обсуждение участника:Сергей

2016-11-30T22:34:58Z

Evgeny Mortikov: /* Правки */

Хорошая работа, но есть несколько замечаний.

= Пункт 1.1 =

'''~ есть O(n). Такое определение подходит разве что для теоретического анализа асимптотических свойств матричных алгоритмов;'''

'''~ в каждой строке не превышает 10 в типичном случае;'''

'''~ ограничено <math>n^{1+\gamma}</math>, где <math>\gamma < 1</math>.'''

- Если первое определение подходит только для “теоретического анализа”, то чем лучше третье?

- Второе определение, по-моему, не совсем корректно – оно слишком строгое, не понятно, что за типичный случай, почему именно используется привязка к строкам матрицы, почему именно 10 и т.д. Есть ли какие-то ссылки на литературу, где такое определение использовалось для анализа или для практических задач? Нужно пояснить смысл такого определения.

- В силу того, что определить разреженную матрицу строго не получается, то можно упомянуть то, что разреженными матрицами можно считать именно те, для которых применение специализированных алгоритмов обработки и/или хранения является оправданным (см., например, короткое обсуждение в Gilbert et al., Sparse Matrices in MATLAB: Design and Implementation, 1992)

'''Огромные разрежённые матрицы часто возникают при решении таких задач, как дифференциальное уравнение в частных производных.'''

Это предложение нужно переформулировать. Разреженные матрицы часто возникают при решении дифференциальных уравнений именно численными методами.

'''Более того, разреженный строчный формат обеспечивает эффективный доступ к строчкам матрицы; доступ к столбцам по прежнему затруднен. Поэтому предпочтительно использовать этот способ хранения в тех алгоритмах, в которых преобладают строчные операции.'''

Что здесь понимается под эффективностью доступа к строкам матрицы и тем, что доступ к столбцам затруднен? Если речь идет об устройстве компьютерной памяти, то это нужно пояснить, поскольку до этого в разделе описывается просто структура данных.

= Пункт 1.2 =

'''Пусть матрица размером <math>N\times M</math> содержит в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>'''

Из этого определения можно получить матрицу со всеми ненулевыми элементами при <math>N \gg M</math>, тогда <math>N M \ll N^2</math>

= Пункт 1.3 =

'''Итого: <math>NZ</math> умножений + <math>x</math> сложений(<math>NZ-N<x<NZ-1</math>).'''

Оценка для операций сложения здесь не до конца правильная (например, если матрица нулевая). Лучше оценку записать в форме равенства. Или вообще не рассматривать случай нулевых строк.

= Пункт 1.6 =

'''<math>\bullet \ x</math> сложений(<math>NZ-N<x<NZ-1</math>).'''

См. пункт 1.3

'''Всего <math>2NZ</math> операций, где <math>NZ</math> - количество ненулевых элементов.'''

Почему <math>NZ + x = 2NZ?</math>

= Пункт 1.9 =

'''Для матрицы размером <math>N\times M</math>, содержащей в себе <math>NZ</math> ненулевых элементов, где <math>NZ\ll N^2</math>,'''

См. пункт 1.2

= Пункт 1.10 =

'''Данный алгоритм обладает свойством детерминированности.'''

Будет ли влиять выполнение свойства ассоциативности для сложения на детерминированность алгоритма?

= Пункт 2.4 =

Включает ли численный эксперимент генерацию матрицы? Нужно также указать размерность самой матрицы, помимо числа ненулевых элементов.

'''Можно заметить небольшой всплеск эффективности при использовании 64 процессоров.'''

С чем связан этот «всплеск»? С алгоритмом, программой или вычислительной системой?

= Пункт 2.7 =

опечатка - '''... также математических пакет [http://matlab.ru/products/matlab Matlab] имеет собственную реализацию.'''