Skripta Dragan Milicev Programiranje u Realnom Vremennu C++ UML

Dragan Milićev

Programiranje u realnom vremenu Skripta

Beograd, 2002.

Programiranje u realnom vremenu

1

Sadržaj Sadržaj

I C++

II

1

OSNOVE OBJEKTNO ORIJENTISANOG PROGRAMIRANJA NA JEZIKU 4 Pregled osnovnih koncepata OOP-a na jeziku C++ Klase Konstruktori i destruktori Nasleđivanje Polimorfizam Vežbe

5 5 6 7 8 9

Elementi jezika C++ koji nisu objektno orijentisani Ugrađeni tipovi i deklaracije Pokazivači Nizovi Izrazi Naredbe Funkcije Struktura programa Oblast važenja imena Životni vek objekata Konverzije tipova Dinamički objekti Funkcije Operatori i izrazi Vežbe

12 12 12 13 14 15 15 16 17 18 20 21 21 24 25

Klase i preklapanje operatora Pojam i deklaracija klase Pokazivač this Zajednički članovi klasa Prijatelji klasa Konstruktori Destruktor Pojam preklapanja operatora Operatori new i delete Primeri struktura pogodnih za RT implementacije

27 27 28 29 30 31 33 33 34 35

Nasleđivanje Izvedene klase Polimorfizam Višestruko nasleđivanje

58 58 61 66

OSNOVE OBJEKTNO ORIJENTISANOG MODELOVANJA NA JEZIKU UML 67 Modelovanje strukture Klasa, atributi i operacije Asocijacija

68 68 68

2

Programiranje u realnom vremenu Zavisnost Generalizacija/Specijalizacija Interfejsi Modelovanje ponašanja Interakcije i dijagrami interakcije Aktivnosti i dijagrami aktivnosti Mašine stanja i dijagrami prelaza stanja

74 74 76 78

Organizacija modela Paketi Dijagrami

85 85 85

III UVOD U SISTEME ZA RAD U REALNOM VREMENU

IV

86

Definicija sistema za rad u realnom vremenu Podela i terminologija RT sistema Primeri RT sistema

87 87 88

Karakteristike RT sistema

89

POUZDANOST I TOLERANCIJA OTKAZA Pouzdanost i tolerancija otkaza Pouzdanost, padovi i otkazi Sprečavanje i tolerancija otkaza N-Version Programiranje Dinamička softverska redundansa Blokovi oporavka Izuzeci i njihova obrada Dinamička redundansa i izuzeci Obrada izuzetaka bez posebne jezičke podrške Izuzeci i njihova reprezentacija Obrada izuzetka Propagacija izuzetka Vežbe

V

71 72 73

OSNOVE KONKURENTNOG PROGRAMIRANJA

90 91 91 92 93 95 98 101 101 101 102 104 106 107

110

Konkurentnost i procesi Konkurentno programiranje Pojam procesa Predstavljanje procesa Interakcija između procesa Implementacija niti Vežbe

111 111 113 114 117 118 136

Sinhronizacija i komunikacija pomoću deljene promenljive Međusobno isključenje i uslovna sinhronizacija Uposleno čekanje Semafori Uslovni kritični regioni Monitori Klasifikacija poziva operacija Implementacija sinhronizacionih primitiva Vežbe

138 138 140 143 148 149 155 155 160

Programiranje u realnom vremenu

VI

3

Sinhronizacija i komunikacija pomoću poruka Sinhronizacija procesa Imenovanje procesa i struktura poruke Randevu u jeziku Ada Komunikacija u metodi ROOM Vežbe

163 163 165 166 169 170

Kontrola resursa Modeli za pristup deljenim resursima Problemi nadmetanja za deljene resurse Vežbe

171 171 173 180

SPECIFIČNOSTI RT PROGRAMIRANJA

182

Realno vreme Časovnik realnog vremena Merenje proteklog vremena Vremenske kontrole Kašnjenje procesa Specifikacija vremenskih zahteva Kontrola zadovoljenja vremenskih zahteva Implementacija u školskom Jezgru Vežbe

