diff --git a/2/main.cpp b/2/main.cpp index 47e25b1..ab0902f 100644 --- a/2/main.cpp +++ b/2/main.cpp @@ -8,43 +8,47 @@ #include #include -constexpr int NIL = -1; +constexpr int NIL = -1; // Маркер конца списка (аналог nullptr для индексов) +// Структура узла списка, хранящегося в массиве struct Node { - int value; - int next; + int value; // Значение элемента + int next; // Индекс следующего элемента в массиве pool }; +// Результат работы функции сортировки struct SortResult { - int head; - long long comparisons; + int head; // Индекс головы отсортированного списка + long long comparisons; // Счетчик выполненных сравнений }; +// Аргументы для передачи в новый поток struct Args { - Node* pool; - int head; - int depth; - int size; - int threshold; - SortResult* res_out; + Node* pool; // Указатель на массив всех узлов + int head; // Голова подсписка для сортировки + int depth; // Текущая глубина рекурсии + int size; // Количество элементов в подсписке + int threshold; // Порог, ниже которого новые потоки не создаются + SortResult* res_out; // Куда записать результат работы потока }; -int active_threads = 0; -int max_threads = 4; -pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER; -pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER; -bool enable_logging = false; +// Глобальные переменные для управления потоками +int active_threads = 0; // Текущее количество работающих потоков +int max_threads = 4; // Максимально допустимое количество потоков +pthread_mutex_t counter_mutex = PTHREAD_MUTEX_INITIALIZER; // Мьютекс для счетчика потоков +pthread_mutex_t log_mutex = PTHREAD_MUTEX_INITIALIZER; // Мьютекс для синхронизации вывода +bool enable_logging = false; // Флаг включения логирования -// Высокоточное логирование для exporter.py +// Логирование событий для анализа производительности void log_event(const std::string& type, int head, int depth) { if (!enable_logging) return; - pthread_mutex_lock(&log_mutex); + pthread_mutex_lock(&log_mutex); // Блокируем вывод, чтобы строки не перемешались timeval tv{}; gettimeofday(&tv, nullptr); double current_time = tv.tv_sec + tv.tv_usec * 1e-6; - std::cout << type << " TID=" << pthread_self() + std::cout << type << " TID=" << pthread_self() // ID текущего потока << " depth=" << depth << " range=[" << head << "," << head << "]" << " time=" << std::fixed << std::setprecision(6) << current_time << std::endl; @@ -52,6 +56,7 @@ void log_event(const std::string& type, int head, int depth) { pthread_mutex_unlock(&log_mutex); } +// Разделение списка на две равные части (алгоритм "черепахи и зайца") void split_list(Node* pool, int head, int& left, int& right) { if (head == NIL || pool[head].next == NIL) { left = head; right = NIL; return; @@ -59,55 +64,75 @@ void split_list(Node* pool, int head, int& left, int& right) { int slow = head, fast = pool[head].next; while (fast != NIL) { fast = pool[fast].next; - if (fast != NIL) { slow = pool[slow].next; fast = pool[fast].next; } + if (fast != NIL) { + slow = pool[slow].next; + fast = pool[fast].next; + } } left = head; right = pool[slow].next; - pool[slow].next = NIL; + pool[slow].next = NIL; // Разрываем список на две части } +// Слияние двух отсортированных списков SortResult merge_lists(Node* pool, int l, int r) { long long comps = 0; if (l == NIL) return {r, 0}; if (r == NIL) return {l, 0}; + int res_head = NIL, tail = NIL; + + // Вспомогательная лямбда для добавления элемента в результирующий список auto append = [&](int idx) { if (res_head == NIL) res_head = tail = idx; else { pool[tail].next = idx; tail = idx; } }; + while (l != NIL && r != NIL) { comps++; - if (pool[l].value <= pool[r].value) { int n = pool[l].next; append(l); l = n; } - else { int n = pool[r].next; append(r); r = n; } + if (pool[l].value <= pool[r].value) { + int n = pool[l].next; append(l); l = n; + } else { + int n = pool[r].next; append(r); r = n; + } } + // Прикрепляем оставшиеся элементы if (l != NIL) pool[tail].next = l; if (r != NIL) pool[tail].next = r; + return {res_head, comps}; } +// Прототип функции для использования в thread_func SortResult parallel_list_sort(Node* pool, int head, int depth, int size, int threshold); +// Функция-обертка для запуска в pthread void* thread_func(void* arg) { Args* a = (Args*)arg; + // Выполняем сортировку и записываем результат по указателю *(a->res_out) = parallel_list_sort(a->pool, a->head, a->depth, a->size, a->threshold); return nullptr; } +// Основная рекурсивная функция параллельной сортировки SortResult parallel_list_sort(Node* pool, int head, int depth, int size, int threshold) { log_event("START", head, depth); + + // Базовый случай рекурсии: список пуст или из одного элемента if (head == NIL || pool[head].next == NIL) { log_event("END", head, depth); return {head, 0}; } int left_p, right_p; - split_list(pool, head, left_p, right_p); + split_list(pool, head, left_p, right_p); // Разбиваем список int new_size = size / 2; pthread_t tid; - bool spawned = false; + bool spawned = false; // Флаг: был ли создан новый поток SortResult res_right = {NIL, 0}; + // Решаем, нужно ли создавать новый поток if (size > threshold) { pthread_mutex_lock(&counter_mutex); if (active_threads < max_threads) { @@ -118,20 +143,26 @@ SortResult parallel_list_sort(Node* pool, int head, int depth, int size, int thr } if (spawned) { + // Создаем поток для правой части Args* args = new Args{pool, right_p, depth + 1, new_size, threshold, &res_right}; pthread_create(&tid, nullptr, thread_func, args); + + // Левую часть сортируем в текущем потоке SortResult res_left = parallel_list_sort(pool, left_p, depth + 1, new_size, threshold); + + // Дожидаемся завершения правого потока pthread_join(tid, nullptr); pthread_mutex_lock(&counter_mutex); - active_threads--; + active_threads--; // Освобождаем место для новых потоков pthread_mutex_unlock(&counter_mutex); SortResult m = merge_lists(pool, res_left.head, res_right.head); - delete args; + delete args; // Очищаем память, выделенную под аргументы log_event("END", m.head, depth); return {m.head, res_left.comparisons + res_right.comparisons + m.comparisons}; } else { + // Последовательная сортировка обеих частей в текущем потоке SortResult res_left = parallel_list_sort(pool, left_p, depth + 1, new_size, threshold); SortResult res_r_seq = parallel_list_sort(pool, right_p, depth + 1, new_size, threshold); SortResult m = merge_lists(pool, res_left.head, res_r_seq.head); @@ -141,29 +172,39 @@ SortResult parallel_list_sort(Node* pool, int head, int depth, int size, int thr } int main(int argc, char* argv[]) { - int n = 100000; - int threshold = 5000; + int n = 100000; // Размер списка по умолчанию + int threshold = 5000; // Порог распараллеливания по умолчанию + + // Считывание параметров из командной строки if (argc >= 2) n = std::atoi(argv[1]); if (argc >= 3) max_threads = std::atoi(argv[2]); if (argc >= 4) threshold = std::atoi(argv[3]); - // Включаем логи только для маленьких N + // Включаем подробные логи только для небольших задач, чтобы не спамить в консоль if (n < 5000) enable_logging = true; + // Инициализация пула узлов std::vector pool(n); - std::mt19937 rng(1337); + std::mt19937 rng(1337); // Фиксированный seed для воспроизводимости for (int i = 0; i < n; i++) { pool[i].value = rng() % 100000; pool[i].next = (i == n - 1) ? NIL : i + 1; } timeval t1, t2; - gettimeofday(&t1, nullptr); - SortResult final_res = parallel_list_sort(pool.data(), 0, 0, n, threshold); - gettimeofday(&t2, nullptr); + gettimeofday(&t1, nullptr); // Замер времени начала + // Запуск основной функции сортировки + SortResult final_res = parallel_list_sort(pool.data(), 0, 0, n, threshold); + + gettimeofday(&t2, nullptr); // Замер времени окончания + + // Расчет и вывод статистики double elapsed = (t2.tv_sec - t1.tv_sec) + (t2.tv_usec - t1.tv_usec) * 1e-6; - std::cerr << "STAT: threads=" << max_threads << " size=" << n << " threshold=" << threshold << " time=" << elapsed << std::endl; + std::cerr << "STAT: threads=" << max_threads + << " size=" << n + << " threshold=" << threshold + << " time=" << elapsed << " sec" << std::endl; return 0; }