cube_tm/cube_tm_2.cpp - master - savushkin/CubeTaskManager

cube_tm/cube_tm_2.cpp
498 строк16 KB
Alexander Savushkin
feat: cube_tm_2 - 2025-10-23 17:58:06
23 окт 2025, 17:58
23 окт 2025, 17:5802548f3
#include <iostream>
#include <memory>
#include <string>
#include <functional>
#include <vector>
#include <algorithm>

// Типы задач
enum class TaskType
{
    SYSTEM = 0,
    USER = 1,
    BACKGROUND = 2
};

// Приоритеты задач
enum class Priority
{
    HIGH = 0,
    MEDIUM = 1,
    LOW = 2
};

// Состояния задач
enum class TaskState
{
    READY,
    RUNNING,
    SUSPENDED,
    TERMINATED
};

// Базовый класс задачи
class Task
{
public:
    int task_id;
    std::string name;
    TaskType type;
    Priority priority;
    TaskState state;
    void *task_object; // Указатель на объект задачи (процесс, поток и т.д.)
    int cpu_usage;
    int memory_usage;

    Task(int id, const std::string &task_name, TaskType task_type,
         Priority task_priority, void *obj = nullptr)
        : task_id(id), name(task_name), type(task_type),
          priority(task_priority), state(TaskState::READY),
          task_object(obj), cpu_usage(0), memory_usage(0) {}

    virtual ~Task() = default;

    virtual void execute()
    {
        state = TaskState::RUNNING;
        std::cout << "Выполняется задача: " << name << " (ID: " << task_id << ")" << std::endl;
    }

    virtual void suspend()
    {
        state = TaskState::SUSPENDED;
        std::cout << "Задача приостановлена: " << name << std::endl;
    }

    virtual void resume()
    {
        state = TaskState::READY;
        std::cout << "Задача возобновлена: " << name << std::endl;
    }

    virtual void terminate()
    {
        state = TaskState::TERMINATED;
        std::cout << "Задача завершена: " << name << std::endl;
    }
};

// Узел трехсвязного списка
template <typename T>
class ThreeDNode
{
public:
    std::shared_ptr<T> data;

    // Ссылки на соседние узлы в трех направлениях
    std::shared_ptr<ThreeDNode<T>> next_x; // по приоритету
    std::shared_ptr<ThreeDNode<T>> next_y; // по типу задачи
    std::shared_ptr<ThreeDNode<T>> next_z; // по времени/очереди

    ThreeDNode(const std::shared_ptr<T> &task_data)
        : data(task_data), next_x(nullptr), next_y(nullptr), next_z(nullptr) {}
};

// Диспетчер задач на основе трехсвязного списка
class TaskScheduler
{
private:
    std::shared_ptr<ThreeDNode<Task>> origin;
    int next_task_id;

    // Размеры по осям
    static const int PRIORITY_LEVELS = 3; // HIGH, MEDIUM, LOW
    static const int TASK_TYPES = 3;      // SYSTEM, USER, BACKGROUND

public:
    TaskScheduler() : next_task_id(1)
    {
        initializeScheduler();
    }

private:
    void initializeScheduler()
    {
        // Создаем начальную структуру с пустыми узлами
        auto ***nodes = new std::shared_ptr<ThreeDNode<Task>> **[PRIORITY_LEVELS];

        for (int x = 0; x < PRIORITY_LEVELS; x++)
        {
            nodes[x] = new std::shared_ptr<ThreeDNode<Task>> *[TASK_TYPES];
            for (int y = 0; y < TASK_TYPES; y++)
            {
                nodes[x][y] = new std::shared_ptr<ThreeDNode<Task>>[1]; // Одна ячейка по Z
                nodes[x][y][0] = nullptr;                               // Начально все узлы пустые
            }
        }

        origin = nullptr;

        // Очистка временного массива
        for (int x = 0; x < PRIORITY_LEVELS; x++)
        {
            for (int y = 0; y < TASK_TYPES; y++)
            {
                delete[] nodes[x][y];
            }
            delete[] nodes[x];
        }
        delete[] nodes;
    }

    // Получение координат для задачи
    int getXCoord(Priority priority)
    {
        return static_cast<int>(priority);
    }

