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

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

2017-01-06T22:39:49Z

Joinmek:

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма. Но если наложить ограничение на минимально допустимую величину отрезка, как было сделано ранее, то его можно оценить следующим образом: O((B - A) / (G * p)), где p -количество процессов. Каждый процесс считает интеграл на своем отрезке вне зависимости от других процессов, влияние других процессоров происходит исключительно в момент ожидания получения доступа к глобальному стеку.

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T02:13:52Z

Joinmek:

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма. Но если наложить ограничение на минимально допустимую величину отрезка, как было сделано ранее, то его можно оценить следующим образом: O((B - A) / (G * p)), где p -количество процессов. Каждый процесс считает интеграл на своем отрезке вне зависимости от других процессов, влияние других процессоров происходит исключительно в момент ожидания получения доступа к глобальному стеку.

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T02:13:17Z

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

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

2016-12-20T02:10:21Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма. Но если наложить ограничение на минимально допустимую величину отрезка, как было сделано ранее, то его можно оценить следующим образом: O((B - A) / (G * p)), где p -количество процессов. Каждый процесс считает интеграл на своем отрезке вне зависимости от других процессов, взаимодействие происходит исключительно в момент ожидания получения доступа к глобальному стеку.

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T02:10:20Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма. Но если наложить ограничение на минимально допустимую величину отрезка, как было сделано ранее, то его можно оценить следующим образом: O((B - A) / (G * p)), где p -количество процессов. Каждый процесс считает интеграл на своем отрезке вне зависимости от других процессов, взаимодействие происходит исключительно в момент ожидания получения доступа к глобальному стеку.

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T02:00:30Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T02:00:29Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T02:00:28Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T01:58:37Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T01:58:36Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность остается примерно на том же уровне.

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

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

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

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

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

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

2016-12-20T01:49:17Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма на системе с общей памятью, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность медленно падает.

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

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

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

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

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

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

2016-12-20T01:48:18Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки масштабируемости алгоритма, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность медленно падает.

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

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

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

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

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

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

2016-12-20T01:43:08Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки эффективности алгоритма, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность медленно падает.

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

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

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

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

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

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

2016-12-20T01:41:10Z

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

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

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

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

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

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

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

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

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

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

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

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

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

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

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

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

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

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

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

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

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

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

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

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

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

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

4. Иначе

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

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

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

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

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

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

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

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

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

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

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

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

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

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

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

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

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

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

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

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

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

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

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

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

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

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

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

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

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

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

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

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

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

Для оценки эффективности алгоритма, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность медленно падает.

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

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

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

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

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

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

2016-12-20T01:41:09Z

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

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

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

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

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

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

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

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

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

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sAB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

Для оценки эффективности алгоритма, реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] была запущена на архитектуре IBM pSeries 690 HPC Regatta. Программа запускалась на 1, 2, 4, 8 и 16 потоках. Точность так же, как и в первом случае, градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута 2 потоках и равна 0.9504; минимальная - на 16, ее величина - 0.67484. При увеличении количества потоков эффективность падает из-за конкуренции доступа к глобальному стеку. При увеличении сложности для одинакового числа процессов эффективность медленно падает.

