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

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

2016-12-14T20:48:04Z

Stalles: /* Пункт 1.5 */

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:41:38Z

Stalles:

{{Assignment}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double f( double x );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-12-14T20:33:25Z

Stalles: /* Пункт 1.5 */

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:30:50Z

Stalles: /* Пункт 1.2.3 */

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:30:37Z

Stalles: /* Метод локального стека */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double f( double x );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-12-14T20:28:04Z

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:27:42Z

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:27:31Z

Stalles: /* Пункт 1.2.3 */

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:27:21Z

Stalles: /* Пункт 1.2.2 */

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Исправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:26:43Z

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double f( double x );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-12-14T20:07:59Z

Stalles: /* Пункт 1.5 */

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:07:10Z

Stalles: /* Пункт 1.2.3 */

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T20:00:20Z

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

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

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

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

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

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

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

2016-12-14T19:54:54Z

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

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

-'''"...относятся к несколько другому алгоритму..."''' - к другому относительно чего?

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

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

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

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

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

2016-12-14T19:47:24Z

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

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

-Правильно.

-'''"...относятся к несколько другому алгоритму..."''' - к другому относительно чего?

-Если честно, не понимаю, почему нельзя судить о масштабируемости, и почему это надо отдельно пояснять.

-Глобального стека в реализации нет. Как и в требованиях учебного задания, насколько я понимаю.
----

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

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

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

2016-12-14T19:43:46Z

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

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

'''"относятся к несколько другому алгоритму"''' - к другому относительно чего?
----

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

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

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

2016-12-14T19:43:28Z

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

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

'''относятся к несколько другому алгоритму''' - к другому относительно чего?
----

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

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

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

2016-12-14T19:40:37Z

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

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:40, 14 декабря 2016 (MSK)

Поправлено

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

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

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

----

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

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

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

2016-12-14T19:40:09Z

Stalles:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double f( double x );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-12-14T19:39:18Z

Stalles: /* Входные и выходные данные алгоритма */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double f( double x );

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-12-14T19:37:46Z

Stalles: /* Пункт 1.5 */

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

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

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:37, 14 декабря 2016 (MSK)

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

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

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

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

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

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

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

----

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

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

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

2016-12-14T19:36:55Z

Stalles: /* Пункт 1.5 */

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

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

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

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

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

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

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

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

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

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

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

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

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

См. пункт 1.6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2016-12-14T19:36:40Z

Stalles: /* Пункт 1.5 */

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

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

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

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

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

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

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

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:36, 14 декабря 2016 (MSK)

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

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

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

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

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

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

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

См. пункт 1.6

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

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

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

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

Влияют ли на свойство детерминированности алгоритма выполнение свойства ассоциативности для операции сложения, а также свойства входной функции?

'''7. Данный алгоритм является устойчивым'''

Алгоритм устойчив для любой функции?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

'''Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.'''

То, что данная реализация предназначена для систем с общей памятью, не означает, что она не является масштабируемой.
Почему нет графиков масштабируемости по ядрам одного узла для алгоритма с адаптивной сеткой, где глобальный стек реализован для общей памяти?

== Статья [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2)]] ==

* Нет краткой сводки свойств алгоритма в начале страницы (Исправлено)
* Нумерация подразделов не соответствует шаблону (Исправлено)
* Разделы 1.6 и 1.8 (6 и 8 в оригинальной статье) не заполнены (Исправлено)
* Картинка в разделе 1.7 (7) не является информационным графом (Исправлено)
** Если это информационный граф, из него следует, что алгоритм строго последовательный. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
** Приведённый граф очень мелкий, надписи практически нечитаемы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Раздел 2.7 отсутствует (Исправлено)
* Список литературы отсутствует (Исправлено)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:03, 16 ноября 2016 (MSK) (Исправлено)
* Рисунки в статье не подписаны и не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)

Обсуждение участника:Joinmek

2016-12-14T19:36:27Z

