#include <mpi.h> #include <stdio.h> #include <stdlib.h> #include <math.h> #include…
- User
#include <mpi.h> #include <stdio.h> #include <stdlib.h> #include <math.h> #include <string.h> #include <pthread.h>
#define L 100 //сложность задач #define ITERATIONS 30 //количество итераций #define MAX_TASKS 10000 //количество задач
pthread_t threads[2]; //Потоки для приема и выполнения задач pthread_mutex_t mutex; //Мьютекс для синхронизации доступа к общим данным int stop_thread = -1; //переменная-сигнал для остановки потоков int tasks[MAX_TASKS]; //Массив для хранения задач int size; //Количество процессов MPI int rank; //Ранг текущего процесса MPI int task_counter; //Счетчик задач для выполнения ХХХ мьютекс! int executed_counter; //Счетчик выполненных задач ХХХ мьютекс! double globalRes = 0; //Глобальный результат double globalRes_sum; //Сумма глобальных результатов
//Определение задач void initTasks(int* tasks, int amountOfTasks, int iterCounter) { for (int i = 0; i < amountOfTasks; i++) { tasks[i] = abs(50 - i % ITERATIONS) * abs(rank - (iterCounter % size)) * L; } }
//Выполнение задач void execute_tasks(int* tasks) { for (int i = 0; i < task_counter; i++) { pthread_mutex_lock(&mutex);//Блокировка mutex для безопасного изменения executed_counter int currentTaskWeight = tasks[i]; executed_counter++; pthread_mutex_unlock(&mutex);//Разблокировка mutex и разрешение доступа к общим данным
for (int j = 0; j < currentTaskWeight; j++) { globalRes += sqrt(sin(j) + cos(j)); } } //обнуление в критической секции чтобы избежать одновременного доступа к task_counter из разных потоков... pthread_mutex_lock(&mutex); task_counter = 0; pthread_mutex_unlock(&mutex); //task_counter сброшен и потоки могут продолжать работать с новыми задачами}
//Вывод статистики void printStats(double iteration_time, double min_time, double max_time) { printf("%d: Number of executed tasks - %d\n", rank, executed_counter); printf("%d: Global res - %f\n", rank, globalRes); printf("%d: Time of one iteration - %f sec\n", rank, iteration_time); printf("%d: Disbalance - %f\n", rank, max_time - min_time); printf("%d: Disbalance procent: - %.3f\n", rank, (max_time - min_time) / max_time * 100); }
//Функция для приема запросов задач от других процессов void* receiver(void* args) { int task_to_share; int s_rank;//sended ака процесс отправивший запрос while (1) { MPI_Recv(&s_rank, 1, MPI_INT, MPI_ANY_SOURCE, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);//Получение запроса на задачу от другого процесса if (s_rank == stop_thread) { pthread_exit(NULL); //Получен сигнал о завершении потока } pthread_mutex_lock(&mutex); //блокируем mutex перед изменением общих данных
if (task_counter > 5) { task_to_share = task_counter / 2; task_counter -= task_to_share; MPI_Send(&task_to_share, 1, MPI_INT, s_rank, 1, MPI_COMM_WORLD);//task_to_share процессу s_rank с тегом 1 MPI_Send(&tasks[task_to_share - 1], task_to_share, MPI_INT, s_rank, 1, MPI_COMM_WORLD);//часть массива задач tasks с тегом 1 } else { task_to_share = 0; MPI_Send(&task_to_share, 1, MPI_INT, s_rank, 1, MPI_COMM_WORLD);//сигнал о том что нет задач для передачи. } pthread_mutex_unlock(&mutex); }}
//Функция для выполнения задач void* executor(void* args) { double start_time, iteration_time = 0, min_time = 0, max_time = 0; int extra_task_counter = 0;
for (int i = 0; i < ITERATIONS; i++) { pthread_mutex_lock(&mutex); initTasks(tasks, MAX_TASKS, i); task_counter = MAX_TASKS; executed_counter = 0; pthread_mutex_unlock(&mutex); extra_task_counter = 0; //отслеживание дополнительных задач, которые могут быть получены от других процессов start_time = MPI_Wtime(); execute_tasks(tasks); for (int j = 0; j < size; j++) { if (j != rank) { MPI_Send(&rank, 1, MPI_INT, j, 0, MPI_COMM_WORLD);//отправляем свой собственный ранг с тегом 0 чтобы запросить задачи MPI_Recv(&extra_task_counter, 1, MPI_INT, j, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);//принимает ответ от другого процесса в котором содержится информация о количестве дополнительных задач extra_task_counter которые он готов передать if (extra_task_counter) { //Принимаем и выполняем дополнительные задачи от других процессов MPI_Recv(tasks, extra_task_counter, MPI_INT, j, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE); pthread_mutex_lock(&mutex); task_counter = extra_task_counter; pthread_mutex_unlock(&mutex); execute_tasks(tasks); } } } iteration_time = MPI_Wtime() - start_time; //Синхронизация времени выполнения между процессами MPI_Allreduce(&iteration_time, &min_time, 1, MPI_DOUBLE, MPI_MIN, MPI_COMM_WORLD); MPI_Allreduce(&iteration_time, &max_time, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD); MPI_Allreduce(&globalRes, &globalRes_sum, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD); printStats(iteration_time, min_time, max_time); } MPI_Send(&stop_thread, 1, MPI_INT, rank, 0, MPI_COMM_WORLD);//сигнал о завершении потока текущему процессу}
int main(int argc, char** argv) { int provided; MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);//многопоточность в MPI if (provided != MPI_THREAD_MULTIPLE) {//завершение при невозможности использовать наивысшей многопоточности mpi MPI_Finalize(); return 1; } MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); pthread_mutex_init(&mutex, NULL);
pthread_attr_t attrs; pthread_attr_init(&attrs); pthread_attr_setdetachstate(&attrs, PTHREAD_CREATE_JOINABLE);//присваивается атрибут потокам PTHREAD_CREATE_JOINABLE для возможности использовать join после их завершения double start_time = MPI_Wtime(); //Два потока: для приема задач и для выполнения pthread_create(&threads[0], &attrs, receiver, NULL); pthread_create(&threads[1], &attrs, executor, NULL); pthread_attr_destroy(&attrs); //ожидание завершения потоков через pthread_join pthread_join(threads[0], NULL); pthread_join(threads[1], NULL); pthread_mutex_destroy(&mutex); double t_time = MPI_Wtime() - start_time; if (rank == 0) { printf("%f\n", t_time); printf("%f\n", globalRes_sum); } MPI_Finalize(); return 0;} как сделать чтобы потоки receiver удалялись только после завершения всех executor
- Assistant
Так как потоки receiver и executor работают параллельно и одновременно, то для того чтобы потоки receiver удалялись только после завершения всех потоков executor, можно использовать счетчик, который будет отслеживать количество активных потоков executor.
Для этого вам нужно добавить глобальную переменную, которая будет отслеживать количество активных потоков executor. Каждый поток executor должен увеличивать этот счетчик при запуске и уменьшать при завершении. После завершения всех потоков executor счетчик должен быть равен 0, и только после этого потоки receiver могут завершить свою работу.
Пример кода:
- Добавление глобальной переменной для отслеживания активных потоков executor:
int active_executors = 0;- Внутри функции executor увеличиваем счетчик при запуске и уменьшаем при завершении:
void* executor(void* args) { // увеличиваем счетчик активных executor active_executors++; // код выполнения задач // уменьшаем счетчик активных executor active_executors--; }- В функции receiver проверяем, что все потоки executor завершили работу, прежде чем завершить поток receiver:
void* receiver(void* args) { int task_to_share; int s_rank; while (1) { // код обработки запросов и передачи задач // проверяем, что все потоки executor завершили работу if (active_executors == 0) { break; // завершаем поток receiver } } }Это позволит потокам receiver ожидать завершения всех потоков executor перед тем как завершить свою работу.
- User
но вот она глобальная но у каждого процесса своя копия
- Assistant
Если у каждого процесса своя копия глобальной переменной, то необходимо использовать сборку MPI для обмена информацией между процессами и синхронизацию их действий. В данном случае можно использовать функцию MPI_Allreduce для синхронизации счетчика активных потоков executor между всеми процессами.
Пример кода:
int active_executors = 0; void* executor(void* args) { // увеличиваем счетчик активных executor active_executors++; // код выполнения задач // уменьшаем счетчик активных executor active_executors--; // Синхронизация счетчика active_executors между всеми процессами int global_active_executors; MPI_Allreduce(&active_executors, &global_active_executors, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); // проверяем значение global_active_executors if (global_active_executors == 0) { // обработка завершения всех потоков executor } } void* receiver(void* args) { int task_to_share; int s_rank; while (1) { // код обработки запросов и передачи задач // Синхронизация счетчика active_executors между всеми процессами int global_active_executors; MPI_Allreduce(&active_executors, &global_active_executors, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); // проверяем значение global_active_executors if (global_active_executors == 0) { break; // завершаем поток receiver } } }Таким образом, используя функцию MPI_Allreduce, можно синхронизировать значение счетчика active_executors между всеми процессами и обеспечить правильное завершение потоков receiver после завершения всех потоков executor.
- User
как вообще работает MPI_Init_thread
- Assistant
MPI_Init_thread - это функция инициализации библиотеки MPI с поддержкой работы с многопоточностью. Она позволяет указать требуемый уровень поддержки многопоточности в MPI.
Прототип функции:
int MPI_Init_thread(int *argc, char ***argv, int required, int *provided)Параметры:
- argc: указатель на количество аргументов командной строки
- argv: указатель на массив аргументов командной строки
- required: требуемый уровень поддержки многопоточности
- provided: фактически предоставленный уровень поддержки многопоточности
Уровни поддержки многопоточности в MPI:
- MPI_THREAD_SINGLE: только один поток может использовать функции MPI
- MPI_THREAD_FUNNELED: только главный поток может вызывать функции MPI
- MPI_THREAD_SERIALIZED: несколько потоков могут вызывать функции MPI, но все вызовы должны быть сериализованы
- MPI_THREAD_MULTIPLE: несколько потоков могут вызывать функции MPI одновременно
Функция MPI_Init_thread возвращает значение 0 в случае успешной инициализации или код ошибки в случае возникновения проблем.
Пример использования MPI_Init_thread для работы с многопоточностью в MPI:
int provided; MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided); if (provided != MPI_THREAD_MULTIPLE) { printf("Ошибка: MPI не поддерживает многопоточность\n"); MPI_Finalize(); return 1; } // Ваш код работы с MPI в многопоточном режиме MPI_Finalize();При использовании MPI_Init_thread с уровнем MPI_THREAD_MULTIPLE возможна работа с несколькими потоками одновременно для вызовов функций MPI. Каждый поток должен самостоятельно использовать синхронизацию при обращении к функциям MPI, чтобы предотвратить возможные коллизии и ошибки.
- User
а сделай чтобы executor при завершении всем уменьшал этот global_active_executors
- Assistant
Чтобы каждый поток
executorуменьшал значениеglobal_active_executorsпосле завершения всех потоковexecutor, необходимо обновлять его значение после уменьшения счетчикаactive_executors. Для этого можно использовать функциюMPI_Allreduceдля обновления значенияglobal_active_executorsпо всем процессам после уменьшения или увеличенияactive_executors.Пример кода:
int active_executors = 0; int global_active_executors = 0; // Глобальное значение для отслеживания активных executor void* executor(void* args) { // увеличиваем счетчик активных executor active_executors++; // код выполнения задач // уменьшаем счетчик активных executor active_executors--; // Синхронизация счетчика active_executors между всеми процессами MPI_Allreduce(&active_executors, &global_active_executors, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); // обновляем global_active_executors после уменьшения active_executors global_active_executors -= 1; } void* receiver(void* args) { int task_to_share; int s_rank; while (1) { // код обработки запросов и передачи задач // Синхронизация счетчика active_executors между всеми процессами int global_active_executors; MPI_Allreduce(&active_executors, &global_active_executors, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD); // проверяем значение global_active_executors if (global_active_executors == 0) { break; // завершаем поток receiver } } }Таким образом, после завершения всех потоков
executor, глобальное значениеglobal_active_executorsбудет правильно обновлено после уменьшения счетчикаactive_executors.