[[Файл:VM_time_regatta.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]
[[Файл:VM_efficiency_regatta.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-20T01:27:50Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sAB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

[[Файл:VM_time_regatta.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]
[[Файл:VM_efficiency_regatta.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-20T01:24:57Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sAB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

[[Файл:VM_time_regatta.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]
[[Файл:VM_efficiency_regatta.png|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-19T20:17:48Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sAB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-19T20:17:47Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sAB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-19T20:17:08Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| <= ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-19T20:17:07Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| <= ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-19T19:42:45Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.

Чтобы продемонстрировать работу алгоритма на архитектуре BlueGene, было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpixlcxx_r с опцией -O2. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-18T15:24:26Z

Joinmek: /* Свойства алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма на основе общей памяти не требуется управляющий процесс. На системах с распределенной памятью отдельный управляющий процесс также не нужен. Распределение отрезков и финальное сложение можно провести на нулевом процессе.

4. Алгоритм является детерминированным. На это свойство влияет выполнение свойства ассоциативности сложения, но не влияют свойства интегрируемой функции.

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым не для всех функций. Например, для sinx алгоритм неустойчив. Можно рассмотреть отрезки интегрирования [0, 2*pi] и [0, 2*pi + delta]. В первом случае, алгоритм остановится на первой итерации, и значение интеграла будет равно 0. При изменении правой границы отрезка на малое delta, алгоритм не остановится на первой итерации, и значение интеграла будет сильно отличаться от 0.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-18T14:41:56Z

Joinmek: /* Информационный граф */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-18T14:41:55Z

Joinmek: /* Информационный граф */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке. Такой вариант проще реализовать, но его недостаток в том, что увеличивается количество обращений процессов к глобальному стеку, и каждый процесс должен ждать своей очереди, что может привести к увеличению времени работы программы.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-18T14:30:26Z

Joinmek: /* Последовательная сложность алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.
Если предположить, что алгоритм будет останавливаться при достижении длины отрезка меньше некоторого порога G, то сложность можно оценить как O((B - A) / G).

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-18T14:00:42Z

Joinmek: /* Общее описание алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение интеграла от новой (упрощенной) функции, после чего значения интегралов суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Обсуждение участника:Joinmek

2016-11-22T16:31:06Z

Joinmek:

== Статья [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2)]] ==

* Нет краткой сводки свойств алгоритма в начале страницы (Исправлено)
* Нумерация подразделов не соответствует шаблону (Исправлено)
* Разделы 1.6 и 1.8 (6 и 8 в оригинальной статье) не заполнены (Исправлено)
* Картинка в разделе 1.7 (7) не является информационным графом (Исправлено)
** Если это информационный граф, из него следует, что алгоритм строго последовательный. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
** Приведённый граф очень мелкий, надписи практически нечитаемы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Раздел 2.7 отсутствует (Исправлено)
* Список литературы отсутствует (Исправлено)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:03, 16 ноября 2016 (MSK) (Исправлено)
* Рисунки в статье не подписаны и не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:30:14Z

Joinmek:

{{assignment}}

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:22:48Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках, а также библиотека OpenMPI версии 1.68.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:21:42Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:21:18Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

--<source lang="C">
LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:20:47Z

Joinmek: /* Схема реализации алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

<source lang="C">
LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:14:03Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:11:57Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:11:56Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.3. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.4. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T16:10:14Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene]. Использовался компилятор mpicc версии 4.1.2 с опцией -lm. Внутри программы использовалась стандартная библиотека языка C - math, которая была выбрана для подсчета функции синуса в заданных точках.

[[Файл:VM_Time1.png|800px|center|thumb|Рис.2. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.3. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Масштабируемость:

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

При увеличении числа процессов эффективность программы падает, т. к. увеличиваются накладные расходы, а также по причине того, что некоторым процессам попадаются более трудоемкие участки интегрирования, из-за которых остальным процессам приходится ожидать.

При фиксированном количестве процессов и увеличении сложности задачи (уменьшении точности), эффективность падает, но очень медленно.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Обсуждение участника:Joinmek

2016-11-22T14:19:51Z

Joinmek:

== Статья [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2)]] ==

* Нет краткой сводки свойств алгоритма в начале страницы (Исправлено)
* Нумерация подразделов не соответствует шаблону (Исправлено)
* Разделы 1.6 и 1.8 (6 и 8 в оригинальной статье) не заполнены (Исправлено)
* Картинка в разделе 1.7 (7) не является информационным графом (Исправлено)
** Если это информационный граф, из него следует, что алгоритм строго последовательный. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
** Приведённый граф очень мелкий, надписи практически нечитаемы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Раздел 2.7 отсутствует (Исправлено)
* Список литературы отсутствует (Исправлено)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:03, 16 ноября 2016 (MSK) (Исправлено)
* Рисунки в статье не подписаны и не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK)

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T13:13:00Z

Joinmek: /* Информационный граф */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|700px|center|thumb|Рис.2. Информационный граф для алгоритма глобального стека. Ch - выбор отрезка интегрирования, Sq - вычисление площади на отрезке, Div - деление отрезка пополам, Tol - проверка достижения точности, Wr - запись отрезка в лок./глоб. стек, Sum - суммирование результатов]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center|thumb|Рис.2. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.3. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T13:06:17Z

Joinmek: /* Информационный граф */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:VM_Graph1.png|500px|center|thumb|Информационный граф для алгоритма глобального стека]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center|thumb|Рис.2. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.3. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Обсуждение участника:Joinmek

2016-11-22T09:36:20Z

Joinmek:

== Статья [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2)]] ==

* Нет краткой сводки свойств алгоритма в начале страницы (Исправлено)
* Нумерация подразделов не соответствует шаблону (Исправлено)
* Разделы 1.6 и 1.8 (6 и 8 в оригинальной статье) не заполнены (Исправлено)
* Картинка в разделе 1.7 (7) не является информационным графом (Исправлено)
** Если это информационный граф, из него следует, что алгоритм строго последовательный. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK)
** Приведённый граф очень мелкий, надписи практически нечитаемы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK)
* Раздел 2.7 отсутствует (Исправлено)
* Список литературы отсутствует (Исправлено)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:03, 16 ноября 2016 (MSK) (Исправлено)
* Рисунки в статье не подписаны и не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK)

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T09:35:17Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:1478004288745.png|500px|center]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center|thumb|Рис.2. Зависимость времени работы алгоритма от числа процессов и заданной точности]]

