Библиотека "mes.h" not found

/**
 * Программа моделирования управления движением на уличном перекрестке.
 *
 * Движение на каждой из 3-х прилегающих к перекрестку улиц моделируется отдельным процессом.
 * Процесс имитирует подъезжающие к перекрестку автомобили случайным образом, интенсивности потоков
 * от процессов различны. В начале работы светофор переключается с равными интервалами. По мере
 * накопления статистики по интенсивностям потоков время переключения светофора изменяется. Передача
 * информации процессу, имитирующему светофор, выполняется через сообщения.
 *
 * @author Федосеев Вячеслав.
 * @since v1.0
 */
#include <iostream>
#include <unistd.h>
#include <signal.h>
#include "stdlib.h"
#include "mes.h"
 
using namespace std;
 
// Тайминги
const int T_ALONE = 10000;
const int T_PROV = 100;
const int T_TRAFFIC_LIGHT = 1000;
const int TIME = 3;
const int LIMIT = 100;
 
/**
 * Заданный таймер
 * @param time время
 */
void delay(long time) {
    for (long i = 1; i < time; i++);
}
 
/**
 * Процесс светофора
 *
 * @param fd
 * @param fd_count1
 * @param fd_count2
 * @param fd_count3
 * @return идентификатор процесса
 */
int process_traffic_light(int fd[2], int fd_count1[2], int fd_count2[2], int fd_count3[2]) {
    int pid;
    int t1, t2, t3;
    int buf[1];
    int count1[1], count2[1], count3[1];
 
    // Создаем новый процесс
    pid = fork();
 
    if (pid < 0) {
        cout << "Не создан процесс светофора!" << endl;
        exit(1);
    }
 
    if (pid == 0) {
        while (true) {
            read(fd_count1[0], count1, sizeof(count1));
            write(fd_count1[1], count1, sizeof(count1));
            read(fd_count2[0], count2, sizeof(count2));
            write(fd_count2[1], count2, sizeof(count2));
            read(fd_count3[0], count3, sizeof(count3));
            write(fd_count3[1], count3, sizeof(count3));
 
            if (count1[0] + count2[0] + count3[0] > LIMIT) {
                t1 = 3 * T_TRAFFIC_LIGHT * count1[0] / (count1[0] + count2[0] + count3[0]);
                t2 = 3 * T_TRAFFIC_LIGHT * count2[0] / (count1[0] + count2[0] + count3[0]);
                t3 = 3 * T_TRAFFIC_LIGHT * count3[0] / (count1[0] + count2[0] + count3[0]);
            }
            else {
                t1 = t2 = t3 = T_TRAFFIC_LIGHT;
            }
 
            buf[0] = 1;
            write(fd[1], buf, sizeof(buf));
            delay(t1);
            buf[0] = 2;
            write(fd[1], buf, sizeof(buf));
            delay(t2);
            buf[0] = 3;
            write(fd[1], buf, sizeof(buf));
            delay(t3);
        }
    }
 
    return pid;
}
 
/**
 * Процесс проезда машин через перекресток
 * @param fd
 * @param fd1
 * @param fd2
 * @param fd3
 * @return идентификатор процесса
 */
int process_prov(int fd[2], int fd1[2], int fd2[2], int fd3[2]) {
    int pid;
    int t;
    int way[1];
    int sw = 0;
    int buf[1];
 
    // Создаем новый процесс
    pid = fork();
 
    if (pid < 0) {
        cout << "Не создан процесс перекресток!" << endl;
        exit(1);
    }
 
    if (pid == 0) {
        while (true) {
            if (read(fd[0], way, sizeof(way)) > 0)
                sw = way[0];
            switch (sw) {
            case 1:
                read(fd1[0], buf, sizeof(buf));
                if (buf[0] > 0)
                    buf[0]--;
                write(fd1[1], buf, sizeof(buf));
                t = (int)(((float)rand() / RAND_MAX) * T_PROV);
                delay(t);
                break;
            case 2:
                read(fd2[0], buf, sizeof(buf));
                if (buf[0] > 0)
                    buf[0]--;
                write(fd2[1], buf, sizeof(buf));
                t = (int)(((float)rand() / RAND_MAX) * T_PROV);
                delay(t);
                break;
            case 3:
                read(fd3[0], buf, sizeof(buf));
                if (buf[0] > 0)
                    buf[0]--;
                write(fd3[1], buf, sizeof(buf));
                t = (int)(((float)rand() / RAND_MAX) * T_PROV);
                delay(t);
                break;
            }
        }
    }
 
    return pid;
}
 
