Код программы

//---------------------------------------------------------------------------

#include < vcl.h>

#include < conio.h>

#pragma hdrstop

//---------------------------------------------------------------------------

#pragma argsused

#include < math.h>

#include < cstdio>

#define NUM_PROC 4 // количество процессов

#define NUM_RES 2 // количество ресурсов

struct Resource // Структура данных ресурса (п. 2, 3)

{

int id, s; // идентификатор и семафор

int waiters[NUM_PROC]; // список ожидающих ресурс процессов (п. 4)

int owner; // текущий владелец ресурса

};

//===================================================

// Код получения ресурса:

bool P(int& s)

{

// Функция уменьшения значения семафора (п. 1)

// Возвращает true, если значение семафора уменьшено,

// и false, если уменьшение невозможно.

if (s > 0)

{

s -= 1;

return true;

}

else return false;

}

//===================================================

void insert(int* arr, int val)

{

// Процедура добавления процесса в конец очереди (п. 5)

int i = 0;

while (arr[i]! = -1) i++;

arr[i] = val;

arr[i+1] = -1; // в конце очереди всегда стоит -1

}

//===================================================

void wait(Resource& res, int proc)

{

// Процедура постановки в очередь на ресурс res процесса с номером proc (п. 1)

insert(res.waiters, proc);

}

//===================================================

bool seize(Resource& res, int proc)

{

// Процедура получения доступа к ресурсу res процессом с номером proc.

// Возвращает true, если доступ получен, и false, если процесс поставлен в очередь.

if (P(res.s)) // Шаг 1 алгоритма А1

{ // Шаг 2 алгоритма А1:

res.owner = proc;

return true;

}

else

{ // Шаг 3 алгоритма А1:

wait(res, proc);

return false;

}

}

//===================================================

// Код освобождения ресурса:

void V(int& s)

{

// Функция увеличения значения семафора (п. 1)

if (s == 0) s += 1;

}

//===================================================

int allocator(Resource& res)

{

// Функция, возвращающая номер процесса, который получит доступ к ресурсу следующим (п. 7)

return res.waiters[0]; // в простейшем случае, возвращает следующий процесс в очереди

}

//===================================================

void remove(int* arr, int val)

{

// Процедура удаления процесса из очереди (п. 6)

int i = 0;

while (arr[i]! = val) i++;

do

{

arr[i] = arr[i+1];

i++;

}

while (arr[i]! = -1);

}

//===================================================

void signal(Resource& res)

{

// Процедура оповещения о том, что ресурс res свободен (п. 1)

// Возвращает false, если ресурс теперь занят другим процессом,

// и true, если ресурс свободен.

int next = allocator(res);

remove(res.waiters, next);

res.owner = next;

}

//===================================================

void release(Resource& res)

{

// Процедура освобождения ресурса res.

if (res.waiters[0] == -1) // Шаг 1 алгоритма А2

{ // Шаг 2 алгоритма А2:

V(res.s);

res.owner = -1;

}

else

{ // Шаг 3 алгоритма А2:

signal(res);

}

}

//===================================================

// Код, реализующий пользовательский интерфейс:

int main()

{//1

Resource resource[NUM_RES]; // массив ресурсов

for (int i = 0; i < NUM_RES; i++)

{//2

resource[i].id = i;

resource[i].s = 1;

resource[i].waiters[0] = -1; // очередь пуста

resource[i].owner = -1; // ресурс свободен

}//2

int blocked[NUM_PROC]; // массив определяет, какой ресурс сейчас ожидает процесс

for (int i = 0; i < NUM_PROC; i++)

{

blocked[i] = -1; // означает, что процесс не ожидает никакого ресурса

}

setlocale(LC_ALL, " rus");

printf(" В вашем распоряжении имеется %d процессов и %d ресурса.\n", NUM_PROC, NUM_RES);

printf(" Чтобы выйти, в любой момент введите 0.\n");

while (true)

{//3

printf(" \n");

int proc, res;

do

{//4

printf(" Введите номер процесса (от 1 до %d): ", NUM_PROC);

scanf(" %d", & proc);

}//4

while (proc < 0 || proc > NUM_PROC);

if (proc == 0)

{//5

printf(" Программа динамического моделирования завершила работу.");

getch();

return 0;

}//5

else

{

proc -= 1; // делаем номер процесса индексом массива

}

if (blocked[proc]! = -1)

{//6

printf(" Процесс заблокирован в ожидании ресурса %d.\n", blocked[proc]+1);

continue;

}//6

do

{//7

printf(" Введите номер ресурса (от 1 до %d): ", NUM_RES);

scanf(" %d", & res);

}//7

while (res < 0 || res > NUM_RES);

if (res == 0)

{//8

printf(" Программа динамического моделирования завершила работу.");

getch();

return 0;

}//8

else

{

res -= 1; // делаем номер ресурса индексом массива

}

if (resource[res].owner! = proc)

{//9

if (seize(resource[res], proc))

{

printf(" Ресурс #%d успешно занят процессом #%d.\n", res+1, proc+1);

}

else

{//10

blocked[proc] = res;

printf(" Процесс #%d заблокирован в ожидании ресурса #%d.\n", proc+1, res+1);

}//10

}//9

else

{//11

release(resource[res]);

printf(" Процесс #%d освободил ресурс #%d.\n", proc+1, res+1);

if (resource[res].owner! = -1)

{//12

blocked[resource[res].owner] = -1;

printf(" Процесс #%d разблокирован и теперь занимает ресурс #%d.\n", resource[res].owner+1, res+1);

}//12

}//11

}//3

}//1