[[Файл:VM_Efficiency1.png|800px|center|thumb|Рис.3. Зависимость эффективности алгоритма от числа процессов и заданной точности]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-22T09:33:09Z

Joinmek: /* Общее описание алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center|thumb|Рис.1. Метод трапеций]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:1478004288745.png|500px|center]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center]]

[[Файл:VM_Efficiency1.png|800px|center]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-18T15:37:46Z

Joinmek:

{{assignment}}

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:1478004288745.png|500px|center]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center]]

[[Файл:VM_Efficiency1.png|800px|center]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Обсуждение участника:Joinmek

2016-11-18T15:37:02Z

Joinmek: /* Статья Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2) */

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-18T15:33:08Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:1478004288745.png|500px|center]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center]]

[[Файл:VM_Efficiency1.png|800px|center]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-18T15:32:46Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:1478004288745.png|500px|center]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY] на языке C.
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а ,значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center]]

[[Файл:VM_Efficiency1.png|800px|center]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-18T15:32:03Z

Joinmek: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| input_data = <math>O(1)</math>
| output_data = <math>O(1)</math>
}}

Основные авторы описания: [[Участник:Joinmek|Можарова В. А.]]

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Основная идея большинства методов численного интегрирования состоит в замене подынтегральной функции на более простую, интеграл от которой легко вычисляется аналитически. При замене подынтегральной функции на полином нулевой, первой и второй степени получаются соответственно методы прямоугольников, трапеций и парабол (Симпсона).

[[Файл:vm_trap.png|300px|center]]

Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках. Но чтобы посчитать интеграл с определенной точностью, мы не можем заранее узнать, какие размеры отрезков, нужно использовать, т. к. это зависит от самой функции. Для этого используют адаптивное разбиение участка интегрирования: размер конкретного отрезка определяется во время подсчета значения функции на нем самом. Если заданная точность не была достигнута на данном отрезке, он рекурсивно разбивается на несколько новых и функция подсчитывается уже на них. Таким образом, выигрыш от применения рассмотренного алгоритма рекурсивного разбиения достигается за счет возможности использования сеток с разным числом узлов на разных участках интервала интегрирования.

