pajjilykk/OS-LABS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

comment shit out in 2

Browse Source
This commit is contained in:
pajjilykk
2026-04-28 15:52:29 +07:00
parent 85c625a74a
commit 335769a10e
1 changed files with 76 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
2/main.cpp
+76 -35
View File
@@ -8,43 +8,47 @@
#include <unistd.h>
#include <sstream>
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<Node> 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;
}