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

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

2016-12-12T11:50:59Z

Trrufina:

Хорошая работа. Есть несколько замечаний

'''Спасибо! Внесла небольшие правки в статью по замечаниям. На некоторые замечания ответила в этом тексте'''

= Пункт 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 – размер разреженной матрицы.

''' Учитываются, размер разреженной матрицы n, хранится она в формате CSR: 2 nnz + n + 1 памяти, плюс x, плотный вектор размера n'''

= Пункт 2.4 =

Непонятно какая реализация алгоритма использовалась в экспериментах. Если это собственная реализация, то нужно кратко описать язык программирования, библиотеки, которые использовались и т.п.
'''Собственная реализация на языке C, никаких дополнительных библиотек кроме стандартных библиотек языка и mpi.h не использовалось'''

'''4. управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор'''

Разделение матрицы идет только по строкам или по блокам матрицы?
'''Разделение происходит по блокам, которые содержат целое число строк. Число строк на каждом процессоре равно <math>\frac{n}{k}</math>'''

Опечатка - исправила

Нужно описать, что подразумевается под «Matrix size» на рисунках, число ненулевых элементов или размерность матрицы, и указать обе величины в численных экспериментах.
'''«Matrix size» равно <math>n</math>. В экспериментах число ненулевых элементов задавалось как <math>n * \sqrt{n}</math>'''

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

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

Опечатки - исправила.

'''Тестирование производилось на кластере cluster2 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?
'''Потому что очереди из однородных ядер содержат 16 или 32 ядер, мне этого было недостаточно. Cсылку добавила.'''

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

2016-12-12T11:49:13Z

Trrufina: /* Пункт 2.4 */

Хорошая работа. Есть несколько замечаний

= Пункт 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 – размер разреженной матрицы.

''' Учитываются, размер разреженной матрицы n, хранится она в формате CSR: 2 nnz + n + 1 памяти, плюс x, плотный вектор размера n'''

= Пункт 2.4 =

Непонятно какая реализация алгоритма использовалась в экспериментах. Если это собственная реализация, то нужно кратко описать язык программирования, библиотеки, которые использовались и т.п.
'''Собственная реализация на языке C, никаких дополнительных библиотек кроме стандартных библиотек языка и mpi.h не использовалось'''

'''4. управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор'''

Разделение матрицы идет только по строкам или по блокам матрицы?
'''Разделение происходит по блокам, которые содержат целое число строк. Число строк на каждом процессоре равно <math>\frac{n}{k}</math>'''

Опечатка - исправила

Нужно описать, что подразумевается под «Matrix size» на рисунках, число ненулевых элементов или размерность матрицы, и указать обе величины в численных экспериментах.
'''«Matrix size» равно <math>n</math>. В экспериментах число ненулевых элементов задавалось как <math>n * \sqrt{n}</math>'''

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

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

Опечатки - исправила.

'''Тестирование производилось на кластере cluster2 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?
'''Потому что очереди из однородных ядер содержат 16 или 32 ядер, мне этого было недостаточно. Cсылку добавила.'''

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

2016-12-12T11:48:32Z

Trrufina: /* Пункт 2.4 */

Хорошая работа. Есть несколько замечаний

= Пункт 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 – размер разреженной матрицы.

''' Учитываются, размер разреженной матрицы n, хранится она в формате CSR: 2 nnz + n + 1 памяти, плюс x, плотный вектор размера n'''

= Пункт 2.4 =

Непонятно какая реализация алгоритма использовалась в экспериментах. Если это собственная реализация, то нужно кратко описать язык программирования, библиотеки, которые использовались и т.п.
'''Собственная реализация на языке C, никаких дополнительных библиотек кроме стандартных библиотек языка и mpi.h не использовалось'''

'''4. управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор'''

Разделение матрицы идет только по строкам или по блокам матрицы?
'''Разделение происходит по блокам, которые содержат целое число строк. Число строк на каждом процессоре равно <math>\frac{n}{k}</math>'''

Опечатка - исправила

