Очереди с приоритетом("Процессор", 3 сем.)

#include <iostream>
#include <queue>

using namespace std;

//инициализация очереди
void initializeOrder(queue <int>(&queueMatrix)[3][3]) {

    //инициализация запросов времени для 1-го клиента
    int clientRequests1[10] = {4, 2, 3, 4, 6, 8, 9, 3, 2, 1};
    for (int i = 0; i < 10; i++)
        queueMatrix[0][0].push(clientRequests1[i]);

    //инициализация запросов времени для 2-го клиента
    int clientRequests2[10] = {4, 2, 6, 8, 7, 3, 1, 2, 4, 6};
    for (int i = 0; i < 10; i++)
        queueMatrix[1][0].push(clientRequests2[i]);

    //инициализация запросов времени для 3-го клиента
    int clientRequests3[10] = { 2, 3, 4, 5, 9, 7, 6, 8, 3, 2 };
    for (int i = 0; i < 10; i++)
        queueMatrix[1][1].push(clientRequests3[i]);

    //инициализация запросов времени для 4-го клиента
    int clientRequests4[11] = { 3, 3, 4, 2, 4, 6, 8, 9, 7, 2, 1 };
    for (int i = 0; i < 10; i++)
        queueMatrix[2][0].push(clientRequests4[i]);

    //инициализация запросов времени для 5-го клиента
    int clientRequests5[10] = { 2, 1, 2, 4, 5, 2, 4, 6, 8, 9};
    for (int i = 0; i < 10; i++)
        queueMatrix[2][1].push(clientRequests5[i]);

    //инициализация запросов времени для 6-го клиента
    int clientRequests6[10] = { 1, 2, 1, 6, 1, 9, 8, 1, 6, 8 };
    for (int i = 0; i < 10; i++)
        queueMatrix[2][2].push(clientRequests6[i]);
}

//структура, описывающая клиента
struct client {
    int priority;
    int index;
};

client findClient(int(&currentClient)[3], const char(&busyArr)[3][3][1000], int& currentSec, queue <int>(&clientMatrix)[3][3], int& numberOfProperties, int(&clientsArr)[3]) {
    client clientInstance;
    clientInstance.priority = clientInstance.index = -1;
    for (int i = 0; i < numberOfProperties; ++i)
    {
        int previousClient = currentClient[i];
        ++currentClient[i];
        currentClient[i] %= clientsArr[i];

        for (int j = 0; j < clientsArr[i]; ++j) {
            if ((!clientMatrix[i][currentClient[i]].empty()) && (busyArr[i][currentClient[i]][currentSec] == 'O'))
            {
                clientInstance.priority = i;
                clientInstance.index = currentClient[i];
                return clientInstance;
            }
            ++currentClient[i];
            currentClient[i] %= clientsArr[i];
        }
    }
    return clientInstance;
}

//методы процессора
bool hasToWork(queue <int>(&clientMatrix)[3][3]) {
    for (int i = 0; i < 3; ++i)
        for (int j = 0; j < 3; ++j)
            if (!clientMatrix[i][j].empty())
                return 1;
    return 0;
}

void initializeBusy(char(&a)[3][3][1000]) {
    for (int i = 0; i < 3; ++i)
        for (int j = 0; j < 3; ++j)
            for (int k = 0; k < 1000; ++k)
                a[i][j][k] = 'O';
    return;
}

//процедуры вывода в консоль
void printBusy(char(&requestQueue)[1000], int& wholeTime, int& processingTact) {
    for (int i = max(0, wholeTime - processingTact * 4); i < wholeTime; ++i)
    {
        cout << requestQueue[i] << " ";
        if (i % processingTact == processingTact - 1)
            cout << "| ";
    }
    cout << "\n";
    return;
}

void printQueue(queue <int>& requestQueue, int priorityIndex, int clientIndex) {
    cout << "Клиент приоритета " << priorityIndex + 1 << " под номером " << clientIndex + 1 << ": ";
    if (requestQueue.empty())
        cout << "запросов больше нет.\n";
    else
    {
        for (int i = 0; i < requestQueue.size(); ++i)
        {
            requestQueue.push(requestQueue.front());
            cout << requestQueue.front() << " ";
            requestQueue.pop();
        }
        cout << "\n";
    }
}

