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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-29T21:26:24Z

Bvdmitri:

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

Алгоритм не использует и не подразумевает хранение общих данных между вычислительными единицами.

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Master-Slave реализация ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-16T08:19:55Z

Bvdmitri: /* Использование управляющего узла */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

Алгоритм не использует и не подразумевает хранение общих данных между вычислительными единицами.

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Master-Slave реализация ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-16T08:19:28Z

Bvdmitri: /* Использование управляющего узла */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

Алгоритм не использует и не подразумевает хранение общих данных между вычислительными единицами.

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Master-Slave реализация ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:20:46Z

Bvdmitri: /* Локальность данных и вычислений */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

Алгоритм не использует и не подразумевает хранение общих данных между вычислительными единицами.

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:15:33Z

Bvdmitri: /* Исходный код */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:15:11Z

Bvdmitri: /* Исходный код */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]
<div class="toccolours mw-collapsible mw-collapsed">
<div class="mw-collapsible-content">
<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>
</div>
</div>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:15:01Z

Bvdmitri: /* Исходный код */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]
<div class="toccolours mw-collapsible mw-collapsed">
<div class="mw-collapsible-content">
<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>
</div>
<div>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:12:44Z

Bvdmitri: /* Исходный код */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:12:17Z

Bvdmitri: /* Использование управляющего узла */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub].

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для управляющего узла.
<div class="mw-collapsible-content">
<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>
</div>
</div>

<div class="toccolours mw-collapsible mw-collapsed">
Исходный код для вычислительных узлов.
<div class="mw-collapsible-content">

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>
</div>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:07:29Z

Bvdmitri: /* Исходный код для управляющего узла */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

===== Исходный код для управляющего узла =====

{{Collapse|<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>}}

===== Исходный код для вычислительных узлов =====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:05:33Z

Bvdmitri: /* Использование управляющего узла */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

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

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

===== Исходный код для управляющего узла =====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

===== Исходный код для вычислительных узлов =====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T14:03:44Z

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

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[[File:Mpi_farm_adaptive_integral_tests.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

===== Исходный код для управляющего узла =====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

===== Исходный код для вычислительных узлов =====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T13:46:25Z

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

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T13:41:55Z

Bvdmitri: /* Деление на подотрезки */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

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

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T13:40:18Z

Bvdmitri: /* Очередь задач на общей памяти */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

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

[[File:Shared_memory_adaptive_integral.png|center|900px]]

==== Исходный код ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T13:37:33Z

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

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

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

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
Характеристики вычислительного кластера: [http://users.parallel.ru/wiki/pages/22-config link].

=== Очередь задач на общей памяти ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

[[File:Shared_memory_adaptive_integral.png|center|900px]]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T13:04:03Z

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

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

=== Очередь задач на общей памяти ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

[[File:Shared_memory_adaptive_integral.png|center|900px]]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

[[File:Mpi_shared_memory_adaptive_integral.png|center|900px]]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T12:54:35Z

Bvdmitri: /* Очередь задач на общей памяти */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

=== Очередь задач на общей памяти ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

[[File:Shared_memory_adaptive_integral.png|center|900px]]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T12:54:19Z

Bvdmitri: /* Очередь задач на общей памяти */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

=== Очередь задач на общей памяти ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

[[File:Shared_memory_adaptive_integral.png|center|500px]]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T11:39:16Z

Bvdmitri: /* Использование управляющего узла */

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

=== Очередь задач на общей памяти ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T11:38:44Z

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

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

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

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

Алгоритм имеет несколько возможных параллельных реализаций.

=== Очередь задач на общей памяти ===
Реализация для эффективного использования многомерного процессора. В данном случае вместо рекурсии используется очередь задач общая для всех ядер процессора.

Плюсы данного подхода:
* Очень простая реализация

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

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

Плюсы данного подхода:
* Хорошая масштабируемость на большом классе функций

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

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

Плюсы данного подхода:
* Балансировка нагрузки

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

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

=== Очередь задач на общей памяти ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/tbb GitHub]

<source lang="c++">
#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}
</source>

=== Деление на подотрезки ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_tbb GitHub]

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

=== Использование управляющего узла ===

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm GitHub]

==== Исходный код для управляющего узла ====

<source lang="c++">
#include "Farm.h"