183 183 186 187 191 192 196 198 208

Raspoređivanje Osnovne strategije raspoređivanja Testovi rasporedivosti Opštiji model procesa Projektovanje prema vremenskim zahtevima Vežbe

217 217 221 227 234 238

4

Programiranje u realnom vremenu

I

Osnove objektno orijentisanog programiranja na jeziku C++

Programiranje u realnom vremenu

5

Pregled osnovnih koncepata OOP-a na jeziku C++ U ovoj glavi biće dat kratak i sasvim površan pregled osnovnih koncepata OOP koje ∗ podržava C++. Potpunija i preciznija objašnjenja koncepata biće data kasnije, u posebnim glavama. Primeri koji se koriste u ovoj glavi samo su pokazni, nisu pravljeni da budu ∗ upotrebljivi. Iz realizacije primera izbačeno je sve što bi smanjivalo preglednost osnovnih ideja. Zato su primeri često i nekompletni. Čitalac ne treba da se trudi da posle čitanja ove glave zapamti sintaksu rešenja, niti da ∗ otkrije sve pojedinosti pokazanih primera. Cilj je da čitalac samo stekne predstavu o osnovnim idejama OOP-a i jezika C++, da vidi šta je novo i šta se sve može uraditi, kao i da nauči da razmišlja na novi, objektni način.

Klase Klasa (engl. class) je osnovna organizaciona jedinica programa u OOP jezicima, pa i u ∗ jeziku C++. Klasa predstavlja strukturu u koju su grupisani podaci i funkcije: // Deklaracija klase: class Osoba { public: void koSi(); private: char* ime; int god; };

// funkcija: predstavi se! // ... i još nešto // podatak: ime i prezime // podatak: koliko ima godina

// Svaka funkcija se mora i definisati: void Osoba::koSi () { coutnext=e->next; else head=e->next; if (internalIterator && internalIterator->currentItem()==e->cont) internalIterator->next(); delete e; sz--; } void Collection::append (Object* e) { if (head==0) head=tail=new CollectionElement(e); else tail=new CollectionElement(e,tail,0); sz++; } void Collection::insert (Object* e, int at) { if (atsize()) return; if (at==0) { head=new CollectionElement(e,head); if (tail==0) tail=head; sz++; return; } if (at==size()) { append(e); return; } int i=0; for (CollectionElement* cur=head; inext, i++); new CollectionElement(e,cur->prev,cur); sz++; } void Collection::remove (Object* e) { if (tail && tail->cont==e) { remove(tail); return; } for (CollectionElement* cur=head; cur!=0; cur=cur->next) if (cur->cont==e) remove(cur); } Object* Collection::remove (int at) { Object* ret = 0; if (at=size()) return 0; if (at==0) { ret = head->cont; remove(head);

Programiranje u realnom vremenu

}

return ret; } if (at==size()-1) { ret = tail->cont; remove(tail); return ret; } int i=0; for (CollectionElement* cur=head; inext, i++); ret = cur->cont; remove(cur); return ret;

void Collection::clear () { for (CollectionElement* cur=head, *temp=0; cur!=0; cur=temp) { temp=cur->next; delete cur; } head=0; tail=0; sz=0; if (internalIterator) internalIterator->reset(); } Object* Collection::first () { if (head==0) return 0; else return head->cont; } Object* Collection::last () { if (tail==0) return 0; else return tail->cont; } Object* Collection::itemAt (int at) { if (at=size()) return 0; int i=0; for (CollectionElement* cur=head; inext, i++); return cur->cont; } int Collection::location (Object* e) { int i=0; for (CollectionElement* cur=head; cur!=0; cur=cur->next, i++) if (cur->cont==e) return i; return -1; } CollectionIterator* Collection::createIterator () { return new CollectionIterator(this); }

///////////////////////////////////////////////////////////////////// // class CollectionIterator /////////////////////////////////////////////////////////////////////

39

40

Programiranje u realnom vremenu

int CollectionIterator::next () { if (cur!=0) cur=cur->next; return !isDone(); } Object* CollectionIterator::currentItem () { return cur?cur->cont:0; }