Stalles: /* Пункт 1.5 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK) К работе есть несколько замечаний по содержанию (ниже с моей подписью)

== Пункт 1.1 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''Чтобы посчитать определенный интеграл, участок интегрирования делится на отрезки, на которых подсчитывается значение новой (упрощенной) функции, после чего значения суммируются на всех отрезках.'''

Наверное, на отрезках рассчитываются интегралы от новых функций, а их значения уже суммируются?

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''if (|sAB - sACB| ≥ ε|sACB|) { // Если заданная точность не достигнута'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2?

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:34, 14 декабря 2016 (MSK)

Не отличается, так как во всех перечисленных алгоритмах используется метод трапеций.

== Пункт 1.6 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

В качестве примера нужно привести хотя бы оценки, определяя разбиение отрезка (глубину, неравномерность и пр.) без учета функции.

== Пункт 1.7 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''Существуют реализации, где локальные стеки полностью отсутствуют, а все отрезки хранятся в глобальном стеке.'''

Хорошо бы пояснить в чем достоинства и недостатки такого подхода, по сравнению с тем, что описывается ранее?

== Пункт 1.8 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

См. пункт 1.6

== Пункт 1.10 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

'''3. В параллельной версии алгоритма не требуется управляющий процесс'''

Нужно здесь уточнить, что рассматривается алгоритм с общей памятью. Будет ли нужен управляющий процесс при реализации глобального стека на системах с распределенной памятью?

'''4. Алгоритм является детерминированным'''

Влияют ли на свойство детерминированности алгоритма выполнение свойства ассоциативности для операции сложения, а также свойства входной функции?

'''7. Данный алгоритм является устойчивым'''

Алгоритм устойчив для любой функции?

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 04:46, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

'''Данная реализация не является масштабируемой, т. к. она основана на механизме общей памяти, а, значит, на архитектуре Blue Gene, на которой она тестировалась, ограничена одним узлом.'''

То, что данная реализация предназначена для систем с общей памятью, не означает, что она не является масштабируемой.
Почему нет графиков масштабируемости по ядрам одного узла для алгоритма с адаптивной сеткой, где глобальный стек реализован для общей памяти?

== Статья [[Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки (2)]] ==

* Нет краткой сводки свойств алгоритма в начале страницы (Исправлено)
* Нумерация подразделов не соответствует шаблону (Исправлено)
* Разделы 1.6 и 1.8 (6 и 8 в оригинальной статье) не заполнены (Исправлено)
* Картинка в разделе 1.7 (7) не является информационным графом (Исправлено)
** Если это информационный граф, из него следует, что алгоритм строго последовательный. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
** Приведённый граф очень мелкий, надписи практически нечитаемы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Раздел 2.7 отсутствует (Исправлено)
* Список литературы отсутствует (Исправлено)
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:19, 1 ноября 2016 (MSK) (Исправлено)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:03, 16 ноября 2016 (MSK) (Исправлено)
* Рисунки в статье не подписаны и не пронумерованы. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:29, 21 ноября 2016 (MSK) (Исправлено)

Обсуждение участника:Stalles

2016-12-14T19:33:51Z

Stalles: /* Пункт 1.5 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK) Хорошее описание метода и алгоритма. Есть несколько замечаний по содержанию и вопросы по исследованию масштабируемости (ниже с моей подписью)

== Пункт 1.2.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту.'''

Что подразумевается под недоступностью стека для программиста, если далее рассматривается работа с этим стеком? Нужно пояснить это утверждение.

== Пункт 1.2.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга.'''

Нужно описать немного подробнее, как из определения стека появляется возможность обрабатывать отрезки независимо друг от друга.

'''Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.'''

Где в работе были перечислены последовательные методы, которые здесь сравниваются? С какой точки зрения локальный стек является наилучшим, по сравнению с ними?

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2.1?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>.'''

Объём равен <math> O\left( 1 \right) </math> - это уже не любой вид представления функции.

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

Есть ли в реализации глобальный стек, который описан в работе?

----

== Статья [[Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

=== Замечания по тексту ===
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
** Граф на рис.1 не является графом алгоритма, как написано в подписи к нему. Граф на рис.2 также является каким-то гибридом информационного графа и графа управления - в частности, содержит ветвления, которых в информационном графе быть не должно. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:57, 14 ноября 2016 (MSK)
* В разделе 1.9 должны быть оценки объёмов входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* В части 2 должны быть все разделы 2.1-2.7 (некоторые могут быть пустыми). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)

Обсуждение участника:Stalles

2016-12-14T19:32:56Z

Stalles: /* Пункт 1.2.3 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK) Хорошее описание метода и алгоритма. Есть несколько замечаний по содержанию и вопросы по исследованию масштабируемости (ниже с моей подписью)

== Пункт 1.2.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту.'''

Что подразумевается под недоступностью стека для программиста, если далее рассматривается работа с этим стеком? Нужно пояснить это утверждение.

== Пункт 1.2.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга.'''

Нужно описать немного подробнее, как из определения стека появляется возможность обрабатывать отрезки независимо друг от друга.

'''Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.'''

Где в работе были перечислены последовательные методы, которые здесь сравниваются? С какой точки зрения локальный стек является наилучшим, по сравнению с ними?

--[[Участник:Бобцов_Борис|Бобцов Борис]] 22:32, 14 декабря 2016 (MSK)

Поправлено

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2.1?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>.'''

Объём равен <math> O\left( 1 \right) </math> - это уже не любой вид представления функции.

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

Есть ли в реализации глобальный стек, который описан в работе?

----

== Статья [[Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

=== Замечания по тексту ===
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
** Граф на рис.1 не является графом алгоритма, как написано в подписи к нему. Граф на рис.2 также является каким-то гибридом информационного графа и графа управления - в частности, содержит ветвления, которых в информационном графе быть не должно. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:57, 14 ноября 2016 (MSK)
* В разделе 1.9 должны быть оценки объёмов входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* В части 2 должны быть все разделы 2.1-2.7 (некоторые могут быть пустыми). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)

Обсуждение участника:Stalles

2016-12-14T19:32:14Z

Stalles: /* Пункт 1.2.3 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK) Хорошее описание метода и алгоритма. Есть несколько замечаний по содержанию и вопросы по исследованию масштабируемости (ниже с моей подписью)

== Пункт 1.2.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту.'''

Что подразумевается под недоступностью стека для программиста, если далее рассматривается работа с этим стеком? Нужно пояснить это утверждение.

== Пункт 1.2.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга.'''

Нужно описать немного подробнее, как из определения стека появляется возможность обрабатывать отрезки независимо друг от друга.

'''Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.'''

Где в работе были перечислены последовательные методы, которые здесь сравниваются? С какой точки зрения локальный стек является наилучшим, по сравнению с ними?

--[[Участник:Бобцов_Борис|Бобцов Борис]]

Поправлено

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2.1?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>.'''

Объём равен <math> O\left( 1 \right) </math> - это уже не любой вид представления функции.

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

Есть ли в реализации глобальный стек, который описан в работе?

----

== Статья [[Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

=== Замечания по тексту ===
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
** Граф на рис.1 не является графом алгоритма, как написано в подписи к нему. Граф на рис.2 также является каким-то гибридом информационного графа и графа управления - в частности, содержит ветвления, которых в информационном графе быть не должно. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:57, 14 ноября 2016 (MSK)
* В разделе 1.9 должны быть оценки объёмов входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* В части 2 должны быть все разделы 2.1-2.7 (некоторые могут быть пустыми). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)

Обсуждение участника:Stalles

2016-12-14T19:31:55Z

Stalles: /* Пункт 1.2.3 */

