Pragmatismul unei metode moderne de dezvoltare se manifestă prin acordarea unui rol primar concurenței (specificației acesteia) în ghidarea arhitecturării unui sistem software, dar și prin verificarea și „animarea” cât mai timpurie a cerințelor întru determinarea fezabilității arhitecturii specificate. Cele menționate induc o dezvoltare bazată pe prototip, a cărei avantaje sunt recunoscute atât de industrie, cât și de mediul academic [1,2,3].

Dezvoltarea prototipului concurent este determinată de platforma concurentă țintă – software-ul care permite coordonarea, planificarea și gestiunea resurselor multiprocesor/multicore [4]. Platforma stabilind relația directă dintre potențialul hardware și performanța aplicațiilor, definește unitățile de procesare – firele de execuție.

Substratul pentru multithreading

Implementarea firelor de execuție diferă de la un sistem de operare la altul, dar în majoritatea cazurilor firul este inclus în proces. În sistemele cu un singur procesor multithreading-ul este atins prin tehnici de multiplexare în timp a procesorului, time-slicing-ul în acest caz efectuându-se suficient de rapid pentru a crea impresia execuției simultane. Un alt caz se prezintă în sistemele multiprocesor, în care execuția simultană are loc efectiv. Majoritatea sistemelor de operare moderne suportă ambele posibilități, dar la care se poate adăuga și tehnicile bazate pe operații asincrone de intrare/ieșire.

Planificarea (schedule – eng.) firelor de execuție în sistemele de operare poate avea loc în special în două modalități: cooperativ și preemtiv. Planificarea cooperativă presupune că firele de execuție să renunțe la control odată ce acestea sunt la un anumit punct de oprire. Planificarea preemtivă este definită de o altă strategie, în care sistemul de operare utilizează anumite criterii pentru a decide cum să aloce timpul sarcinilor. Un criteriu comun pentru schimbarea contextului (deci a taskului de executat) este, pur şi simplu, expirarea timpul alocat (de exemplu, sisteme cu time-sharing sau time-sclicing), dar există sisteme de operare, în care unor fire se poate acorda o prioritate mai mare (priority-based – eng.), prin alocarea acestora unor cuante de timp mai mari.

Modele pentru multithreading

Unitatea „grea” de planificare la nivelul nucleului (kernel – eng.) sistemului de operare este procesul, căruia se alocă resursele. Anume în cadrul proceselor se manifestă firele de execuție, care își partajează resursele disponibile. În cazul când firele de execuție sunt gestionate de sistemul de operare, acestea sunt considerate ca fire de execuție ale nivelului nucleu (kernel-level – eng.). Prioritățile acestor fire de execuție se transpun de la prioritățile proceselor din cadrul sistemului. Deși considerate unități „ușoare” de planificare aceste fire implică o procedură de trecere de la un fir la altul mai lentă decât în cazul firelor de execuție de nivelul spațiului utilizatorului (user-level – eng.). Cele menționate se datorează faptului că aceste fire de execuție sunt create și planificate fără implicarea nucleului de sistem. Cu toate acestea relația dintre firele de nivelul nucleului și spațiului utilizatorului este determinată de următoarele modele (figura 1):

• 1:1 (kernel-level threading – eng.), în care firele create de utilizator corespund firelor planificate de nucleu (implementat în Windows API, Native POSIX Thread Library, etc.);
• N:1 (user-level threading – eng.), în care firele create de aplicații se „execută” planificat în spațiul utilizatorului pe un singur fir de nivelul nucleului (implementat în GNU Portable Threads);
• N:M (hybrid threading – eng.), un compromis dintre precedentele două modele (întru valorificarea multiprocesării) în care librăriile sunt responsabile pentru planificarea „execuției” multiplelor fire de nivel utilizator pe firele disponibile de nivel nucleu (implementat în Windows 7, Tera/Cray MTA, etc.);

Platforme concurente

Astfel platforma de dezvoltare, până la urmă, și de execuție trebuie să ofere posibilitatea de exploatare a beneficiilor oferite de concurență (ca formă abstractă a paralelismului și distribuirii) ce poate fi reprezentată în codul sursă în mod explicit sau implicit prin diversele instrumente:

• Limbaje cu multithreading-ul inclus: C#, Java, C++0x, etc.;
• Extensii ale limbajelor și platformelor existente: Scala (bazat Java) [5], Cilk plus (bazat C++) [6];
• Librării ce facilitează programarea paralelă de nivel înalt: Intel Threading Building Blocks (TBB) [7], Microsoft Task Parallel Library (TPL) [8];
• Limbaje/platforme specifice ce implementează diverse modele de programare paralelă:
  1. Mesagerie (message-passing – eng.), model implementat cu ajutorul librăriilor MPI (de exemplu MPI.NET [9]);
  2. Data-paralelism, model implementat în limbajul NESL [10];
  3. Memorie partajată distribuită, model implementat în OpenMP [11];
  4. Modelul Actor, implementat în Erlang [12], Scala [5];
• Limbaje și platforme de exploatare a unităților grafice de procesare (GPU, Graphics Processing Unit – eng.):
  1. CUDA (Compute Unified Device Architecture), platformă de calcul paralel inventată de Nvidia întru mărirea performanțelor de calcul prin utilizarea procesoarelor grafice [13];
  2. DirectCompute, o interfață program de aplicații implementat de Microsoft în DirectX 11 pentru procesare grafică,  inclusiv utilizând platforma CUDA [14];
  3. OpenCL (Open Computing Language), cadrul preluat de consorțiul Khronos Group (inițial propus de Apple Inc.) oferă o modalitate de calcul paralel (pe taskuri și pe date) independent de platformă (CPU/GPU); ultimele modificării fiind anunțate în noiembrie 2011 măresc esențial performanța de calcul [15].

Platforma concurentă este esențială în procesul de dezvoltare a prototipurilor pentru care există două strategii distincte: a) fie se animă structurile de limbaj obținute în urma unei analize obiect-orientate tradiționale; b) fie se optează pentru abordarea orientată pe proces, în care unitățile de limbaj reprezintă deja unități active de execuție – procese.

Figura 1 - Platforme pentru concurență

Referințe