Primer upotrebe #include "collection.h" #include class Object { //... }; class X : public Object { public: X(int ii) : i(ii) {} int i; //... }; void main () { X* x1 = new X* x2 = new X* x3 = new X* x4 = new X* x5 = new

X(1); X(2); X(3); X(4); X(5);

Collection* col1 = new Collection; col1->append(x1); col1->append(x2); col1->insert(x3); col1->insert(x4,2); X* x = (X*)col1->removeFirst(); col1->append(x); col1->insert(x5,3); CollectionIterator* it = col1->getIterator(); for (it->reset(); !it->isDone(); it->next()) { X* x = (X*)it->currentItem(); coutappend(x5); it = col2->getIterator(); for (it->reset(); !it->isDone(); it->next()) { X* x = (X*)it->currentItem(); coutcurrentItem(); coutisDone(); it->next()) { X* x = (X*)it->currentItem(); couthead; } { if (cur!=0) cur=cur->next; return !isDone(); }

int

isDone() { return cur==0; }

Object* CollectionElement*

currentItem() { return cur?cur->getHolder():0; } currentElement() { return cur; }

private: Collection* col; CollectionElement* cur; }; #endif // // // // // // // // // //

Project: Real-Time Programming Subject: Data Structures Module: Collection File: collect.cpp Date: October 2002 Author: Dragan Milicev Contents: Class: CollectionElement Collection CollectionIterator

Programiranje u realnom vremenu #include "collect.h" ///////////////////////////////////////////////////////////////////// // class Collection ///////////////////////////////////////////////////////////////////// Collection::Collection () : head(0), tail(0), sz(0), internalIterator(new CollectionIterator(this)) {} Collection::~Collection () { clear(); delete internalIterator; } void Collection::append (CollectionElement* e) { if (e==0 || e->getContainer()!=0) return; if (head==0) { e->set(0,0); head=tail=e; } else { e->set(tail,0); tail=e; } e->setContainer(this); sz++; } void Collection::insert (CollectionElement* e, int at) { if (e==0 || e->getContainer()!=0 || atsize()) return; if (at==0) { e->set(0,head); e->setContainer(this); head=e; if (tail==0) tail=head; sz++; return; } if (at==size()) { append(e); return; } int i=0; for (CollectionElement* cur=head; inext, i++); e->set(cur->prev,cur); e->setContainer(this); sz++; } void Collection::insertBefore (CollectionElement* newElem, CollectionElement* beforeThis) { if (newElem==0 || newElem->getContainer()!=0) return; if (beforeThis==0) { append(newElem); return; } if (beforeThis->prev==0) { insert(newElem); return; } newElem->set(beforeThis->prev,beforeThis); newElem->setContainer(this); sz++;

45

46

Programiranje u realnom vremenu

} void Collection::insertAfter (CollectionElement* newElem, CollectionElement* afterThis) { if (newElem==0 || newElem->getContainer()!=0) return; if (afterThis==0) { insert(newElem); return; } if (afterThis->next==0) { append(newElem); return; } newElem->set(afterThis,afterThis->next); newElem->setContainer(this); sz++; } void Collection::remove (CollectionElement* e) { if (e==0 || e->getContainer()!=this) return; if (e->next!=0) e->next->prev=e->prev; else tail=e->prev; if (e->prev!=0) e->prev->next=e->next; else head=e->next; e->set(0,0); e->setContainer(0); if (internalIterator && internalIterator->currentItem()==e->getHolder()) internalIterator->next(); sz--; } Object* Collection::remove (int at) { CollectionElement* ret = 0; if (at=size()) return 0; if (at==0) { ret = head; remove(head); return ret?ret->getHolder():0; } if (at==size()-1) { ret = tail; remove(tail); return ret?ret->getHolder():0; } int i=0; for (CollectionElement* cur=head; inext, i++); ret = cur; remove(cur); return ret?ret->getHolder():0; } void Collection::clear () { for (CollectionElement* cur=head, *temp=0; cur!=0; cur=temp) { temp=cur->next; cur->set(0,0); cur->setContainer(0); } head=0; tail=0; sz=0; if (internalIterator) internalIterator->reset(); } Object* Collection::itemAt (int at) { if (at=size()) return 0; int i=0;

Programiranje u realnom vremenu

}