--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK) Хорошее описание метода и алгоритма. Есть несколько замечаний по содержанию и вопросы по исследованию масштабируемости (ниже с моей подписью)

== Пункт 1.2.2 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту.'''

Что подразумевается под недоступностью стека для программиста, если далее рассматривается работа с этим стеком? Нужно пояснить это утверждение.

== Пункт 1.2.3 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга.'''

Нужно описать немного подробнее, как из определения стека появляется возможность обрабатывать отрезки независимо друг от друга.

'''Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.'''

Где в работе были перечислены последовательные методы, которые здесь сравниваются? С какой точки зрения локальный стек является наилучшим, по сравнению с ними?

--[[Участник:Бобцов_Борис|Бобцов Борис]]

== Пункт 1.5 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность'''

Не отличается ли здесь условие на деление отрезка от того, что приведено в пункте 1.2.1?

== Пункт 1.9 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

'''Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>.'''

Объём равен <math> O\left( 1 \right) </math> - это уже не любой вид представления функции.

== Пункт 2.4 ==
--[[Участник:Evgeny Mortikov|Evgeny Mortikov]] ([[Обсуждение участника:Evgeny Mortikov|обсуждение]]) 05:06, 3 декабря 2016 (MSK)

Правильно ли я понимаю, что представленные результаты по исследованию масштабируемости относятся к несколько другому алгоритму – рассматривается равномерное разбиение отрезка по MPI процессам, а в рамках каждого рассчитывается алгоритм с адаптивной сеткой? Можно ли по полученным результатам судить о масштабируемости исследуемого алгоритма? Нужно это пояснить в работе.

Есть ли в реализации глобальный стек, который описан в работе?

----

== Статья [[Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки]] ==

=== Замечания по тексту ===
* В разделе 1.4 требуется привести описание алгоритма на верхнем уровне (на основе макроопераций), а не то, что там сейчас. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* В разделе 1.5 кроме кода нужны также текстовые пояснения. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
* Граф, приведённый в разделе 1.7 не является информационным графом (ациклический граф, вершины - операции, дуги - информационные зависимости). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 18:25, 1 ноября 2016 (MSK)
** Граф на рис.1 не является графом алгоритма, как написано в подписи к нему. Граф на рис.2 также является каким-то гибридом информационного графа и графа управления - в частности, содержит ветвления, которых в информационном графе быть не должно. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:57, 14 ноября 2016 (MSK)
* В разделе 1.9 должны быть оценки объёмов входных и выходных данных. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* В части 2 должны быть все разделы 2.1-2.7 (некоторые могут быть пустыми). [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:00, 14 ноября 2016 (MSK)
* Не заполнен раздел 2.4 описания. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 16:04, 16 ноября 2016 (MSK)
* В разделе 2.4 не приведены все параметры запуска теста - какой компилятор, с какими опциями использовался, какие версии библиотек, на каких узлах проводился запуск и т.д. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* В разделе 2.4 не приведена использованная в экспериментах реализация алгоритма. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)
** Замечание не исправлено. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 15:21, 28 ноября 2016 (MSK)
* Из графиков в разделе 2.4 следует сделать выводы о масштабируемости реализации. [[Участник:ASA|Александр Сергеевич Антонов]] ([[Обсуждение участника:ASA|обсуждение]]) 14:31, 21 ноября 2016 (MSK)

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-12-14T19:30:43Z

Stalles: /* Метод локального стека */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга, так как у каждого процесса существует свой стек, и он работает только с отрезками, которые хранятся в нём. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI. При запусках использовалась связка openmpi/1.8.4-gcc + gcc/5.2.0, реализация - тут -> [https://github.com/Stalles/superprak1 ссылка на реализацию.]

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-30T20:56:35Z

Stalles:

{{Assignment}}
{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI. При запусках использовалась связка openmpi/1.8.4-gcc + gcc/5.2.0, реализация - тут -> [https://github.com/Stalles/superprak1 ссылка на реализацию.]

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-30T20:54:37Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI. При запусках использовалась связка openmpi/1.8.4-gcc + gcc/5.2.0, реализация - тут -> [https://github.com/Stalles/superprak1 ссылка на реализацию.]

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-30T20:41:12Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI. [https://github.com/Stalles/superprak1 ссылка на реализацию]

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:51:18Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{Assignment}}

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:51:05Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{Assignment}}

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана предложенная в функция <math>1/(x^2) * (sin(1/x))^2</math>. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:26:42Z

Stalles:

{{Assignment}}

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана предложенная в функция Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:26:30Z

Stalles:

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана предложенная в функция Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:24:28Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. В качестве тестируемой функции была выбрана предложенная в функция Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:20:22Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

Проведем оценки масштабируемости:

'''По числу процессов''' — при увеличении числа процессов эффективность уменьшается на всей области рассматриваемых значений, причем темп убывания замедляется с ростом числа процессов. Кроме того, видно, что при более,чем 40 процессов эффективность становится крайне низкой.

'''По размеру задачи (точности вычислений)''' — при увеличении точности вычислений и при постоянном числе процессов эффективность вычислений остаётся практически неизменяемой, очень медленно снижается. Это объясняется тем, что некоторые отрезки интегрирования имеют большую трудоёмкость из-за негладкости функции. Процессы, которым достались такие отрезки, и определяют время работы всей программы.

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:08:33Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессоров. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессоров. При таком алгоритме мало затрат на обмен данными между процессорами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

На графиках, представленных ниже, отображена [[Глоссарий#Производительность|производительность]] и [[Глоссарий#Эффективность распараллеливания|эффективность распараллеливания]] данного алгоритма в зависимости от изменяемых параметров запуска - точности вычислений и числа процессоров.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:05:19Z

Stalles: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Функция может иметь любой вид представления, однако это представление "константно", то есть можно считать, что объём равен <math> O\left( 1 \right) </math>. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) = O\left( 1 \right) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) = O\left( 1 \right) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:03:14Z

Stalles:

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math> O\left( 1 \right) </math> (<math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность))
| output_data = <math> O\left( 1 \right) </math> (<math>1</math> число)
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T18:00:42Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:Myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:59:23Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:myefficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:58:53Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

[[Файл:efficiency.png|thumb|center|800px|Рис.4. Эффективность алгоритма в зависимости от числа процессоров и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:17:53Z

Stalles: /* Информационный граф */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма обработки отрезка. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:15:54Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. При таком алгоритме мало затрат на обмен данными между процессами, поэтому было решено воспользоваться только средствами библиотеки MPI.

Для оценки масштабируемости были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:13:23Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a_i, b_i) </math> для своего отрезка <math> [ a_i, b_i ] </math> независимо от других процессов. Были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:12:29Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Далее каждый процесс выполнял функцию <math> IntTrap(a, b) </math>. Были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:10:41Z

Stalles: /* Масштабируемость алгоритма и его реализации */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Исследование проводилось на суперкомпьютере "Ломоносов" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.

Участник:Бобцов Борис/Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки

2016-11-27T17:07:29Z

Stalles: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Вычисление определенного интеграла с использованием адаптивно сгущающейся сетки
| serial_complexity = <math> O\left( n \right) </math>, где <math> n </math> - количество подотрезков, на которые разбился исходный отрезок
| pf_height = <math> log(n) </math>
| pf_width = <math> n </math>
| input_data = <math>1</math> функция <math>1</math> переменной, <math>3</math> числа (границы отрезка интегрирования, точность)
| output_data = <math>1</math> число
}}
Автор статьи: [[Участник:Stalles|Бобцов Борис]] (группа 619)

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===
----

Пусть требуется вычислить определённый интеграл <math>I = \int_a^b{f(x)dx}</math> от непрерывной функции <math>f(x)</math>. Если может быть найдена первообразная <math>F(x)</math> подынтегральной функции, то по формуле Ньютона-Лейбница:

<math>\int_a^b{f(x)dx} = F(b) - F(a). </math>

Если же первообразная не может быть найдена, то для вычисления интеграла прибегают к приближённым формулам, точность которых может быть сделана сколь угодно большой.

Приближённые методы вычисления определённого интеграла в большинстве случаев основаны на том, что определённый интеграл численно равен площади криволинейной трапеции, ограниченной кривой <math> y =f(x)</math>, сегментом <math> \left[ a,b \right] </math> оси <math>Ox</math> и вертикальными прямыми <math>x = a</math> и <math>x = b</math>.

Идея данных методов заключается в приближении исходной кривой новой, достаточно близкой к старой, кривой. В качестве этой новой кривой подбирают такую, для которой площадь криволинейной трапеции подсчитывается просто. В зависимости от выбора новой кривой мы получим ту или иную приближённую формулу интегрирования.

Разбивая сегмент интегрирования на несколько достаточно малых частей, на каждом из полученных маленьких сегментов мы можем приблизить интегрируемую функцию прямой. Тем самым мы заменим криволинейную трапецию прямолинейной, формула площади которой проста для вычисления.

=== Математическое описание алгоритма ===
----
==== Метод трапеций ====
Будем рассматривать проблему вычисления значения определенного интеграла с некоторой заданной точностью <math> \epsilon </math>:

<math>I(a,b) = \int_a^b{f(x)dx}</math>

Пусть на отрезке <math> [a,b] </math> задана равномерная сетка, содержащая <math> n+1 </math> узел:

<math> x_{i} = a + \frac{(b - a)} {n} i, i = 0,...,n </math>

Тогда, согласно методу трапеций, можно численно найти определенный интеграл от функции <math> f (x) </math> на отрезке <math>[a,b]</math>:

<math> \int_a^b{f(x)dx} = \frac{b - a}{n} \left( \frac{f(x_0)}{2} + \sum^{n-1}_{i=1} {f(x_i)} + \frac{f(x_n)}{2} \right)</math>

Будем полагать значение <math> I </math> найденным с точностью <math> \epsilon </math>, если выполнено условие:

<math> |I_{n_1} - I_{n_2}| \leq \epsilon |I_{n_2}|, n_1 > n_2, </math>
где <math> n_1 </math> и <math> n_2 </math> - количество узлов, образующих две разные сетки.

==== Метод рекурсивного деления ====

Метод трапеций обладает следующими недостатками:
* в некоторых точках значение функции будет вычисляться несколько раз;
* на всём интервале интегрирования используется равномерная сетка, тогда как число точек, необходимых для достижения заданной точности, зависит от вида функции и может сильно различаться на разных участках сегмента интегрирования.

Метод рекурсивного деления был придуман, чтобы избежать этих недостатков. Суть метода заключается в рекурсивном вызове себя до момента, пока мы не достигнем нужной точности:
<math> I(a,b) = IntTrap(a, b, f(a), f(b)) = IntTrap(a, (b - a) / 2, f(a), f((b - a) / 2)) + IntTrap((b - a) / 2, b, f((b - a) / 2), f(b)) = ... </math>

Однако можно заметить, что координаты концов обрабатываемых отрезков хранятся в программном стеке процесса <math>IntTrap() </math>, и недоступны программисту. Это является основной сложностью при построении параллельного алгоритма на основе метода рекурсивного деления.

====Метод локального стека ====

Данный алгоритм использует массив данных, доступ к которым осуществляется по принципу стека - первым удаляется последний из добавленных элементов. Теперь у разных процессов есть возможность обрабатывать отрезки независимо друг от друга. В рассматриваемом алгоритме вместо стека можно было использовать и другие способы хранения заданий, например очередь. Стек выбран исключительно из соображений простоты реализации. Алгоритм локального стека можно считать наилучшим из перечисленных последовательных методов для разработки его параллельной версии.

=== Вычислительное ядро алгоритма ===
----
В схеме реализации будет явно видно, что алгоритм реализуется при помощи цикла, внутри которого происходит подсчет текущих частичных сумм и проверка достигнутой точности. Сложность данного алгоритма зависит от количества проходов по циклу линейно, поэтому можно считать, что тело этого цикла и является вычислительным ядром данного алгоритма.

=== Макроструктура алгоритма ===
----
Как уже было замечено, алгоритм представляет собой три основные части, выполняющиеся в цикле. Сначала вычисляются частичные суммы на имеющемся отрезке, затем проверяется точность вычислений и, в случае, если точность недостаточна, вычисляются новые отрезки.

[[Файл:123321.png]]

=== Схема реализации последовательного алгоритма ===
----

Будем считать, что описана функция double f( double x ), возвращающая значение f(x) интегрируемой функции f в точке x.

double f( double x );

int sp = 0; //указатель вершины стека

struct
{
double a;
double b;
double fa;
double fb;
double sab;
} stk[1000]; //массив структур, в которых хранятся отложенные значения. 1000 может быть заменена на необходимое число

//операции доступа к данным стека
#define STACK_IS_NOT_FREE ( sp > 0 )

void PUT_INTO_STACK( double a, double b, double fa, double fb, double sab )
{
stk[sp].a = a;
stk[sp].b = b;
stk[sp].fa = fa;
stk[sp].fb = fb;
stk[sp].sab = sab;
++sp;
}

void GET_FROM_STACK( double& a, double& b, double& fa, double& fb, double& sab )
{
--sp;
a = stk[sp].a;
b = stk[sp].b;
fa = stk[sp].fa;
fb = stk[sp].fb;
sab = stk[sp].sab;
}

//основная функция
int IntTrap(a, b)
{
double I = 0; //значение интеграла
double fa = f( a ); //значение функции <math>y = f(x)</math> в точке <math>a</math>
double fb = f( b ); //значение функции <math>y = f(x)</math> в точке <math>b</math>
double fc = 0;
double c = 0; //середина отрезка интегрирования
double sab = 0; //
double sac = 0; //
double scb = 0; //
double sabc = 0; //переменные для подсчёта текущих сумм
sab = ( fa + fb ) * ( b - a ) / 2;
while( 1 )
{
c = ( a + b ) / 2;
fc = f( c );
sac = ( fa + fc ) * ( c - a ) / 2;
scb = ( fc + fb ) * ( b - c ) / 2;
sabc = sac + scb;
if( abs( sab - sabc ) > <math>\epsilon</math> * abs ( sabc ) ) //<math>\epsilon</math> - заданная точность
{
PUT_INTO_STACK( a, c, fa, fc, sac );
a = c;
fa = fc;
sab = scb;
}
else
{
I += sabc;
if( STACK_IS_NOT_FREE )
{
break;
}
GET_FROM_STACK( a, b, fa, fb, sab );
}
}
return I;
}

Работа со стеком происходит через операции доступа к данным. В основной функции в цикле происходит вычисление частичных сумм sac и scb, затем проверяется точность if( abs( sab - sacb ) ><math>\epsilon</math> * abs ( sacb ) ). В случае достижения необходимой точности частичные суммы добавляются к значению интеграла I, если отрезков не осталось, то программа завершает работу, иначе из стека выгружается следующий отрезок. Если точность не достигнута, то правый полуотрезок загружается в стек, а левый полуотрезок устанавливается как текущий для следующей итерации цикла.

Когда в стеке не останется отрезков, это будет означать, что программа рассчитала все отрезки до точки a включительно, и возвращает значение I как приближённое значение интеграла.

=== Последовательная сложность алгоритма ===
----
Пусть для работы алгоритма было необходимо разбить отрезок <math> \left[a, b\right] </math> на сегменты <math> \left[a=x_0 , x_1\right], \left[a=x_1 , x_2\right],... \left[a=x_{n-1} , x_n = b\right] </math>.
Так как каждый раз, когда нам приходится вычислять площадь трапеции на более коротком сегменте, мы делим отрезок пополам, получаем, что длина каждого отрезка равна <math> \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^k} </math> для некоторого натурального <math> k </math>.

Назовём глубиной метода максимальное <math> k </math> из всех <math> k_i : \left( x_i - x_{i - 1} \right) = \frac{b - a}{2^{k_i}} </math>.

Очевидно, что для каждой функции <math> y </math> и для каждой точности <math> \epsilon </math> глубина алгоритма будет разной. То есть можно считать, что <math> k = k(f(x), \epsilon). </math> Также понятно, что, если <math> k </math>- глубина алгоритма при фиксированных <math> y </math> и <math> \epsilon </math>, то максимально возможное количество полученных отрезков, для которых считалась частичная сумма, и количество точек на отрезке <math> \left[a, b\right] </math> равны соответственно <math> 2^k </math> и <math> 2^k + 1 </math> при <math> k_i = k, i = 1,2,...,n </math>. В этом худшем с точки зрения количества операций случае алгоритм прокрутит цикл while( 1 ) <math> 1 + 2 + 4 + ... + 2^k = (2^{k + 1}-1) </math> раз.

Если не учитывать при расчёте сложности операции работы с памятью, а только сложения/вычитания и умножения*деления, получим, что за каждый выполненный цикл while( 1 ) алгоритм выполняет 7 сложений и 6 умножений. Итого получаем в худшем случае <math> 7*2^k </math> сложений и <math> 6*2^k </math> умножений. Кроме этого, алгоритм посчитает значение <math> f(x) </math> в <math> n+1 </math> точках. При этом понятно, что <math> k \leq log(n). </math>

Получаем, что при разбиении исходного отрезка на <math> n </math> подотрезков получаем глубину алгоритма <math> k \leq log(n) </math> и сложность алгоритма <math> O\left( n + 2^{log n} \right) = O\left( n + n \right) = O\left( n \right) </math>.

При этом из всего вышесказанного сразу видно, что при достаточном количестве вычислительных ресурсов распараллеливания высота ярусно-параллельной формы параллельной программы будет равна глубине <math> k \leq log(n), </math>, а ширина будет не больше, чем количество отрезков <math> n. </math>

=== Информационный граф ===
----
[[Файл:Macromy.png|thumb|center|400px|Рис.1. Общая схема алгоритма ]]

На Рис.1 изображена макроструктура алгоритма. На вход алгоритма подаётся функция, границы отрезка интегрирования и нужная точность. В предварительных вычислениях задаются границы первого отрезка и значения функции в них. Далее запускается операция обработки отрезка, в случае недостаточной точности повторяющаяся для двух подотрезков (и так далее, пока не будет достигнута нужная точность), на выход алгоритм выдаёт приближённое значение интеграла на заданном отрезке с необходимой точностью.

Рассмотрим процедуру обработки отрезка подробнее.

[[Файл:Png граф.png|thumb|center|800px|Рис.2. Информационный граф одной итерации цикла (обработки одного отрезка) ]]

На Рис.2 изображён информационный граф алгоритма. Синими прямоугольниками изображены входные данные итерации цикла, внутри подписаны имена данных. Кругами изображены операции вычисления переменных, имена которых указаны внутри кругов. Зелёными овалами изображены прочие операции, выполняемые алгоритмом. После операции проверки точности алгоритм загружает правый отрезок в стек, а левый настраивает на дальнейшую обработку, если точность не достигнута, иначе загружает новый отрезок из стека. Затем происходит суммирование текущей частичной суммы с полученными ранее. При отсутствии отрезков в стеке итерация завершается.

=== Ресурс параллелизма алгоритма ===
----

Представленный алгоритм обладает хорошим ресурсом параллелизма. В самом деле, пусть в нашем распоряжении есть доступный всем параллельным процессам список отрезков интегрирования, организованный в виде стека. Назовём его глобальным стеком. Предположим, что перед запуском параллельных процессов в глобальный стек помещается единственная запись - координаты концов отрезка интегрирования - в дальнейшем - "отрезок". Тогда возможно реализовать следующую схему алгоритма, выполняемую каждым из параллельных процессов:

Пока в глобальном стеке есть отрезки:
*взять один отрезок из глобального стека;
*выполнить алгоритм локального стека, выполняя при записи в локальный стек следующие операции:
**если в локальном стеке есть несколько отрезков, а в глобальном стеке отрезки отсутствуют, то
***переместить часть отрезков из локального стека в глобальный;
**по исчерпании локального стека добавить полученную частичную сумму к общему значению интеграла.

=== Входные и выходные данные алгоритма ===
----

'''Входные данные''':
* функция <math> y = f(x)</math>;
* точность <math> \epsilon </math>;
* границы отрезка интегрирования <math> a, b.</math>

Формально оценить объём входных данных не получится, так как функция может иметь любой вид представления. Кроме функции, на вход подаётся три вещественных числа, их объём - <math> 3 * sizeof( double ) </math>.

'''Выходные данные''':
* число <math>I </math>, приближённо равное <math> \int_a^b{f(x)dx}</math> с точностью <math> \epsilon </math>.

На выход алгоритм выдаёт одно вещественное число, его объём - <math> sizeof( double ) </math>.

=== Свойства алгоритма ===
----

Алгоритм обладает большой вычислительной мощностью. Кроме того, у него имеется большой потенциал для распараллеливания.

Алгоритм не обладает свойством детерминированности, так как в зависимости от специфических свойств графика входных функций может вести себя для них совершенно по-разному.

Соотношение последовательной и параллельной сложности алгоритма высоко и равно приблизительно <math> \frac{n}{log(n)} </math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===

Для распараллеливания программы был выбран алгоритм геометрического параллелизма. Весь отрезок интегрирования делился на равные части, количество которых было равно количеству процессов. Были произведены запуски на 1, 2, 4, 8, 16, 32, 48, 64, 80, 96, 112 и 128 процессах. Кроме того, для каждого количества процессов были произведены запуски при разной точности вычисления интеграла, от <math>10^{-5} </math> до <math>10^{-7} </math>.

[[Файл:Png_mapoftime.png|thumb|center|800px|Рис.3. Время работы алгоритма в зависимости от числа процессов и точности вычислений ]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

На данный момент реализация алгоритма локального стека была указана только в книге Якобовского М.В., Кульковой Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

== Литература ==

# Шнейдер В. Е. и др. Краткий курс высшей математики. Учеб. пособие для втузов. М., «Высш. школа», 1972. 640 с.
# Якобовский М.В., Кулькова Е.Ю. Решение задач на многопроцессорных вычислительных системах с разделяемой памятью. - М.: СТАНКИН, 2004. – 30 c.