Farm::Farm(int nodes_num, double a, double b, double tau) {
this->nodes_num = nodes_num;
this->availableNodes = (int *) calloc((size_t) nodes_num, sizeof(int));
this->availableNodesCount = nodes_num - 1;
this->a = a;
this->b = b;
this->tau = tau;
this->answer = 0.0;

this->jobCount = 0;
this->jobs = (double *) calloc(FARM_JOBS_BUFFER_SIZE, sizeof(double));
//Buf structure
//0 - a
//1 - b
//2 - tau, if tau < 0, a = y or exit job

this->message_buffer = (double *) calloc(FARM_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, FARM_MPI_BUFFER_SIZE * sizeof(double));
//Main node is always busy
availableNodes[0] = 1;
}

void Farm::SendInitialJobs() {
double shift = (b - a) / (nodes_num - 1);
double *buf = (double *) calloc(3, sizeof(double));
for (int i = 0; i < nodes_num - 1; i++) {
buf[0] = a + shift * i;
buf[1] = buf[0] + shift;
buf[2] = tau;

MPI_Bsend(buf, 3, MPI_DOUBLE, i + 1, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i + 1] = 1;
availableNodesCount -= 1;
}
}

void Farm::work() {
double buf[3];
MPI_Status status;
while (true) {
MPI_Recv(buf, 3, MPI_DOUBLE, MPI_ANY_SOURCE, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD, &status);
int source = status.MPI_SOURCE;

if (buf[2] < 0.0) {
//Node send result
answer += buf[0];
if (jobCount != 0) {
buf[0] = jobs[(jobCount - 1) * 3 + 0];
buf[1] = jobs[(jobCount - 1) * 3 + 1];
buf[2] = jobs[(jobCount - 1) * 3 + 2];
jobCount -= 1;

MPI_Bsend(buf, 3, MPI_DOUBLE, source, JOB_SEND_TAG, MPI_COMM_WORLD);
} else {
availableNodes[source] = 0;
availableNodesCount += 1;
if (availableNodesCount == (nodes_num - 1)) {
KillWorkers();
break;
}
}
} else {
//Node send job
if (availableNodesCount != 0) {
for (int i = 1; i < nodes_num; i++) {
if (availableNodes[i] == 0) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
availableNodes[i] = 1;
availableNodesCount -= 1;
break;
}
}
} else {
jobs[jobCount * 3 + 0] = buf[0];
jobs[jobCount * 3 + 1] = buf[1];
jobs[jobCount * 3 + 2] = buf[2];
jobCount += 1;
}
}

}
}

void Farm::KillWorkers() {
double buf[3];
buf[2] = -1.0;
for (int i = 1; i < nodes_num; i++) {
MPI_Bsend(buf, 3, MPI_DOUBLE, i, JOB_SEND_TAG, MPI_COMM_WORLD);
}
}

double Farm::Result() {
return answer;
}

Farm::~Farm() {
free(jobs);
int size = FARM_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}
</source>

==== Исходный код для вычислительных узлов ====

<source lang="c++">
#include <cmath>
#include "Worker.h"

Worker::Worker(const std::function<double(double)> &f): f(f) {
this->buf = (double *) calloc(16, sizeof(double));
this->message_buffer = (double *) calloc(WORKER_MPI_BUFFER_SIZE, sizeof(double));
MPI_Buffer_attach(message_buffer, WORKER_MPI_BUFFER_SIZE * sizeof(double));
}

void Worker::work() {
while (true) {
GetJob();
if (buf[2] > 0.0) {
Calculate();
} else {
break;
}
}
}

void Worker::GetJob() {
MPI_Recv(buf, 3, MPI_DOUBLE, 0, JOB_GET_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}

void Worker::Calculate() {
double a = buf[0];
double b = buf[1];
double tau = buf[2];

while (true) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);

if (fabs(x - y) < tau) {
SendResult(y);
break;
} else {
SaveJob(a, (a + b) / 2, tau / 2);
a = (a + b) / 2;
tau = tau / 2;
}

}
}