=== Математическое описание алгоритма ===
Пусть у нас есть интеграл, который надо вычислить с точностью ε:

[[Файл:vm_integral.png|200px|center]]

Предположим, что в результате адаптации сетки для данной функции, на отрезке [A, B] получилась сетка, содержащая n + 1 узел. Тогда согласно методу трапеций, можно численно найти определенный интеграл от функции f(x) на отрезке [A, B]:

[[Файл:vm_common.png|400px|center]]

Будем полагать значение J найденным с точностью ε, если выполнено условие:

[[Файл:vm_condition.png|300px|center]]

где n1 и n2 - количество узлов, образующих две разные сетки.
Пользуясь формулой

[[Файл:vm_div.png|400px|center]]

рекурсивно делим отрезки интегрирования до достижения на них заданной точности.

=== Вычислительное ядро алгоритма ===
Основное время работы алгоритма приходится на вычисление площадей на отрезках, получившихся в результате рекурсивного разбиения:

[[Файл:vm_sq.png|400px|center]]

=== Макроструктура алгоритма ===

Алгоритм итеративный. Сначала значение текущего отрезка равно общему отрезу интегрирования. На каждой итерации:

1. На текущем отрезке считается приближенное значение интеграла

2. Текущий отрезок делится пополам, и на получившихся отрезках высчитываются новые интегралы

3. Если достигнута заданная точность, то

3.1 Добавить значение интеграла текущего отрезка к общему интегралу

3.2 Если стек пуст, то завершить алгоритм

3.3 Достать из стека отрезок и присвоить его значение текущему отрезку.

4. Иначе

4.1 Один из получившихся маленьких отрезков положить в стек

4.2 Текущему отрезку присвоить значение второго маленького отрезка

=== Схема реализации алгоритма ===

Для хранения отрезков интегрирования в данном алгоритме понадобится стек <ref>Якобовский М. В., Кулькова Е. Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. Москва, 2004.</ref>.

sp=0 // указатель вершины стека
struct {
A, B, fA, fB, s
} stk[1000]

У стека определен следующий набор операций:

1. PUT_INTO_STACK - положить элемент в стек

#define PUT_INTO_STACK(A, B, fA, fB, s)
{
stk[sp].A=A
stk[sp].B=B
stk[sp].fA=fA
stk[sp].fB=fB
stk[sp].s=s
sp++
}

2. GET_FROM_STACK - взять верхний элемент из стека
#define GET_FROM_STACK(A, B, fA, fB, s)
{
sp--
A=stk[sp].A
B=stk[sp].B
fA=stk[sp].fA
fB=stk[sp].fB
s=stk[sp].s
}

3. STACK_IS_NOT_FREE - проверить стек на наличие в нем элементов
#define STACK_IS_NOT_FREE (sp > 0)

LocalStack (A, B)
{
// В переменной J храним ответ
J=0
// Вычисляем значение функции на границах интегрируемого отрезка
fA = f(A)
fB = f(B)
// Вычисляем площадь с помощью метода трапеций
sAB = (fA + fB) * (B - A) / 2
while (1)
{
C = (A + B) / 2 // Находим середину отрезка
fc = f(C) // Вычисляем в середине значение функции
// Считаем приближенное значение интеграла на получившихся отрезках
sAC = (fA + fC) * (C - A) / 2
sCB = (fC + fB ) * (B-C) / 2
sACB = sAC + sCB
if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута
PUT_INTO_STACK(A, C, fA, fC, sAC) // то один из отрезков кладем в стек
A = C // и решаем задачу для оставшегося отрезка
fA = fC
sAB = sCB
} else // Если заданная точность достигнута
{
J += sACB // то к общей сумме добавляем полученное число
if (STACK_IS_NOT_FREE) // если стек пуст, то цикл завершается - ответ получен
break
GET_FROM_STACK(A, B, fA, fB, sAB) // иначе берем из стека новый отрезок
}
}
return J
}

