Rtos_api.h

/* rtos_api.h */

/****************************************/

#include <Windows.h>

#include <conio.h>

#include <stdio.h>

#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<MAX_TASK - 1; 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<MAX_TASK; i++)

{if(Task[i].priority<RunningTask.priority)

{if(Task[i].priority!=-1)

{j=i+1;

Bufo = Task[i];

while((Task[j].priority!=-1) & (j<MAX_TASK))

{Bufn = Task[j];

Task[j] = Bufo;

Bufo = Bufn;

}Task[j] = Bufo;

break;

}else break;}}

Task[i] = RunningTask;}

Event.cpp

/* Управление событиями - события принадлежат задаче */

/*******************************************************/

#include <stdlib.h>

#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<MAX_EVENT; 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("\n");

if(flag)

{int TaskNumber = atoi(&(*Task).name[4]) - 1;

Schedule((*Task).priority, TaskNumber);}

printf("Setting events for %s completed\n", (*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<MAX_EVENT; 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("\n"); comma = true;

/* Проверка установленной маски */

for(i=0; i<MAX_EVENT; 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("\n");

/* Если все события произошли, то ничего не делаем, в противном случае задача переходит в состояние 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\n", sz);}

else{printf("Error: ReadProcessMemory %i\n", GetLastError());}

if(FreeTask[0].priority!=-1)

{Dispatch(FreeTask[0].priority, FreeTask[0].task);}

else

{printf("Error: Deadlock in WaitEvent routine!\n");

_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\n", sz);}

Else

{printf("Error: WriteProcessMemory %i\n", GetLastError());}}}

else

{printf("All events have already happened!\n");}

if(RunningTask.task!=-1) printf("Waiting events (Task%i) completed\n", RunningTask.task + 1);}

void ClearEvent(TEventMask Mask)

{TaskQueue[RunningTask.priority][RunningTask.task].mask_h = Mask;}

void ClearMask(TTask *Task)

{for(int i=0; i<MAX_EVENT; i++)

{(*Task).mask_w.mask[i] = false;

(*Task).mask_h.mask[i] = false;}}

void ClearMask(TEventMask *Mask)

{for(int i=0; i<MAX_EVENT; 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<MAX_PRIOR; i++)

{for(int j=0; j<MAX_TASK; 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<MAX_TASK; 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...\n");

InitPVS(Sem);

InitializeTaskQueue(); // Инициализируем очереди ресурсов и задач

ActivateTask(Task); // запускаем задачу

return 0;}

/* Завершение работы ОС */

void ShutdownOS()

{printf("Shutdown OS...\n");}

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\n");

/* Сохоаняем контекст задачи и запускаем другую задачу */

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\n", sz);}

else

{printf("Error: ReadProcessMemory %i\n", GetLastError());}

if(FreeTask[0].priority!=-1)

{Dispatch(FreeTask[0].priority, FreeTask[0].task);}

else

{printf("Error: Deadlock in primitive P!\n");

_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\n", sz);}

else

{printf("Error: WriteProcessMemory %i\n", GetLastError());}}}

printf("Semaphore is obtained (Task%i)\n", 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)...\n", 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 <stdlib.h>

#include "rtos_api.h"

/* Проверка наличия задачи в очереди и её состояния.

Завершение программы произойдет в следующих случаях: данная задача уже запущена, неправильный приоритет или номер задачи */

void CheckTask(int prt, int tasknumber)

{if(prt<MAX_PRIOR)

{if(tasknumber<MAX_TASK)

{if(TaskQueue[prt][tasknumber].state==1)

{printf("Checking... Error: Task%i is running\n", tasknumber);

_getch(); exit(1);}}

else

{printf("Checking... Error: Trying to activate wrong task - Task%i\n", tasknumber);

_getch(); exit(1);}

printf("Checking... Ok\n",tasknumber);}

else

{printf("Checking... Error: Trying to activate task with wrong priority %i\n", prt);

_getch(); exit(1);}}

/* Активизация задачи */

void ActivateTask(TTask tsk)

{printf("Activating %s\n", 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\n",tsk.name);

if(RunningTask.priority==-1) Dispatch(tsk.priority,TaskNumber); // запускаем диспетчер}

/* Завершение задачи */

void TerminateTask(void)

{if(RunningTask.task!=-1)

{printf("Terminating %s\n",TaskQueue[RunningTask.priority][RunningTask.task].name);

printf("Termination of %s completed\n", 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\n",TaskQueue[prt][task].name, TaskQueue[prt][task].priority);

// Меняем состояние задачи

TaskQueue[prt][task].state = 0;

/* Подготавливаем место в очереди готовых задач

Очередь отсортирована по убыванию приоритета, и содержит только указатели на задачи в очереди TaskQueue */

for(i=0; i<MAX_TASK; i++)

{if(FreeTask[i].priority<prt)

{if(FreeTask[i].priority!=-1)

{j=i+1;

Bufo = FreeTask[i];

while((FreeTask[j].priority!=-1) & (j<MAX_TASK))

{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\n",TaskQueue[prt][task].name);}

/* Диспетчер */

void Dispatch(int prt, int task)

{printf("Dispatching...\n");

// Выбираем первую задачу в очереди готовых задач на исполнение

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\n",task+1);}

Test.cpp

/* test.cpp */

/*********************************/

#include <stdlib.h>

#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...\n");

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...\n");

TerminateTask();}

TASK(Task2)

{printf("Starting Task2...\n");

TEventMask msk;

ClearMask(&msk);

msk.mask[0] = true; msk.mask[1] = true;

SetEvent(&(TaskQueue[0][0]), msk);

printf("Executing Task2...\n");

TerminateTask();}

TASK(Task3)

{printf("Starting Task3...\n");

TEventMask msk;

ClearMask(&msk);

msk.mask[0] = true; msk.mask[1] = true;

P(Semaphore);

printf("Executing Task3...\n");

V(Semaphore);

TerminateTask();}

TASK(Task4)

{printf("Starting Task4...\n");

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...\n");

TerminateTask();}

TASK(Task5)

{printf("Starting Task5...\n");

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...\n");

TerminateTask();}

TASK(Task6)

{printf("Starting Task6...\n");

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...\n");

TerminateTask();}

TASK(Task7)

{printf("Starting Task7...\n");

TEventMask msk;

ClearMask(&msk);

msk.mask[Event10] = true;

WaitEvent(msk);

printf("Executing Task7...\n");

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\n");}

printf("******************************************\n");

Test(0);

_getch();

return 0;}

5. Результаты работы