void Worker::SaveJob(double a, double b, double tau) {
double job[3];
job[0] = a;
job[1] = b;
job[2] = tau;
MPI_Bsend(job, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

void Worker::SendResult(double result) {
double r[3];
r[0] = result;
r[1] = 0.0;
r[2] = -1.0;
MPI_Bsend(r, 3, MPI_DOUBLE, 0, JOB_SAVE_OR_RESULT_TAG, MPI_COMM_WORLD);
}

Worker::~Worker() {
free(buf);
int size = WORKER_MPI_BUFFER_SIZE * sizeof(double);
MPI_Buffer_detach(message_buffer, &size);
free(message_buffer);
}

double Worker::simpson(double a, double b, int k) {
double h = (b - a) / ((double) 2 * k);
double answer = 0.0;
for (int j = 1; j < 2 * k; j += 2) {
answer += (f(a + h * (j - 1)) + 4 * f(a + h * j) +
f(a + h * (j + 1)));
}
return h * answer / 3;
}
</source>

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

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

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

* [https://en.wikipedia.org/wiki/Adaptive_Simpson%27s_method Adaptive Simpson's method]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

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

* [https://en.wikipedia.org/wiki/Adaptive_quadrature Adaptive Quadrature Wikipedia]
* [https://en.wikipedia.org/wiki/Simpson%27s_rule Simpson's Rule]
* Якобовский М.В., Кулькова Е.Ю. "Решение задач на многопроцессорных вычислительных системах с разделяемой памятью."

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T11:36:42Z

Bvdmitri: /* Очередь задач на общей памяти */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T11:35:01Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-15T11:33:29Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:57:58Z

Bvdmitri: /* Существующие реализации алгоритма */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:57:47Z

Bvdmitri: /* Литература */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:51:58Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:48:41Z

Bvdmitri: /* Литература */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:48:28Z

Bvdmitri: /* Литература */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:47:32Z

Bvdmitri: /* Существующие реализации алгоритма */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:32:33Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:31:57Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:31:36Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:31:05Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-14T10:21:29Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:56:58Z

Bvdmitri: /* Литература */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:46:44Z

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

Основные авторы описания: [[Участник:bvdmitri|Д.В.Багаев]]

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

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

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

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

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

# Интеграл функции вычисляется по квадратурной [https://ru.wikipedia.org/wiki/Формула_Симпсона формуле Симпсона] с числом узловых точек равным 4 и 8 на отрезке <math>[a, b] </math>.
# Вычисляется разность найденных значений
## Если разность интегралов меньше либо равна желаемой точности интегрирования ε - заканчиваем процедуру.
## Если разность больше, то отрезок разбивается на два : <math>[a, \tfrac{a + b} {2}]</math> и <math>[\tfrac{a + b} {2}, b]</math> и для каждого отрезка повторяется процедура 1, затем возвращается сумма полученных значений.
Алгоритм имеет рекурсивную природу.

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

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

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

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

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

[[Файл:Adaptive_integration_block.png|center|500px]]

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

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

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

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

У алгоритма есть несколько возможностей для распараллеливания.
<br>
В первом случае можно разбить отрезок на фиксированное число под-отрезков, и каждый под отрезок считать на одном процессоре с дальнейшим суммированием результатов с каждого процессора. Внутри процессора используется схема стека задач. Рекурсия заменяется на операции добавить и достать задачу из общего стека задач.

[[Файл:Mpi_tbb_adaptive_integral.png|1200px|center]]

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

[[Файл:Mpi_farm_adaptive_integral.png|1200px|center]]

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

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

* Функция.
* Отрезок интегрирования <math>[a, b]</math>.
* Желаемая точность интегрирования <math>\varepsilon</math>.

=== Выходные данные ===

* Определенный интеграл функции на отрезке [a, b] с точностью ε.

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

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

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

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

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

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

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

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

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

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

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

=== Исходный код реализованного алгоритма ===

Весь исходный код в статье можно найти в репозитории на [https://github.com/bvdmitri/aintegrate GitHub].

=== Реализации на одном процессоре ===

Простейшую рекурсивную реализацию данного алгоритма , которая не использует ресурсы параллелизма можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/sequential/SequentialMethod.cpp здесь].

<source lang="c++">
#include "SequentialMethod.h"

SequentialMethod::SequentialMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double SequentialMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
return integrate(a, (a + b) / 2.0) + integrate((a + b) / 2.0, b);
}
}

SequentialMethod::~SequentialMethod() {}
</source>

<br>
Реализация с помощью библиотеки [https://www.threadingbuildingblocks.org Intel TBB] для более эффективного использования многоядерных процессоров можно посмотреть [https://github.com/bvdmitri/aintegrate/blob/master/src/method/tbb/TBBMethod.cpp здесь].

<source lang="c++">

#include "TBBMethod.h"

TBBMethod::TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double TBBMethod::integrate(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = integrate(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = integrate((a + b) / 2.0, b);
});

return x + y;
}
}

TBBMethod::~TBBMethod() {}

</source>

=== Параллельная реализации ===

==== Реализация с помощью MPI для межпроцессорного взаимодействия и [https://www.threadingbuildingblocks.org Intel TBB] для внутрипроцессорного взаимодействия ====

<source lang="c++">
#include "MPI_TBBMethod.h"

MPI_TBBMethod::MPI_TBBMethod(double eps, const std::function<double(double)> &f) : IntegrationMethod(eps, f) {}

double MPI_TBBMethod::tbb_run(double a, double b) {
double x = simpson(a, b, 4);
double y = simpson(a, b, 8);
if (fabs(x - y) < eps) {
return y;
} else {
tbb::task_group group;

group.run([&] {
x = tbb_run(a, (a + b) / 2.0);
});

group.run_and_wait([&] {
y = tbb_run((a + b) / 2.0, b);
});

return x + y;
}
}

double MPI_TBBMethod::integrate(double a, double b) {
double answer = 0.0;
int nodes = 1;
MPI_Comm_size(MPI_COMM_WORLD, &nodes);

int node_id = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &node_id);

double h = (b - a) / (double) nodes;

a = a + h * node_id;
b = a + h;

double node_answer = tbb_run(a, b);
MPI_Barrier(MPI_COMM_WORLD);
if (node_id == 0) {
answer += node_answer;
for (int i = 1; i < nodes; i++) {
MPI_Recv(&node_answer, 1, MPI_DOUBLE, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
answer += node_answer;
}
} else {
MPI_Send(&node_answer, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD);
}

MPI_Barrier(MPI_COMM_WORLD);

return answer;
}

MPI_TBBMethod::~MPI_TBBMethod() {}
</source>

В данной реализации отрезок [a, b] делится на число доступных процессоров, каждый отрезок считается на своем процессоре, рекурсия заменяется на [https://www.threadingbuildingblocks.org/tutorial-intel-tbb-task-based-programming систему] задач библиотеки Intel MPI для более эффективного использования многоядерных процессоров.

==== Реализация только с помощью MPI ====

[https://github.com/bvdmitri/aintegrate/tree/master/src/method/mpi_farm Исходный код]

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

=== Тесты производительности ===

Все тесты проводились на [https://ru.wikipedia.org/wiki/Ломоносов_(суперкомпьютер) суперкомпьютере Ломоносов].
<br>
Тестировались две [https://github.com/bvdmitri/aintegrate/blob/master/functions.h функции] разной степени сложности.
<br>
Из тестов видно, что параллельная реализация с использованием технологий MPI и Intel TBB показывает прекрасную масштабируемость, в то же время версия на чистом MPI с управляющим узлом сильно проигрывает. Это связано с тем, что при синхронизации задач между процессорами происходит много пересылок сообщений MPI, в сравнении с вычислением значений функции в узловых точках. Это сильно замедляет работу программы в целом, более того при увеличении количества узлов управляющий узел не справляется с очень большим потоком сообщений от вычислительных узлов.

==== MPI + TBB ====

[[file:Mpi_tbb_1.png|thumb|center|500px|Рисунок 1. Результаты масштабируемости для первой функции]]
[[file:Mpi_tbb_2.png|thumb|center|500px|Рисунок 2. Результаты масштабируемости для второй функции]]

==== MPI Farm ====

[[file:Mpi_farm_1.png|thumb|center|500px|Рисунок 3. Результаты масштабируемости для первой функции]]
[[file:Mpi_farm_2.png|thumb|center|500px|Рисунок 4. Результаты масштабируемости для второй функции]]

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:43:19Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:23:18Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:18:03Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:17:50Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:15:25Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T23:14:55Z

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

Файл:Mpi tbb adaptive integral.png

2016-11-13T23:14:31Z

Bvdmitri:

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T22:44:31Z

Bvdmitri: /* Схема реализации последовательного алгоритма */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T22:42:11Z

Bvdmitri: /* Схема реализации последовательного алгоритма */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T22:20:15Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T22:17:04Z

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

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T22:15:39Z

Bvdmitri: /* Схема реализации последовательного алгоритма */

Участник:Bvdmitri/Адаптивное интегрирование

2016-11-13T22:14:27Z

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