/**
 * Процесс создания машин
 * @param fd файловый дескриптор
 * @param fd_count файловый дескриптор, содержащий количество машин
 * @return идентификатор процесса
 */
int process_cars(int fd[2], int fd_count[2]) {
    int pid;
    int t;
    int buf[1];
    int cnt[1];
 
    // Создание процесса
    pid = fork();
 
    if (pid < 0) {
        cout << "Не создан процесс создания машин!" << endl;
        exit(1);
    }
 
    if (pid == 0) {
        while (true) {
            t = (int)(((float)rand() / RAND_MAX) * T_ALONE); // Время прихода транзактов
            delay(t);
            read(fd[0], buf, sizeof(buf));
            buf[0]++;
            write(fd[1], buf, sizeof(buf));
            read(fd_count[0], cnt, sizeof(cnt));
            cnt[0]++;
            if (write(fd_count[1], cnt, sizeof(cnt)) == -1) {
                break;
            };
        }
    }
 
    return pid;
}
 
int main() {
    int pid1, pid2, pid3, pid_traffic_light, pid_prov;
    int buf1[1], buf2[1], buf3[1], cnt1[1], cnt2[1], cnt3[1];
    int fd1[2], fd2[2], fd3[2], fd[2];
    int count1[2], count2[2], count3[2];
 
    buf1[0] = 0;
    buf2[0] = 0;
    buf3[0] = 0;
    cnt1[0] = 0;
    cnt2[0] = 0;
    cnt3[0] = 0;
 
    // Заполняем массив двумя новыми файловыми дескрипторами (fd, fd1, fd2, fd3, count1, count2, count3)
    pipe(fd1);
    pipe(fd2);
    pipe(fd3);
    pipe(fd);
 
    pipe(count1);
    pipe(count2);
    pipe(count3);
 
    // Записываем данные с буфера в файловый дескриптор fd1, fd2, fd3
    write(fd1[1], buf1, sizeof(buf1) * 2);
    write(fd2[1], buf2, sizeof(buf2) * 2);
    write(fd3[1], buf3, sizeof(buf3) * 2);
 
    // Записываем данные с буфера в файловый дескриптор count1, count2, count3
    write(count1[1], cnt1, sizeof(cnt1) * 2);
    write(count2[1], cnt2, sizeof(cnt2) * 2);
    write(count3[1], cnt3, sizeof(cnt3) * 2);
 
    // Создаем процессы светофора, проезды машин через перекресток
    pid_traffic_light = process_traffic_light(fd, count1, count2, count3);
    pid_prov = process_prov(fd, fd1, fd2, fd3);
 
    // Создаем процессы создания машин для дорог 1, 2, 3
    pid1 = process_cars(fd1, count1);
    pid2 = process_cars(fd2, count2);
    pid3 = process_cars(fd3, count3);
 
    cout << "Пожалуйста, подождите..." << endl;
    sleep(TIME);
 
    // Убиваем все процессы
    kill(pid1, SIGKILL);
    kill(pid2, SIGKILL);
    kill(pid3, SIGKILL);
    kill(pid_traffic_light, SIGKILL);
    kill(pid_prov, SIGKILL);
 
    // Считываем данные с файлового дескриптора fd1, fd2, fd3 и сохраняем данные в буфер buf1, buf2, buf3.
 
    read(fd1[0], buf1, sizeof(buf1) * 2);
    read(fd2[0], buf2, sizeof(buf2) * 2);
    read(fd3[0], buf3, sizeof(buf3) * 2);
    read(count1[0], cnt1, sizeof(cnt1) * 2);
    read(count2[0], cnt2, sizeof(cnt2) * 2);
    read(count3[0], cnt3, sizeof(cnt3) * 2);
 
    cout << endl;
    cout << "Количество машин, стоящие на 1 дороге = " << buf1[0] << endl;
    cout << "Количество машин, стоящие на 2 дороге = " << buf2[0] << endl;
    cout << "Количество машин, стоящие на 3 дороге = " << buf3[0] << endl;
 
    cout << endl;
    cout << "Количество машин, проехавшие мимо 1 светофора = " << cnt1[0] << endl;
    cout << "Количество машин, проехавшие мимо 2 светофора = " << cnt2[0] << endl;
    cout << "Количество машин, проехавшие мимо 3 светофора = " << cnt3[0] << endl;
 
    cout << endl;
    cout << "Количество машин, проехавшие мимо всех светофоров = " << cnt1[0] + cnt2[0] + cnt3[0] << endl;
 
    return 0;
}