    int getYCoord(TaskType type)
    {
        return static_cast<int>(type);
    }

public:
    // Добавление задачи
    void addTask(const std::string &name, TaskType type, Priority priority, void *task_obj = nullptr)
    {
        auto task = std::make_shared<Task>(next_task_id++, name, type, priority, task_obj);
        auto new_node = std::make_shared<ThreeDNode<Task>>(task);

        int x = getXCoord(priority);
        int y = getYCoord(type);

        // Вставляем в начало соответствующей цепочки по Z
        if (!origin)
        {
            origin = new_node;
        }
        else
        {
            // Находим последний узел в цепочке Z для данной позиции (x,y)
            auto last_node = findLastInZChain(x, y);
            if (last_node)
            {
                last_node->next_z = new_node;
            }
            else
            {
                // Если цепочка пустая, находим узел (x,y,0) и вставляем
                auto xy_node = findXYNode(x, y);
                if (xy_node)
                {
                    xy_node->next_z = new_node;
                }
                else
                {
                    // Создаем новую цепочку
                    createNewChain(x, y, new_node);
                }
            }
        }

        std::cout << "Задача добавлена: " << name << " (ID: " << task->task_id
                  << ", Приоритет: " << static_cast<int>(priority)
                  << ", Тип: " << static_cast<int>(type) << ")" << std::endl;

        optimizeTasks();
    }

    // Удаление задачи по ID
    bool removeTask(int task_id)
    {
        if (!origin)
            return false;

        // Поиск задачи по всем цепочкам
        for (int x = 0; x < PRIORITY_LEVELS; x++)
        {
            for (int y = 0; y < TASK_TYPES; y++)
            {
                auto current = findXYNode(x, y);
                std::shared_ptr<ThreeDNode<Task>> prev = nullptr;

                while (current)
                {
                    if (current->data->task_id == task_id)
                    {
                        // Нашли задачу для удаления
                        if (prev)
                        {
                            prev->next_z = current->next_z;
                        }
                        else
                        {
                            // Это первый узел в Z-цепочке
                            updateFirstInZChain(x, y, current->next_z);
                        }

                        std::cout << "Задача удалена: " << current->data->name
                                  << " (ID: " << task_id << ")" << std::endl;
                        return true;
                    }
                    prev = current;
                    current = current->next_z;
                }
            }
        }

        std::cout << "Задача с ID " << task_id << " не найдена" << std::endl;
        return false;
    }

    // Оптимизация задач по приоритету
    void optimizeTasks()
    {
        std::cout << "Оптимизация задач по приоритету..." << std::endl;

        // Перемещаем задачи с высоким приоритетом в начало очередей
        for (int y = 0; y < TASK_TYPES; y++)
        {
            auto high_priority_tasks = getTasksByPriorityAndType(Priority::HIGH, static_cast<TaskType>(y));

            for (const auto &task : high_priority_tasks)
            {
                // Удаляем и добавляем заново для перемещения в начало
                removeTask(task->task_id);
                addTask(task->name, task->type, task->priority, task->task_object);
            }
        }
    }

    // Запуск задач определенного типа
    void runTasksByType(TaskType type)
    {
        std::cout << "\n=== Запуск задач типа " << static_cast<int>(type) << " ===" << std::endl;

        for (int x = 0; x < PRIORITY_LEVELS; x++)
        {
            auto tasks = getTasksByPriorityAndType(static_cast<Priority>(x), type);

            for (const auto &task : tasks)
            {
                if (task->state != TaskState::TERMINATED)
                {
                    task->execute();
                }
            }
        }
    }

    // Остановка задач определенного типа
    void suspendTasksByType(TaskType type)
    {
        std::cout << "\n=== Остановка задач типа " << static_cast<int>(type) << " ===" << std::endl;

        for (int x = 0; x < PRIORITY_LEVELS; x++)
        {
            auto tasks = getTasksByPriorityAndType(static_cast<Priority>(x), type);

            for (const auto &task : tasks)
            {
                if (task->state == TaskState::RUNNING || task->state == TaskState::READY)
                {
                    task->suspend();
                }
            }
        }
    }

    // Изменение приоритета задачи (перемещение вперед/назад)
    bool changeTaskPriority(int task_id, Priority new_priority)
    {
        // Находим задачу
        std::shared_ptr<Task> task_to_move = nullptr;
        TaskType original_type;

        for (int x = 0; x < PRIORITY_LEVELS && !task_to_move; x++)
        {
            for (int y = 0; y < TASK_TYPES && !task_to_move; y++)
            {
                auto current = findXYNode(x, y);
                while (current && !task_to_move)
                {
                    if (current->data->task_id == task_id)
                    {
                        task_to_move = current->data;
                        original_type = current->data->type;
                        break;
                    }
                    current = current->next_z;
                }
            }
        }

        if (!task_to_move)
        {
            std::cout << "Задача с ID " << task_id << " не найдена" << std::endl;
            return false;
        }

        // Удаляем и добавляем с новым приоритетом
        removeTask(task_id);
        addTask(task_to_move->name, original_type, new_priority, task_to_move->task_object);

        std::cout << "Приоритет задачи " << task_to_move->name
                  << " изменен на " << static_cast<int>(new_priority) << std::endl;
        return true;
    }