Нужно описать, что подразумевается под «Matrix size» на рисунках, число ненулевых элементов или размерность матрицы, и указать обе величины в численных экспериментах.
'''В экспериментах число ненулевых элементов задавалось как <math>n * \sqrt{n}</math>'''

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

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

Опечатки - исправила.

'''Тестирование производилось на кластере cluster2 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?
'''Потому что очереди из однородных ядер содержат 16 или 32 ядер, мне этого было недостаточно. Cсылку добавила.'''

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

2016-12-12T11:46:01Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{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>nnz</math>), вектор <math>x^n</math>

Существуют различные способы хранения разреженных матриц. Самый простой - каждый ненулевой элемент хранится в виде тройки: строчный индекс, столбцовый индекс, значение элемента. Такой способ хранения позволяет использовать объем памити равный <math>3*nnz</math>. Существуют более экономные форматы, например "Compressed Sparse Row" или "Compressed Sparse Column", хранящие элементы по строкам и столбцам. Данные форматы требуют <math>2*nnz + 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'';
разреженная матрица ''M'' в формате 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 - 1</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> операций.

При классификации по высоте ЯПФ, таким образом, алгоритм умножения матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по ширине ЯПФ его сложность также будет ''линейной''.

''Замечание1:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

''Замечание2:'' для данного формата хранения использование более чем <math>n</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 ИВМ РАН.
http://cluster2.inm.ras.ru/

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-12-12T11:43:41Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{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>nnz</math>), вектор <math>x^n</math>

Существуют различные способы хранения разреженных матриц. Самый простой - каждый ненулевой элемент хранится в виде тройки: строчный индекс, столбцовый индекс, значение элемента. Такой способ хранения позволяет использовать объем памити равный <math>3*nnz</math>. Существуют более экономные форматы, например "Compressed Sparse Row" или "Compressed Sparse Column", хранящие элементы по строкам и столбцам. Данные форматы требуют <math>2*nnz + 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'';
разреженная матрица ''M'' в формате 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 - 1</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> операций.

При классификации по высоте ЯПФ, таким образом, алгоритм умножения матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по ширине ЯПФ его сложность также будет ''линейной''.

''Замечание1:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

''Замечание2:'' для данного формата хранения использование более чем <math>n</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-12T11:42:06Z

Trrufina: /* Пункт 2.4 */

Хорошая работа. Есть несколько замечаний

= Пункт 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 – размер разреженной матрицы.

''' Учитываются, размер разреженной матрицы n, хранится она в формате CSR: 2 nnz + n + 1 памяти, плюс x, плотный вектор размера n'''

= Пункт 2.4 =

Непонятно какая реализация алгоритма использовалась в экспериментах. Если это собственная реализация, то нужно кратко описать язык программирования, библиотеки, которые использовались и т.п.
'''Собственная реализация на языке C, никаких дополнительных библиотек кроме стандартных библиотек языка и mpi.h не использовалось'''

'''4. управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор'''

Разделение матрицы идет только по строкам или по блокам матрицы?
'''Разделение происходит по блокам, которые содержат целое число строк. Число строк на каждом процессоре равно <math>\frac{n}{k}</math>'''

Опечатка - исправила

Нужно описать, что подразумевается под «Matrix size» на рисунках, число ненулевых элементов или размерность матрицы, и указать обе величины в численных экспериментах.

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

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

Опечатки - исправила.

'''Тестирование производилось на кластере cluster2 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?
'''Потому что очереди из однородных ядер содержат 16 или 32 ядер, мне этого было недостаточно'''

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

2016-12-12T11:33:07Z

Trrufina: /* Пункт 1.9 */

Хорошая работа. Есть несколько замечаний

= Пункт 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 – размер разреженной матрицы.

''' Учитываются, размер разреженной матрицы n, хранится она в формате CSR: 2 nnz + n + 1 памяти, плюс x, плотный вектор размера n'''

= Пункт 2.4 =

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

'''4. управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор'''

Разделение матрицы идет только по строкам или по блокам матрицы?

