Код программы.
Разработка операционных систем
Подготавливаем место в очереди готовых задач Очередь отсортирована по убыванию приоритета, и содержит только указатели на задачи в очереди TaskQueue */. Содержатся все макросы, описания типов, декларации функций и другие объекты, которые необходимо включать в пользовательское приложение,. Если все события произошли, то ничего не делаем, в противном случае задача переходит в состояние waiting… Читать ещё >
Код программы. Разработка операционных систем (реферат, курсовая, диплом, контрольная)
Структура.
Файл. | |
additional.cpp | Описание дополнительных процедур и функций, необходимых для работы. |
event.cpp | Управление событиями. |
global.cpp | Описание всех глобальных переменных. |
os.cpp | Управление операционной системой. |
resource.cpp | Управление ресурсами (реализация функционала простых семафоров). |
task.cpp | Управление задачами (планировщик, диспетчер и т. д.). |
test.cpp | Тесты для проверки правильности работы. |
rtos_api.h | Содержатся все макросы, описания типов, декларации функций и другие объекты, которые необходимо включать в пользовательское приложение,. |
Rtos_api.h.
/****************************************/.
/* rtos_api.h */.
/****************************************/.
#include.
#include.
#include.
#define MAX_TASK 32.
#define MAX_RES 16.
#define MAX_PRIOR 16.
#define MAX_EVENT 16.
typedef struct Type_Mask.
{bool mask[MAX_EVENT]; // маска событий.
} TEventMask;
typedef struct Type_stack.
{void *stack; // стек.
int size; // рамер стека.
} _stack;
typedef struct Type_Task.
{int priority; // приоритет.
int state; // состояние задачи.
void (*entry)(void); // точка входа.
char* name; // имя задачи.
TEventMask mask_w; // маска ожидаемых событий.
TEventMask mask_h; // маска произошедших событий.
bool eventwaiting; // флаг ожидания события.
bool semaphorewaiting; // флаг ожидагия семафора.
CONTEXT context; // контекст задачи.
_stack Rsp; // стек вызовов.
} TTask;
typedef struct Type_runningtask.
{int priority; // приоритет.
int task; // номер задачи в очереди.
} TRunningTask;
typedef struct Type_semaphore.
{int sem_id; // идентификатор
int task_id; // идентификатор задачи.
bool isfree; // состояние.
} TSemaphore;
#define DeclareTask (TaskID, priority).
TASK (TaskID);
enum {TaskID##prior=priority}.
#define DeclareResource (ResID, priority).
enum {ResID=priority}.
#define DeclareEvent (Event_ID, EventID).
enum {Event_ID=EventID}.
#define TASK (TaskID) void TaskID (void).
typedef void TTaskCall (void);
extern TTask TaskQueue[MAX_PRIOR][MAX_TASK]; // Очередь задач для POSIX планировщика, отдельная очередь на каждый приоритет.
extern TRunningTask RunningTask; // Запущенная задача.
extern TRunningTask FreeTask[MAX_TASK]; // Очередь свободных задач отсортированных по убыванию приоритетов.
extern TRunningTask SemaphoreWaitingTask[MAX_TASK]; // Очередь задач, ожидающих освобождение семафора.
extern TSemaphore Semaphore; // Семафор
extern void *SP; // Начало стека.
extern bool RestoreStack; // Флаг, характеризующий необходимость восстанавления стека.
extern HANDLE MainProcess; // Дескриптор процесса.
void CheckTask (int prt, int tasknumber);
void ActivateTask (TTask tsk);
void TerminateTask (void);
void Schedule (int prt, int task);
void Dispatch (int prt, int task);
void InitializeTaskQueue ();
int StartOS (TTask Task);
void ShutdownOS ();
void InitPVS (TSemaphore semaphore);
void P (TSemaphore semaphore);
void V (TSemaphore semaphore);
void SetEvent (TTask *Task, TEventMask Mask);
void GetEvent (TTask Task, TEventMask *Mask);
void WaitEvent (TEventMask Mask);
void ClearEvent (TEventMask Mask);
void ClearMask (TTask *Task);
void ClearMask (TEventMask *Mask);
void Sort (TRunningTask *Task);
void InsertIntoQueue (TRunningTask *Task);
Additional.cpp.
/*********************************/.
/* additional. cpp */.
/*********************************/.
#include «rtos_api.h» .
void Sort (TRunningTask *Task).
{TRunningTask Buf;
for (int i=0; i.
{if (Task[i+1]. priority == -1) break;
Buf = Task[i];
Task[i] = Task[i + 1];
Task[i + 1] = Buf;}}.
void InsertIntoQueue (TRunningTask *Task).
{int i = 0, j;
TRunningTask Bufo, Bufn;
for (i=0; i.
{if (Task[i]. priority.
{if (Task[i]. priority≠-1).
{j=i+1;
Bufo = Task[i];
while ((Task[j]. priority≠-1) & (j.
{Bufn = Task[j];
Task[j] = Bufo;
Bufo = Bufn;
}Task[j] = Bufo;
break;
}else break;}}.
Task[i] = RunningTask;}.
Event.cpp.
/*******************************************************/.
/* Управление событиями — события принадлежат задаче */.
/*******************************************************/.
#include.
#include «rtos_api.h» .
/* Генерация событий для задачи Task */.
void SetEvent (TTask *Task, TEventMask Mask).
{int i = 0;
bool flag = false, comma = true;
printf («Setting for %s «, (*Task).name);
/* Устанавливаем маску произошедших событий */.
for (int i=0; i.
{if (Mask.mask[i]).
{if (comma) { printf («Event_%i», i + 1); comma = false; }.
else printf («, Event_%i», i + 1);
(*Task).mask_h.mask[i] = Mask. mask[i]; }.
if (((*Task).mask_w.mask[i])&((*Task).mask_h.mask[i])).
{flag = true;
- (*Task).mask_h.mask[i] = false;
- (*Task).mask_w.mask[i] = false;}}
printf (««);
if (flag).
{int TaskNumber = atoi (&(*Task).name[4]) — 1;
Schedule ((*Task).priority, TaskNumber);}.
printf («Setting events for %s completed «, (*Task).name);}.
void GetEvent (TTask Task, TEventMask *Mask).
{(*Mask) = Task. mask_h;}.
/* Для вызвавшей задачи устанавливается маска ожидаемых событий, задаваемая Mask */.
void WaitEvent (TEventMask Mask).
{bool flag = false, temp = false, comma = true;
int count = 0, i = 0, addr = 0;
SIZE_T sz;
printf («Waiting (Task%i) «, RunningTask. task + 1);
/* Устанавливаем маску ожидаемых событий */.
for (i=0; i.
{if (Mask.mask[i]).
{if (comma) { printf («Event_%i», i + 1); comma = false; }.
else printf («, Event_%i», i + 1);
count++;
TaskQueue[RunningTask.priority][RunningTask.task]. mask_w.mask[i] = Mask. mask[i]; }}.
printf (««); comma = true;
/* Проверка установленной маски */.
for (i=0; i.
{if ((TaskQueue[RunningTask.priority][RunningTask.task]. mask_w.mask[i]) & (TaskQueue[RunningTask.priority][RunningTask.task]. mask_h.mask[i])).
{/* если ожидаемые события уже произошли сбрасываем маску */.
TaskQueue[RunningTask.priority][RunningTask.task]. mask_w.mask[i] = false;
TaskQueue[RunningTask.priority][RunningTask.task]. mask_h.mask[i] = false;
if (!flag) printf («Events which have already happened: «);
flag = true;
count-; temp = true;
if (comma) { printf («Event_%i», i + 1); comma = false; }.
else printf («, Event_%i», i + 1);}}.
if (temp) printf (««);
/* Если все события произошли, то ничего не делаем, в противном случае задача переходит в состояние waiting и запускаем другую задачу */.
if (count≠0).
{/* Есть события, появление которых нужно ожидать */.
/* Приостанавливаем запущенную задачу и устанавливаем флаг, сигнализирующий о том, что есть события, появления которых.
нужно ожидать */.
TaskQueue[RunningTask.priority][RunningTask.task]. state = -1;
TaskQueue[RunningTask.priority][RunningTask.task]. eventwaiting = true;
/* Сохраняем контекст задачи и запускаем другую задачу */.
TaskQueue[RunningTask.priority][RunningTask.task]. context. ContextFlags = CONTEXT_ALL;
RtlCaptureContext (&(TaskQueue[RunningTask.priority][RunningTask.task]. context));
if (TaskQueue[RunningTask.priority][RunningTask.task]. eventwaiting).
{TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size = (int)SP — (int)&addr;
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack = malloc (TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size);
if (ReadProcessMemory (MainProcess, (LPVOID)(TaskQueue[RunningTask.priority][RunningTask.task]. context. Rsp),.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).
{printf («Reading memory… Ok %i bytes «, sz);}.
else{printf («Error: ReadProcessMemory %i «, GetLastError ());}.
if (FreeTask[0]. priority≠-1).
{Dispatch (FreeTask[0]. priority, FreeTask[0]. task);}.
else.
{printf («Error: Deadlock in WaitEvent routine! «);
_getch ();
exit (1);}}.
if (RestoreStack).
{RestoreStack = false;
CONTEXT Ctx = TaskQueue[RunningTask.priority] [RunningTask.task]. context;
if (WriteProcessMemory (GetCurrentProcess (), (void *)(Ctx.Rsp),.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).
{printf («Writing memory… Ok %i bytes «, sz);}.
Else.
{printf («Error: WriteProcessMemory %i «, GetLastError ());}}}.
else.
{printf («All events have already happened! «);}.
if (RunningTask.task≠-1) printf («Waiting events (Task%i) completed «, RunningTask. task + 1);}.
void ClearEvent (TEventMask Mask).
{TaskQueue[RunningTask.priority][RunningTask.task]. mask_h = Mask;}.
void ClearMask (TTask *Task).
{for (int i=0; i.
{(*Task).mask_w.mask[i] = false;
(*Task).mask_h.mask[i] = false;}}.
void ClearMask (TEventMask *Mask).
{for (int i=0; i.
{(*Mask).mask[i] = false;
(*Mask).mask[i] = false;}}.
Global.cpp.
/****************************************************/.
/* Описание глобальных переменных */.
/****************************************************/.
#include «rtos_api.h» .
TTask TaskQueue[MAX_PRIOR][MAX_TASK];
TRunningTask RunningTask;
TRunningTask FreeTask[MAX_TASK];
TRunningTask SemaphoreWaitingTask[MAX_TASK];
TSemaphore Semaphore;
void *SP;
bool RestoreStack;
HANDLE MainProcess;
Os.cpp.
/*******************************************/.
/* Управление ОС */.
/*******************************************/.
#include «rtos_api.h» .
/* Инициализация очереди задач и очереди указателей на активные задачи */.
void InitializeTaskQueue ().
{for (int i=0; i.
{for (int j=0; j.
{TaskQueue[i][j]. priority=0;
TaskQueue[i][j]. state = -1;
TaskQueue[i][j]. entry=NULL;
TaskQueue[i][j]. name=NULL;
TaskQueue[i][j]. eventwaiting = false;
TaskQueue[i][j]. semaphorewaiting = false;
TaskQueue[i][j]. Rsp. stack = NULL;
TaskQueue[i][j]. Rsp. size = 0;
ClearMask (&TaskQueue[i][j]);}}.
for (int i=0; i.
{FreeTask[i]. priority = -1;
FreeTask[i]. task = -1;
SemaphoreWaitingTask[i]. priority = -1;
SemaphoreWaitingTask[i]. task = -1;}}.
/* Инициализация очереди задач и очереди ресурсов, запуск первой задачи */.
int StartOS (TTask Task).
{int tmp = 0;
SP = &tmp;
RunningTask.priority = -1;
RunningTask.task = -1;
RestoreStack = false;
TSemaphore Sem;
Sem.isfree = true; Sem. sem_id = 1;
printf («Starting OS… «);
InitPVS (Sem);
InitializeTaskQueue (); // Инициализируем очереди ресурсов и задач.
ActivateTask (Task); // запускаем задачу.
return 0;}.
/* Завершение работы ОС */.
void ShutdownOS ().
{printf («Shutdown OS… «);}.
Resource.cpp.
/*********************************************/.
/* Управление ресурсами — простые семафоры */.
/*********************************************/.
#include «rtos_api.h» .
/* Инициалищация семафоров */.
void InitPVS (TSemaphore semaphore).
{Semaphore.isfree = semaphore. isfree;
Semaphore.sem_id = semaphore. sem_id;
Semaphore.task_id = -1;}.
/* Захват семафора */.
void P (TSemaphore semaphore).
{int addr = 0;
SIZE_T sz;
printf («Trying to obtain semaphore (Task%i)…», RunningTask. task + 1);
if (!Semaphore.isfree).
{printf («semaphore is busy «);
/* Сохоаняем контекст задачи и запускаем другую задачу */.
TaskQueue[RunningTask.priority][RunningTask.task]. semaphorewaiting = true;
TaskQueue[RunningTask.priority][RunningTask.task]. state = -1;
/* Ставим задачу в очередб задач ожидающих семафора */.
InsertIntoQueue (SemaphoreWaitingTask);
TaskQueue[RunningTask.priority][RunningTask.task]. context. ContextFlags = CONTEXT_ALL;
RtlCaptureContext (&(TaskQueue[RunningTask.priority][RunningTask.task]. context));
if (TaskQueue[RunningTask.priority][RunningTask.task]. semaphorewaiting).
{TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size = (int)SP — (int)&addr;
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack = malloc (TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size);
if (ReadProcessMemory (GetCurrentProcess (), (LPVOID)(TaskQueue[RunningTask.priority][RunningTask.task]. context. Rsp),.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).
{printf («Reading memory… Ok %i bytes «, sz);}.
else.
{printf («Error: ReadProcessMemory %i «, GetLastError ());}.
if (FreeTask[0]. priority≠-1).
{Dispatch (FreeTask[0]. priority, FreeTask[0]. task);}.
else.
{printf («Error: Deadlock in primitive P! «);
_getch ();
exit (1);}}.
if (RestoreStack).
{RestoreStack = false;
CONTEXT Ctx = TaskQueue[RunningTask.priority][RunningTask.task]. context;
if (WriteProcessMemory (GetCurrentProcess (), (void *)(Ctx.Rsp),.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. stack,.
TaskQueue[RunningTask.priority][RunningTask.task]. Rsp. size, &sz)).
{printf («Writing memory… Ok %i bytes «, sz);}.
else.
{printf («Error: WriteProcessMemory %i «, GetLastError ());}}}.
printf («Semaphore is obtained (Task%i) «, RunningTask. task + 1);
Semaphore.isfree = false;
Semaphore.task_id = RunningTask. task;}.
/* Освобождение семафора */.
void V (TSemaphore semaphore).
{int prt, tsk;
if (RunningTask.task≠-1).
{if (RunningTask.task == Semaphore. task_id).
{printf («Retrieving semaphore (Task%i)… «, RunningTask. task + 1);
prt = SemaphoreWaitingTask[0]. priority;
tsk = SemaphoreWaitingTask[0]. task;
SemaphoreWaitingTask[0]. priority = -1;
SemaphoreWaitingTask[0]. task = -1;
Sort (SemaphoreWaitingTask);
Semaphore.isfree = true;
Semaphore.task_id = -1;
if ((prt≠-1)&(tsk≠-1)) Schedule (prt, tsk);}.
else.
{printf («Error: Can not retrieve semaphore, it belongs to another task!»);
_getch (); exit (1);}}}.
Task.cpp.
/*********************************/.
/* Управление задачами */.
/*********************************/.
#include.
#include «rtos_api.h» .
/* Проверка наличия задачи в очереди и её состояния.
Завершение программы произойдет в следующих случаях: данная задача уже запущена, неправильный приоритет или номер задачи */.
void CheckTask (int prt, int tasknumber).
{if (prt.
{if (tasknumber.
{if (TaskQueue[prt][tasknumber]. state==1).
{printf («Checking… Error: Task%i is running «, tasknumber);
_getch (); exit (1);}}.
else.
{printf («Checking… Error: Trying to activate wrong task — Task%i «, tasknumber);
_getch (); exit (1);}.
printf («Checking… Ok «, tasknumber);}.
else.
{printf («Checking… Error: Trying to activate task with wrong priority %i «, prt);
_getch (); exit (1);}}.
/* Активизация задачи */.
void ActivateTask (TTask tsk).
{printf («Activating %s «, tsk.name);
int TaskNumber = atoi (&tsk.name[4]) — 1;
CheckTask (tsk.priority, TaskNumber);
// Задача вносится в очередь задач.
TaskQueue[tsk.priority][TaskNumber]. priority = tsk. priority;
TaskQueue[tsk.priority][TaskNumber]. name = tsk.name;
TaskQueue[tsk.priority][TaskNumber]. entry = tsk. entry;
TaskQueue[tsk.priority][TaskNumber]. eventwaiting = false;
TaskQueue[tsk.priority][TaskNumber]. semaphorewaiting = false;
Schedule (tsk.priority, TaskNumber); // запускаем планировщик.
printf («Activation of %s completed «, tsk.name);
if (RunningTask.priority==-1) Dispatch (tsk.priority, TaskNumber); // запускаем диспетчер}.
/* Завершение задачи */.
void TerminateTask (void).
{if (RunningTask.task≠-1).
{printf («Terminating %s «, TaskQueue[RunningTask.priority][RunningTask.task]. name);
printf («Termination of %s completed «, TaskQueue[RunningTask.priority] [RunningTask.task]. name);
TaskQueue[RunningTask.priority][RunningTask.task]. state = -1;
RunningTask.priority = -1;
RunningTask.task = -1;}.
// Изменяем состояние задачи.
// Запускаем следующую в очереди задачу.
if (FreeTask[0]. priority≠-1).
{Dispatch (FreeTask[0]. priority, FreeTask[0]. task);}}.
/* Планировщик */.
void Schedule (int prt, int task).
{int i = 0, j;
TRunningTask Bufo, Bufn;
printf («Sheduling %s, priority — %i «, TaskQueue[prt][task]. name, TaskQueue[prt][task]. priority);
// Меняем состояние задачи.
TaskQueue[prt][task]. state = 0;
/* Подготавливаем место в очереди готовых задач Очередь отсортирована по убыванию приоритета, и содержит только указатели на задачи в очереди TaskQueue */.
for (i=0; i.
{if (FreeTask[i]. priority.
{if (FreeTask[i]. priority≠-1).
{j=i+1;
Bufo = FreeTask[i];
while ((FreeTask[j]. priority≠-1) & (j.
{Bufn = FreeTask[j];
FreeTask[j] = Bufo;
Bufo = Bufn;}.
FreeTask[j] = Bufo;
break;}.
else break;}}.
// Вставляем задачу в очередь готовых задач.
FreeTask[i]. priority = prt;
FreeTask[i]. task = task;
printf («Scheduling of %s completed «, TaskQueue[prt][task]. name);}.
/* Диспетчер */.
void Dispatch (int prt, int task).
{printf («Dispatching… «);
// Выбираем первую задачу в очереди готовых задач на исполнение.
RunningTask.priority = FreeTask[0]. priority;
RunningTask.task = FreeTask[0]. task;
// Удаляем выбранную задачу из очереди.
FreeTask[0]. priority = -1;
FreeTask[0]. task = -1;
Sort (FreeTask);
TaskQueue[prt][task]. state = 1;
// Запускаем задачу.
if (TaskQueue[prt][task]. eventwaiting | TaskQueue[prt][task]. semaphorewaiting).
{/* Запускаем приостановленную задачу */.
TaskQueue[RunningTask.priority][RunningTask.task]. context. ContextFlags = CONTEXT_ALL;
TaskQueue[prt][task]. eventwaiting = false;
TaskQueue[prt][task]. semaphorewaiting = false;
RestoreStack = true;
RtlRestoreContext (&(TaskQueue[RunningTask.priority][RunningTask.task]. context), NULL);}.
else.
{TaskQueue[prt][task]. entry ();}.
if (RunningTask.task≠-1) printf («Dispatching of Task%i completed «, task+1);}.
Test.cpp.
/*********************************/.
/* test. cpp */.
/*********************************/.
#include.
#include «rtos_api.h» .
DeclareTask (Task1,0);
DeclareTask (Task2,1);
DeclareTask (Task3,2);
DeclareTask (Task4,3);
DeclareTask (Task5,4);
DeclareTask (Task6,5);
DeclareTask (Task7,6);
DeclareTask (Task8,7);
DeclareTask (Task9,8);
DeclareTask (Task10,9);
DeclareEvent (Event1,0);
DeclareEvent (Event2,1);
DeclareEvent (Event3,2);
DeclareEvent (Event4,3);
DeclareEvent (Event5,4);
DeclareEvent (Event6,5);
DeclareEvent (Event7,6);
DeclareEvent (Event8,7);
DeclareEvent (Event9,8);
DeclareEvent (Event10,9);
TASK (Task1).
{printf («Starting Task1… «);
TTask task2, task3;
TEventMask msk;
task2.priority = Task2prior;
task2.state = -1;
task2.name = «Task2» ;
task2.entry = Task2;
task2.eventwaiting = false;
task2.semaphorewaiting = false;
ClearMask (&task2); ClearMask (&msk);
msk.mask[Event1] = true; msk. mask[Event2] = true;
task3.priority = Task3prior;
task3.state = -1;
task3.name = «Task3» ;
task3.entry = Task3;
task3.eventwaiting = false;
task3.semaphorewaiting = false;
ClearMask (&task3);
ActivateTask (task2);
ActivateTask (task3);
P (Semaphore);
WaitEvent (msk);
V (Semaphore);
if (RunningTask.task≠-1) printf («Executing Task1… «);
TerminateTask ();}.
TASK (Task2).
{printf («Starting Task2… «);
TEventMask msk;
ClearMask (&msk);
msk.mask[0] = true; msk. mask[1] = true;
SetEvent (&(TaskQueue[0][0]), msk);
printf («Executing Task2… «);
TerminateTask ();}.
TASK (Task3).
{printf («Starting Task3… «);
TEventMask msk;
ClearMask (&msk);
msk.mask[0] = true; msk. mask[1] = true;
P (Semaphore);
printf («Executing Task3… «);
V (Semaphore);
TerminateTask ();}.
TASK (Task4).
{printf («Starting Task4… «);
TTask task5, task6;
TEventMask msk;
task5.priority = Task5prior;
task5.state = -1;
task5.name = «Task5» ;
task5.entry = Task5;
task5.eventwaiting = false;
task5.semaphorewaiting = false;
ClearMask (&task5); ClearMask (&msk);
msk.mask[Event3] = true; msk. mask[Event4] = true; msk. mask[Event5] = true;
task6.priority = Task6prior;
task6.state = -1;
task6.name = «Task6» ;
task6.entry = Task6;
task6.eventwaiting = false;
task6.semaphorewaiting = false;
ClearMask (&task6);
ActivateTask (task5);
ActivateTask (task6);
WaitEvent (msk);
if (RunningTask.task≠-1) printf («Executing Task4… «);
TerminateTask ();}.
TASK (Task5).
{printf («Starting Task5… «);
TEventMask msk;
ClearMask (&msk);
msk.mask[Event5] = true;
SetEvent (&(TaskQueue[3][3]), msk); // Task4 3.
ClearMask (&msk);
msk.mask[Event10] = true;
SetEvent (&(TaskQueue[6][6]), msk); // Task7 6.
printf («Executing Task5… «);
TerminateTask ();}.
TASK (Task6).
{printf («Starting Task6… «);
TTask task7;
task7.priority = Task7prior;
task7.state = -1;
task7.name = «Task7» ;
task7.entry = Task7;
task7.eventwaiting = false;
task7.semaphorewaiting = false;
ClearMask (&task7);
P (Semaphore);
ActivateTask (task7);
V (Semaphore);
printf («Executing Task6… «);
TerminateTask ();}.
TASK (Task7).
{printf («Starting Task7… «);
TEventMask msk;
ClearMask (&msk);
msk.mask[Event10] = true;
WaitEvent (msk);
printf («Executing Task7… «);
TerminateTask ();}.
void Test (int testNumber).
{TTask InitialTask;
InitialTask.state = -1;
InitialTask.eventwaiting = false;
InitialTask.semaphorewaiting = false;
ClearMask (&InitialTask);
switch (testNumber).
{case (0):
{InitialTask.priority = Task1prior;
InitialTask.name = «Task1» ;
InitialTask.entry = Task1;
break;}.
case (1):
{InitialTask.priority = Task4prior;
InitialTask.name = «Task4» ;
InitialTask.entry = Task4;
break;}}.
StartOS (InitialTask);
ShutdownOS ();}.
int main (void).
{HANDLE Temporary = GetCurrentProcess ();
if (DuplicateHandle (GetCurrentProcess (), Temporary, GetCurrentProcess (), &MainProcess, 0, FALSE, DUPLICATE_SAME_ACCESS)).
{printf («DupliicateHandle… Ok «);}.
printf («****************************************** «);
Test (0);
_getch ();
return 0;}.