    // Вывод всех задач
    void displayAllTasks()
    {
        std::cout << "\n=== ВСЕ ЗАДАЧИ ===" << std::endl;

        for (int x = 0; x < PRIORITY_LEVELS; x++)
        {
            for (int y = 0; y < TASK_TYPES; y++)
            {
                auto current = findXYNode(x, y);
                int count = 0;

                while (current)
                {
                    auto task = current->data;
                    std::cout << "ID: " << task->task_id
                              << " | Имя: " << task->name
                              << " | Приоритет: " << static_cast<int>(task->priority)
                              << " | Тип: " << static_cast<int>(task->type)
                              << " | Состояние: " << static_cast<int>(task->state)
                              << " | CPU: " << task->cpu_usage << "%"
                              << std::endl;
                    count++;
                    current = current->next_z;
                }

                if (count > 0)
                {
                    std::cout << "--- Всего в категории: " << count << " ---" << std::endl;
                }
            }
        }
    }

private:
    // Вспомогательные методы для работы со структурой
    std::shared_ptr<ThreeDNode<Task>> findXYNode(int x, int y)
    {
        if (!origin)
            return nullptr;

        // В упрощенной реализации ищем в Z-цепочках
        // В полной реализации нужны связи по X и Y
        auto current = origin;
        while (current)
        {
            int current_x = getXCoord(current->data->priority);
            int current_y = getYCoord(current->data->type);

            if (current_x == x && current_y == y)
            {
                return current;
            }

            // В этой упрощенной версии используем только Z-связи
            // Для полной реализации нужны X и Y связи
            current = current->next_z;
        }

        return nullptr;
    }

    std::shared_ptr<ThreeDNode<Task>> findLastInZChain(int x, int y)
    {
        auto current = findXYNode(x, y);
        if (!current)
            return nullptr;

        while (current->next_z)
        {
            current = current->next_z;
        }
        return current;
    }

    void createNewChain(int x, int y, std::shared_ptr<ThreeDNode<Task>> new_node)
    {
        // В упрощенной реализации добавляем в общую Z-цепочку
        if (!origin)
        {
            origin = new_node;
        }
        else
        {
            auto last = origin;
            while (last->next_z)
            {
                last = last->next_z;
            }
            last->next_z = new_node;
        }
    }

    void updateFirstInZChain(int x, int y, std::shared_ptr<ThreeDNode<Task>> new_first)
    {
        // В упрощенной реализации обновляем origin если нужно
        auto current = findXYNode(x, y);
        if (current == origin)
        {
            origin = new_first;
        }
    }

    std::vector<std::shared_ptr<Task>> getTasksByPriorityAndType(Priority priority, TaskType type)
    {
        std::vector<std::shared_ptr<Task>> tasks;
        int x = getXCoord(priority);
        int y = getYCoord(type);

        auto current = findXYNode(x, y);
        while (current)
        {
            tasks.push_back(current->data);
            current = current->next_z;
        }

        return tasks;
    }
};

// Демонстрация использования
int main()
{
    TaskScheduler scheduler;

    // Добавление задач
    scheduler.addTask("Системный мониторинг", TaskType::SYSTEM, Priority::HIGH);
    scheduler.addTask("Обновление антивируса", TaskType::SYSTEM, Priority::MEDIUM);
    scheduler.addTask("Фоновая синхронизация", TaskType::BACKGROUND, Priority::LOW);
    scheduler.addTask("Пользовательский редактор", TaskType::USER, Priority::HIGH);
    scheduler.addTask("Загрузка файлов", TaskType::USER, Priority::MEDIUM);
    scheduler.addTask("Фоновое резервное копирование", TaskType::BACKGROUND, Priority::LOW);

    // Вывод всех задач
    scheduler.displayAllTasks();

    // Запуск задач по типам
    scheduler.runTasksByType(TaskType::SYSTEM);
    scheduler.runTasksByType(TaskType::USER);

    // Изменение приоритета
    scheduler.changeTaskPriority(3, Priority::LOW); // Понижаем приоритет редактора

    // Остановка фоновых задач
    scheduler.suspendTasksByType(TaskType::BACKGROUND);

    // Оптимизация
    scheduler.optimizeTasks();

    // Вывод после изменений
    scheduler.displayAllTasks();

    // Удаление задачи
    scheduler.removeTask(2);

    // Финальный вывод
    scheduler.displayAllTasks();

    return 0;
}