Опечатка - '''Данный алгоритм несмотря на кажщуюся простоту'''

Нужно описать, что подразумевается под «Matrix size» на рисунках, число ненулевых элементов или размерность матрицы, и указать обе величины в численных экспериментах.

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

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

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

'''Тестирование производилось на кластере cluster2 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?

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

2016-12-12T11:31:26Z

Trrufina: /* Пункт 1.9 */

Хорошая работа. Есть несколько замечаний

= Пункт 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 ИВМ РАН.'''

Нужно добавить ссылку на описание кластера.
Почему не проводились эксперименты только на очередях из однородных ядер на кластере ИВМ?

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

2016-12-12T11:29:58Z

Trrufina: /* Ресурс параллелизма алгоритма */

{{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>nnz</math>), вектор <math>x^n</math>

Существуют различные способы хранения разреженных матриц. Самый простой - каждый ненулевой элемент хранится в виде тройки: строчный индекс, столбцовый индекс, значение элемента. Такой способ хранения позволяет использовать объем памити равный <math>3*nnz</math>. Существуют более экономные форматы, например "Compressed Sparse Row" или "Compressed Sparse Column", хранящие элементы по строкам и столбцам. Данные форматы требуют <math>2*nnz + 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'';
разреженная матрица ''M'' в формате 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 - 1</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> операций.

При классификации по высоте ЯПФ, таким образом, алгоритм умножения матрицы на вектор относится к алгоритмам ''с линейной сложностью''. При классификации по ширине ЯПФ его сложность также будет ''линейной''.

''Замечание1:'' если число процессоров <math>k</math> меньше числа строк, но отношение <math>\frac{n}{k} = c</math> является константой, то каждый процессор вычисляет <math>c</math> элементов результирующего вектора, и число ярусов не более чем <math>cn</math>. Таким образом, предыдущие оценки сложности сохранятся.

''Замечание2:'' для данного формата хранения использование более чем <math>n</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.

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

2016-12-12T11:27:01Z

Trrufina: /* Последовательная сложность алгоритма */

{{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>nnz</math>), вектор <math>x^n</math>

Существуют различные способы хранения разреженных матриц. Самый простой - каждый ненулевой элемент хранится в виде тройки: строчный индекс, столбцовый индекс, значение элемента. Такой способ хранения позволяет использовать объем памити равный <math>3*nnz</math>. Существуют более экономные форматы, например "Compressed Sparse Row" или "Compressed Sparse Column", хранящие элементы по строкам и столбцам. Данные форматы требуют <math>2*nnz + 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'';
разреженная матрица ''M'' в формате 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 - 1</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.

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

2016-12-12T11:26:29Z

Trrufina: /* Макроструктура алгоритма */

{{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>nnz</math>), вектор <math>x^n</math>

Существуют различные способы хранения разреженных матриц. Самый простой - каждый ненулевой элемент хранится в виде тройки: строчный индекс, столбцовый индекс, значение элемента. Такой способ хранения позволяет использовать объем памити равный <math>3*nnz</math>. Существуют более экономные форматы, например "Compressed Sparse Row" или "Compressed Sparse Column", хранящие элементы по строкам и столбцам. Данные форматы требуют <math>2*nnz + 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'';
разреженная матрица ''M'' в формате 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.

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

2016-12-12T11:25:21Z

Trrufina:

{{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>nnz</math>), вектор <math>x^n</math>

Существуют различные способы хранения разреженных матриц. Самый простой - каждый ненулевой элемент хранится в виде тройки: строчный индекс, столбцовый индекс, значение элемента. Такой способ хранения позволяет использовать объем памити равный <math>3*nnz</math>. Существуют более экономные форматы, например "Compressed Sparse Row" или "Compressed Sparse Column", хранящие элементы по строкам и столбцам. Данные форматы требуют <math>2*nnz + 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.

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

2016-11-09T18:24:55Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Dan}}

{{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.

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

2016-11-09T14:07:56Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Dan}}

{{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 ИВМ РАН.

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-11-09T13:56:07Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Dan}}

{{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>

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-11-09T13:51:02Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Dan}}

{{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>

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

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

<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|Caption 1]] </li>
<li style="display: inline-block;"> [[File:effc_clrc.png|thumb|none|800px|Caption 2]] </li>
</ul></div>

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-11-09T13:40:27Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Dan}}