for (CollectionElement* cur=head; inext, i++); return cur?cur->getHolder():0;

int Collection::location (CollectionElement* e) { if (e==0 || e->getContainer()!=this) return -1; int i=0; for (CollectionElement* cur=head; cur!=0; cur=cur->next, i++) if (cur==e) return i; return -1; } CollectionIterator* Collection::createIterator () { return new CollectionIterator(this); }

Primer upotrebe #include "collect.h" #include class Object { //... }; class X : public Object { public: X(int ii) : i(ii), ceForC1(this), ceForC2(this) {} int i;

};

CollectionElement ceForC1; CollectionElement ceForC2; //...

void main () { X* x1 = new X* x2 = new X* x3 = new X* x4 = new X* x5 = new

X(1); X(2); X(3); X(4); X(5);

Collection* col1 = new Collection; col1->append(&x1->ceForC1); col1->append(&x2->ceForC1); col1->insert(&x3->ceForC1); col1->insert(&x4->ceForC1,2); X* x = (X*)col1->removeFirst(); col1->append(&x->ceForC1); col1->insert(&x5->ceForC1,3); CollectionIterator* it = col1->getIterator(); for (it->reset(); !it->isDone(); it->next()) { X* x = (X*)it->currentItem(); coutappend(&x3->ceForC2); col2->append(&x4->ceForC2); col2->append(&x5->ceForC2); col2->append(&x3->ceForC1); // Tolerant Error it = col2->getIterator(); for (it->reset(); !it->isDone(); it->next()) { X* x = (X*)it->currentItem(); coutcurrentItem(); coutisDone(); it->next()) { X* x = (X*)it->currentItem(); coutgetContainer()!=this) return; col.remove(e); e->setContainer(0); if (highest!=e) return;

}

Priority maxPri = MinPri; highest = 0; CollectionIterator* it = getIterator(); for (it->reset(); !it->isDone(); it->next()) { PriorityElement* pe = (PriorityElement*)it->currentElement(); if (pe->getPriority()>=maxPri) { maxPri = pe->getPriority(); highest = pe; } }

void PriorityQueue::clear () { CollectionIterator* it = getIterator();

Programiranje u realnom vremenu

}

53

for (it->reset(); !it->isDone(); it->next()) { PriorityElement* pe = (PriorityElement*)it->currentElement(); pe->setContainer(0); } col.clear(); highest = 0;

void PriorityQueue::notifyPriorityChange (PriorityElement* e) { if (e==0 || e->getContainer()!=this) return; if (highest==0 || highest->getPriority()getPriority()) { highest = e; return; } if (highest==e) { Priority maxPri = e->getPriority(); CollectionIterator* it = getIterator(); for (it->reset(); !it->isDone(); it->next()) { PriorityElement* pe = (PriorityElement*)it>currentElement(); if (pe->getPriority()>maxPri) { maxPri = pe->getPriority(); highest = pe; } } return; } }

Primer upotrebe #include "pqueue.h" #include class Object { //... }; class X : public Object { public: X(int ID, Priority pri) : id(ID), peForPQ(this) { peForPQ.setPriority(pri); } int id; PriorityElement* getPriorityElement () { return &peForPQ; } }

Priority

getPriority ()

void

setPriority (Priority pri) { peForPQ.setPriority(pri); }

private: PriorityElement peForPQ; };

//...

void main () { X* x1 = new X(1,1); X* x2 = new X(2,2); X* x3 = new X(3,3);

{ return peForPQ.getPriority();

54

Programiranje u realnom vremenu X* x4 = new X(4,4); X* x5 = new X(5,5); PriorityQueue* pq = new PriorityQueue; pq->add(x1->getPriorityElement()); pq->add(x3->getPriorityElement()); pq->add(x4->getPriorityElement()); pq->add(x2->getPriorityElement()); pq->add(x5->getPriorityElement()); X* top = 0; top = (X*)pq->first(); cout