int main() {
    setlocale(LC_ALL, "Rus");

    queue <int> queueMatrix[3][3];
    initializeOrder(queueMatrix);
    char processorBusynessTable[3][3][1000];
    int clientsArr[3] = { 1, 2, 3 };
    int numberOfProperties = 3;
    int processingTact, inputTact;
    initializeBusy(processorBusynessTable);

    cout << "Пожалуйста, введите время такта обработки(условные ед. времени): ";
    cin >> processingTact;
    cout << "Пожалуйста, введите время такта ввода(условные ед. времени): ";
    cin >> inputTact;
    cout << "\n\n\t\t\t\t\t\t\tОбработка началась...\n\n";

    bool shouldEndWork = 0, isDowntime;
    int currentClient[3] = { -1, -1, -1 };
    int currentSec = 0;
    int downtime = 0;

    while (!shouldEndWork)
    {
        client clientInstance = findClient(currentClient, processorBusynessTable, currentSec, queueMatrix, numberOfProperties, clientsArr);
        cout << "Приоритет текущего клиента: " << clientInstance.priority + 1
            << "\nНомер текущего клиента в своей очереди: " << clientInstance.index + 1
            << "\nТекущая секунда: " << currentSec
            << "\n-------------------------------------------------------------"
            << "\nОставшиеся запросы:\n";

        /*
        U - обращение клиента к процессору
        b - обдумывание после обращения
        O - ожидание
        */
        if (clientInstance.priority != -1)
        {
            for (int i = 0; i < min(processingTact, queueMatrix[clientInstance.priority][clientInstance.index].front()); ++i)
            {
                processorBusynessTable[clientInstance.priority][clientInstance.index][currentSec] = 'U';
                ++currentSec;
            }

            for (int k = currentSec - processingTact; k < currentSec; k++)
            {
                isDowntime = true;
                for (int i = 0; i < 3; i++)
                    for (int j = 0; j < 3; j++)
                        if (processorBusynessTable[i][j][k] == 'U')
                            isDowntime = false;
                if (isDowntime)
                    downtime++;
            }

            queueMatrix[clientInstance.priority][clientInstance.index].push(queueMatrix[clientInstance.priority][clientInstance.index].front() - processingTact);
            queueMatrix[clientInstance.priority][clientInstance.index].pop();

            for (int i = 1; i < queueMatrix[clientInstance.priority][clientInstance.index].size(); ++i)
            {
                queueMatrix[clientInstance.priority][clientInstance.index].push(queueMatrix[clientInstance.priority][clientInstance.index].front());
                queueMatrix[clientInstance.priority][clientInstance.index].pop();
            }

            if (queueMatrix[clientInstance.priority][clientInstance.index].front() <= 0)
            {
                queueMatrix[clientInstance.priority][clientInstance.index].pop();
                for (int i = 0; i < inputTact; ++i)
                    processorBusynessTable[clientInstance.priority][clientInstance.index][currentSec + i] = 'b';
            }

            currentSec += currentSec % processingTact ? processingTact - currentSec % processingTact : 0;

        }
        else
            currentSec += processingTact;

        //вывод очередей запросов в консоль
        printQueue(queueMatrix[0][0], 0, 0);
        printQueue(queueMatrix[1][0], 1, 0);
        printQueue(queueMatrix[1][1], 1, 1);
        printQueue(queueMatrix[2][0], 1, 2);
        printQueue(queueMatrix[2][1], 2, 0);
        printQueue(queueMatrix[2][2], 2, 1);

        //вывод таблицы обработки в консоль
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
                printBusy(processorBusynessTable[i][j], currentSec, processingTact);

        cout << "\n\n";

        shouldEndWork = !hasToWork(queueMatrix);
    }

    cout << "Общее время работы: " << currentSec << " условных единиц времени.\n";
    cout << "Общее время простоя: " << downtime << " условных единиц времени.\n";
    cout << "КПД: " << (currentSec - downtime) * 100 / currentSec << "%.\n";

    return 0;
}