{{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>
# управляющий процессор разделяет матрицу на блоки в зависимости от числа процессоров и рассылает остальным процессорам строки матрицы и вектор
# все процессоры вычисляют произведение своего блока матрицы на вектор
# управляющий процессор собирает результаты
Данный алгоритм несмотря на кажщуюся простоту оказывается весьма неэффективен, так как время пересылок оказывается на порядки больше времени вычисления. Более того, при большом количестве процессоров время выполнения параллельной программы оказывается больше времени выполнения последовательной программы.
<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>

<div><ul>
<li style="display: inline-block;"> [[File:perf_drtc.png|thumb|none|800px|Caption 1]] </li>
<li style="display: inline-block;"> [[File:effc_drtc.png|thumb|none|800px|Caption 2]] </li>
</ul></div>

<div><ul>
<li style="display: inline-block;"> [[File:perf_clrc.png|thumb|none|800px|Caption 1]] </li>
<li style="display: inline-block;"> [[File:effc_clrc.png|thumb|none|800px|Caption 2]] </li>
</ul></div>

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-11-09T13:32:11Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{Assignment|Dan}}

{{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> - для параллельного алгоритма.

== ЧАСТЬ. Программная реализация алгоритма ==

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Наитивная реализация алгоритма следующая:
\item один процессор назначается управляющим
\item управляющий процессор считывает или генерирует (если матрица задается известной формулой) матрицу в CSR формате
\item управляющий процессор считывает или генерирует вектор $x$
<div><ul>
<li style="display: inline-block;"> [[File:perf_drto.png|thumb|none|800px|Caption 1]] </li>
<li style="display: inline-block;"> [[File:effc_drto.png|thumb|none|800px|Caption 2]] </li>
</ul></div>

<div><ul>
<li style="display: inline-block;"> [[File:perf_drtc.png|thumb|none|800px|Caption 1]] </li>
<li style="display: inline-block;"> [[File:effc_drtc.png|thumb|none|800px|Caption 2]] </li>
</ul></div>

<div><ul>
<li style="display: inline-block;"> [[File:perf_clrc.png|thumb|none|800px|Caption 1]] </li>
<li style="display: inline-block;"> [[File:effc_clrc.png|thumb|none|800px|Caption 2]] </li>
</ul></div>

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-11-09T13:28:53Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

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

2016-11-09T13:14:46Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

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

2016-11-03T11:12:51Z

Trrufina:

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

2016-10-31T12:43:18Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{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> операций.

[[Файл:1111.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-матрицу и вектор
Управляющий процессор рассылает всем блоки матрицы и вектор для вычислений
Все процессоры производят вычисления
Управляющий процессор собирает результаты в один вектор

Эксперимент показал, что масштабируемость алгоритма в существенной степени определяется его реализацией и особенностями параллельной вычислительной системы. В частности имеется сильная зависимость времени вычисления от скорости обмена данными между процессорами. Например, если замерить время непосредственных вычислений на всех процессорах (операция синхронизируется при помощи барьеров), и время выполнения всей параллельной программы, то второе будет отличаться от первого примерно на порядок. Производительность также существенно различается (Рисунки 1 и 2). "Чистая" вычислительная производительность будет выше при наибольшем числе процессоров, и некоторых определенных размерах матриц (возможно, причина в локальности данных), в остальных случаях производительность не имеет существенных пиков. Производительность с учетом пересылок данных значительно ниже, и достигает наилучших значений при наименьшем числе процессоров (наименьшем числе пересылок). Эффективность, показанная на рисунках 3 и 4, также сильно разнится. "Чистая" эффективность имеет пики, в которых алгоритм сверхпроизводителен, ускорение сверхлинейное. Пики наблюдаются в точках наивысшей производительности, а также при малом числе процессоров, где время последовательного исполнения программы велико. Эффективность с учетом пересылок данных схожа с производительностью, достигает наилучших значений при малом числе процессоров, а также наблюдается рост с увеличением размера матриц.

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

[[Файл:perf_clr.png|800x800px|center|thumb|Рис. 1. Чистая производительность вычислений]]

[[Файл:perf_drt.png|800x800px|center|thumb|Рис. 2. Производительность вычислений с учетом пересылок данных]]

[[Файл:effc_clr.png|800x800px|center|thumb|Рис. 3. Чистая эффективность параллельного алгоритма ]]

[[Файл:effc_drt.png|800x800px|center|thumb|Рис. 4. Эффективность параллельного алгоритма с учетом пересылок данных]]

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-31T12:23:13Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{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> операций.

[[Файл:1111.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> - для параллельного алгоритма.

== ЧАСТЬ. Программная реализация алгоритма ==

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Эксперимент показал, что масштабируемость алгоритма в существенной степени определяется его реализацией и особенностями параллельной вычислительной системы. В частности имеется сильная зависимость времени вычисления от скорости обмена данными между процессорами. Например, если замерить время непосредственных вычислений на всех процессорах (операция синхронизируется при помощи барьеров), и время выполнения всей параллельной программы, то второе будет отличаться от первого примерно на порядок. Производительность также существенно различается (Рисунки 1 и 2). "Чистая" вычислительная производительность будет выше при наибольшем числе процессоров, и некоторых определенных размерах матриц (возможно, причина в локальности данных), в остальных случаях производительность не имеет существенных пиков. Производительность с учетом пересылок данных значительно ниже, и достигает наилучших значений при наименьшем числе процессоров (наименьшем числе пересылок). Эффективность, показанная на рисунках 3 и 4, также сильно разнится. "Чистая" эффективность имеет пики, в которых алгоритм сверхпроизводителен, ускорение сверхлинейное. Пики наблюдаются в точках наивысшей производительности, а также при малом числе процессоров, где время последовательного исполнения программы велико. Эффективность с учетом пересылок данных схожа с производительностью, достигает наилучших значений при малом числе процессоров, а также наблюдается рост с увеличением размера матриц.

[[Файл:perf_clr.png|800x800px|center|thumb|Рис. 1. Чистая производительность вычислений]]

[[Файл:perf_drt.png|800x800px|center|thumb|Рис. 2. Производительность вычислений с учетом пересылок данных]]

[[Файл:effc_clr.png|800x800px|center|thumb|Рис. 3. Чистая эффективность параллельного алгоритма ]]

[[Файл:effc_drt.png|800x800px|center|thumb|Рис. 4. Эффективность параллельного алгоритма с учетом пересылок данных]]

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-31T12:17:19Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

{{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> операций.

[[Файл:1111.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> - для параллельного алгоритма.

== ЧАСТЬ. Программная реализация алгоритма ==

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

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

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

=== Масштабируемость алгоритма и его реализации ===
Эксперимент показал, что масштабируемость алгоритма в существенной степени определяется его реализацией и особенностями параллельной вычислительной системы. В частности имеется сильная зависимость времени вычисления от скорости обмена данными между процессорами. Например, если замерить время непосредственных вычислений на всех процессорах (операция синхронизируется при помощи барьеров), и время выполнения всей параллельной программы, то второе будет отличаться от первого примерно на порядок. Производительность также существенно различается (Рисунки 1 и 2). "Чистая" вычислительная производительность будет выше при наибольшем числе процессоров, и некоторых определенных размерах матриц (возможно, причина в локальности данных), в остальных случаях производительность не имеет существенных пиков. Производительность с учетом пересылок данных значительно ниже, и достигает наилучших значений при наименьшем числе процессоров (наименьшем числе пересылок). Эффективность, показанная на рисунках 3 и 4, также сильно разнится.

[[Файл:perf_clr.png|800x800px|center|thumb|Рис. 1. Чистая производительность вычислений]]

[[Файл:perf_drt.png|800x800px|center|thumb|Рис. 2. Производительность вычислений с учетом пересылок данных]]

[[Файл:effc_clr.png|800x800px|center|thumb|1 ]]

[[Файл:effc_drt.png|800x800px|center|thumb|1 ]]

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-31T11:56:38Z

Trrufina:

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

2016-10-31T11:42:49Z

Trrufina: /* Масштабируемость алгоритма и его реализации */

Файл:Perf drt.png

2016-10-31T11:37:27Z

Trrufina:

Файл:Perf clr.png

2016-10-31T11:37:06Z

Trrufina:

Файл:Effc drt.png

2016-10-31T11:35:59Z

Trrufina:

Файл:Effc clr.png

2016-10-31T11:35:01Z

Trrufina:

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

2016-10-27T17:57:07Z

Trrufina:

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

2016-10-13T20:50:16Z

Trrufina: /* Информационный граф */

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

2016-10-13T20:49:22Z

Trrufina: /* Информационный граф */

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

2016-10-13T20:49:02Z

Trrufina: /* Информационный граф */

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

2016-10-13T20:47:07Z

Trrufina: /* Информационный граф */

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

2016-10-13T20:11:24Z

Trrufina: /* Информационный граф */

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

2016-10-13T20:10:59Z

Trrufina:

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

2016-10-13T20:01:45Z

Trrufina: /* Ресурс параллелизма алгоритма */

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

2016-10-13T20:01:24Z

Trrufina: /* Ресурс параллелизма алгоритма */

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

2016-10-13T19:50:42Z

Trrufina: /* Ресурс параллелизма алгоритма */

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

2016-10-13T19:30:53Z

Trrufina:

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

2016-10-13T19:15:45Z

Trrufina: /* Информационный граф */

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

2016-10-13T17:49:14Z

Trrufina: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:45:59Z

Trrufina: /* Математическое описание алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></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>

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
число строк матрицы ''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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:39:06Z

Trrufina:

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></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 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:36:00Z

Trrufina: /* Математическое описание алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></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>. Подытожив все вышесказанное получим, что каждый элемент итогового вектора определятся формулой

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:29:05Z

Trrufina: /* Математическое описание алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></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>).

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:23:11Z

Trrufina: /* Математическое описание алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></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> умножений и сложений.
Если при умножении плотной матрицы на вектор каждый элемент результата определяется по формуле

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:18:18Z

Trrufina: /* Свойства алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</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> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.

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

2016-10-13T17:17:41Z

Trrufina: /* Свойства алгоритма */

{{algorithm
| name = Умножение разреженной матрицы на вектор
| serial_complexity = <math>nnz</math>
| pf_height = <math></math>
| pf_width = <math></math>
| input_data = <math>2(nnz+n)+1</math>
| output_data = <math>n</math>
}}
Авторы статьи: [[Участница:Руфина_Третьякова|Третьякова Р. М.]] (группа 603), [[Участница:Екатерина_Буторина|Буторина Е. В.]] (группа 603)

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

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

=== Математическое описание алгоритма ===
Исходные данные: разреженная матрица <math>M^{n*n}</math>, вектор <math>x^{n*1}</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> умножений и сложений.

Например, это разреженная матрица с 4-мя ненулевыми элементами
:: <math>\begin{pmatrix}
0 & 0 & 0 & 1 \\
2 & 0 & 0 & 0 \\
0 & 0 & 3 & 0 \\
0 & 4 & 0 & 0 \\
\end{pmatrix}</math>,
представляемая в формате CSR
A = [ 1 2 3 4 ]
IA = [ 0 1 2 3 4 ]
JA = [ 3 0 2 1 ]

Вычисляемые данные: вектор <math>M*x=y</math>

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

:<math>y_i = \sum_{k = IA_i}^{IA_{i+1}} A_k x_{JA_k}</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>n</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> - для параллельного алгоритма.

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

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

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

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

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

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

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

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

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

Последовательная реализация имеется в пакете 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.