Nucleul Tempo - Kernel

Structura proceselor pe care le prelucrează Nucleul Tempo

Nucleul multitasking Tempo fundamentează principiile ce stau la baza unui sistem de operare şi reprezintă un punct de plecare pentru dezvoltarea de aplicaţii multitasking şi în timp real pentru conducerea proceselor industriale.

Un prim exemplu conţine un singur proces care afişează pe ecran un text simplu: “Hello, world!”.

La pornire, Tempo creează un singur proces (task) prin funcţia Main() şi transferă controlul procesului. Procesul începe execuţia la prima declaraţie, instrucţiune din funcţia Main(). După ce se tipăreşte mesajul, Main() se termină şi se returnează controlul către Nucleul Tempo. Tempo atunci va distruge procesul şi se termină rularea.

//ch2ex1.cpp – modul sursă

#include<iostream.h>

#include “tempo.h”

//funcţia rădăcină pentru procesul main

void Main()

{

CS(cout<<”Hello, world!”<<endl);

}

Declaraţia #include se referă la 2 fişiere header iostream.h şi tempo.h care conţin declaraţiile pentru sistemul de I/O şi respectiv interfaţa cu nucleul Tempo.

Următoarea instrucţiune a codului este apelul funcţiei Main() care defineşte procesul (task-ul) Main. Fiecare program Tempo trebuie să aibă o funcţie Main() la fel ca şi un (cu M mare) program secvenţial C++ ce are funcţia principală main(). Practic funcţia Main() va fi referită ca “funcţie rădăcină” (root funtion) pentru procesul Main. În acest caz Main() conţine o singură instrucţiune:

CS(cout<<”Hello, world”<<endl);

Declaraţia din interiorul parametrilor este o declaraţie normala de stream de ieşire C++. ”CS” este o macroinstrucţiune specifică nucleului Tempo şi este definită în temp.h. Orice declaraţie de program încapsulată între parametrii acestui program este executat într-o secţiune critică specifică proceselor concurente. Trebuie reţinut că fiecare declaraţie (instrucţiune) de program care realizează operaţii de I/O, sau apelul unor funcţii din biblioteca C++ trebuie să fie într-o secţiune critică. În acest fel, nucleul Tempo reprezintă de fapt un strat (layer) între aplicaţia realizată şi hardware + alte sisteme de operare şi limbaje de programare.

Un program convenţional C++ începe execuţia într-o funcţie principală main() şi deci această funcţie este o parte principală a nucleului Tempo şi ea este aceeaşi pentru toate programele Tempo. Această funcţie, care este prezentată mai jos, creează primul proces (task) numit Main şi pregăteşte procesul pentru a porni execuţia.

void main()

{

//Iniţializează structura de date a nucleului

initialize_Tempo();

//Creează primul proces pentru utilizator Main

Main_process = create_process(Main, 0);

//porneşte procesul Main pentru a fi executat

become_idle();

}

Funcţia initialize_Tempo(), prin apelare din main(), iniţializează structura de date din interiorul Nucleului Tempo. Funcţia create_process() este una din funcţiile Tempo pentru gestionarea şi coordonarea proceselor.

Valoarea returnată de funcţia create_proces() este un identificator de proces care identifică instanţa procesului respectiv. Funcţia main() apelează apoi funcţia become_idle() pentru a se întoarce înapoi într-un Tempo process idle.

Crearea unor procese adiţionale

Fiecare program Tempo are obligatoriu un singur proces creat de către Kernel la pornire cu funcţia rădăcină Main(), dar orice Tempo proces poate crea alte procese independente.

Crearea unui proces independent este prezentat în codul de mai jos:

//ch2ex2.cpp

#include<iostream.h>

#include<tempo.h>

void hello();

void Main();

{

Process process1;

Process1 = create_process(hello);

}

//Funcţia rădăcină pentru process1

void hello()

{

CS(cout<<”Hello, world, from process1”<<endl);

}

Programul prezentat reia primul exemplu pentru a arăta cum se poate crea un proces independent → process1, proces ce este creat de procesul principal al nucleului, procesul Main.

Terminarea procesului

Main() nu apelează hello() sau aşteaptă să se termine. Când funcţia create_process() returnează rezultatul, în acest moment avem 2 procese independente: unul executat de Main() şi altul executat de hello(). După ce se creează noul proces, process1, Main există în Tempo până când procesul hello tipăreşte mesajul şi apoi este distrus. Într-un program convenţional, funcţia hello() (va returna) va reveni în funcţii apelante după terminare, dar hello() în cazul nostru nu este explicit apelată. Explicaţia este că atunci când se termină funcţia rădăcină a procesului, aceasta pasează controlul înapoi în Tempo, care distruge procesul. Un program Tempo se termină când toate procesele au fost distruse. Având 2 procese în acest exemplu, programul nu se termină până când toate procesele nu au fost distruse: Main şi process1 ca terminare a funcţiilor Main() şi hello().