=== Последовательная сложность алгоритма ===
Количество делений отрезков интегрирования зависит от сложности входной функции, поэтому нельзя оценить сложность данного алгоритма.

=== Информационный граф ===
В параллельной версии алгоритма, появляется дополнительный глобальный стек, доступ к которому имеют все процессы. Он находится в общей памяти и так же содержит границы отрезков. Процессы обмениваются с ним данными, распределяя таким образом отрезки между собой. Когда в локальном стеке заканчиваются элементы, процесс обращается к глобальному стеку, чтобы получить их. Причем любой процесс может отдавать ему отрезки, если глобальный стек пуст в то время, как локальный имеет более одного отрезка. Изначально в глобальный стек помещается один отрезок, соответствующий участку интегрирования. Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.

[[Файл:1478004288745.png|500px|center]]

=== Ресурс параллелизма алгоритма ===
Сложность параллельного алгоритма нельзя оценить из-за зависимости от сложности интегрируемой функции так же, как и у последовательного алгоритма.

=== Входные и выходные данные алгоритма ===
На вход алгоритму подается подынтегральная функция, пределы интегрирования и значение точности, с которой нужно посчитать заданный интеграл.
На выходе: число – значение определенного интеграла.
=== Свойства алгоритма ===

1. Алгоритм адаптируется под сложность функции

2. Для каждого узла сетки значение функции высчитывается один раз

3. В параллельной версии алгоритма не требуется управляющий процесс

4. Алгоритм является детерминированным

5. Степень исхода вершины информационного графа равна 1, т. к. результат работы каждого процесса в дальнейшем используется только 1 раз.

6. В представленном параллельном алгоритме сбалансирована загрузка процессов, т. к. при завершении своих задач каждый процессор обращается за новыми в глобальный стек

7. Данный алгоритм является устойчивым

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Автором данной статьи была выбрана реализация [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH AACHEN UNIVERSITY].
Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а ,значит, ограничена одним узлом.

Тогда было принято решение модифицировать данный алгоритм, разделив отрезок интегрирования на равные части, количество которых равно количеству запущенных процессов ([https://bitbucket.org/FilmSearchers/globalstack/src Code]). Каждый из них считает интеграл на своем участке, а затем отправляет результат нулевому процессу, на котором происходит суммирование.

Чтобы протестировать систему была выбрана функция sin(x). Вычисление интеграла запускается с разными значениями точности, чтобы пронаблюдать за изменением времени в зависимости от количества итоговых отрезков. Программа запускалась на [https://ru.wikipedia.org/wiki/Blue_Gene Blue Gene].

[[Файл:VM_Time1.png|800px|center]]

[[Файл:VM_Efficiency1.png|800px|center]]

Система запускалась на количестве процессов от 8 до 128, начиная с 16 процессов шаг был равен 16. Точность градировалась от 0.00001 до 0.0001 с величиной шага 0.00001. Максимальная эффективность была достигнута на 8 процессах и равна 0.9389. Минимальная - на 128, ее величина 0.2914.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

В России данный алгоритм реализован Якобовским М. В.

За границей осуществила реализацию компания [https://doc.itc.rwth-aachen.de/display/CCP/Parallelizing+an+Algorithm+for+Adaptive+Integration+with+OpenMP RWTH Compute Cluster]; группа исследователей во главе с [http://on-demand.gputechconf.com/gtc/2013/poster/pdf/P0237_KameshArumugam.pdf Kamesh Arumugam]; а также команда Berntsen, J.; Espelid, T. O.; and Genz, A.<ref>Berntsen, J.; Espelid, T. O.; and Genz, A. “An Adaptive Algorithm for the Approximate Calculation of Multiple Integrals.” ACM Transactions on Mathematical Software Vol. 17, No. 4, December 1991, Pages 437-451.</ref>.

== Литература ==
<references \>

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-18T15:30:05Z

Joinmek: /* Информационный граф */

Участник:Joinmek/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-18T15:27:03Z

Joinmek: /* Масштабируемость алгоритма и его реализации */