diff --git a/NHF/include/heap.h b/NHF/include/heap.h index c32f238c60b00964e7a1a347b82c85756bef4409..0e2f87ea723d1c1a26f162ca2ce84d6962797afd 100644 --- a/NHF/include/heap.h +++ b/NHF/include/heap.h @@ -11,7 +11,7 @@ class heap { public: - /** \brief Létrehozza a memóriaegységet + /** \brief Létrehozza a kért méretű memóriaegységet. * * \param size const memnum A létrehozandó memóriaegység mérete * @@ -19,14 +19,18 @@ class heap heap(const memnum size); ~heap(){delete [] blocks;} - /** \brief Visszaadja a memória méretét + /** \brief Visszaadja a memória méretét. * - * \return const memnum A méret + * \return const memnum A memória mérete * */ const memnum get_size() const { return size; } - /** \brief Ha lehetséges, lefoglal egy megadott méretű memóriaterületet + //A hibakezelésre fonatkozó leírást ki kell egészíteni, ha elkészül a hibakezelés + /** \brief Ha lehetséges, lefoglal egy megadott méretű memóriaterületet. + * Alulhivatkozás, vagy túl nagy igényelt blokkméret esetén hibát dob. + * Túl nagy igényelt blokkméretnek számít, ha a megadott érték nagyobb, + * mint az egész memória, vagy csak a jelenlegi állapot alapján nem fér bele. * * \param block_size memnum A kívánt méret * \return memnum A pid, amivel később a process azonosítani tudja magát @@ -34,21 +38,51 @@ class heap */ memnum allocate(const memnum block_size); - /** \brief Megszűnteti a kapott pid-val kezdődő memóriafoglalást + //A hibakezelésre fonatkozó leírást ki kell egészíteni, ha elkészül a hibakezelés + /** \brief Megszűnteti a kapott pid-val kezdődő memóriafoglalást. + * Ha a pid nincs a memóriában, vagy érvénytelen (nem üres területre, + * vagy nem egy memória blokk elejére mutat), hibát dob. * * \param pid memnum A foglalt memória kezdőcíme * \return void * */ void free(const memnum pid); - friend std::ostream& operator<<(std::ostream& os,heap& mem); + + /** \brief 10%-onként átlagolja a memória telítettségét, + * és kirajzolja egy diagrammon. Ha az adott 10% több mint fele + * telített, akkor az a 10% telítettnek tekinthető. + * Formátum: + #------# + |......|//telítetlen + |......| + |......| + |======|//telített + |======| + |======| + |......| + |......| + |......| + |======| + #------# + + * \param os std::ostream& + * \param mem const heap& A kiírandó memória referenciája + * \return friend std::ostream& A sorbafűzhetőség miatt + * + */ + friend std::ostream& operator<<(std::ostream& os,const heap& mem); protected: private: const memnum size;/**< A memóriamodul mérete */ mem_block* blocks;/**< Pointer a foglalt tömbre */ + //A hibakezelésre fonatkozó leírást ki kell egészíteni, ha elkészül a hibakezelés /** \brief A worst fit stratégiának megfelelően megkeresi a választott blokk kezdetét. * A stratégia szerint a legnagyobb egybefüggő memóriaterületet választja ki. + * Ha a meagadott méret nem fér a memóriába, akkor hibát dob vissza. + * Ezt a függvényt csak az allocate() hívja, így a hívó fél számára úgy tűnik, + * mintha a hibát az dobta volna. * * \param block_size memnum Az igényelt blokkméret * \return memnum A process leendő pid-ja diff --git a/NHF/include/mem_block.h b/NHF/include/mem_block.h index c09287dfcfb1095d00bbdc0b1b4ff4d4c76d71d7..6c5f384c06b798cd1cbcdeb93dfacabf89451405 100644 --- a/NHF/include/mem_block.h +++ b/NHF/include/mem_block.h @@ -36,7 +36,7 @@ struct mem_block /** \brief Meghívja set() függvényt paraméterek nélkül. * Más szóval alapértelmezett értékre állítja egy memóriablokk tagjait. - * + * Csak kényelmi funkciója van. * \return void * */ diff --git a/NHF/include/process.h b/NHF/include/process.h index 4b855f0264321ef55cf0801f09251b59be3c9930..583de88dad0cd832b97ebb70cb10ad6afb752c85 100644 --- a/NHF/include/process.h +++ b/NHF/include/process.h @@ -8,7 +8,22 @@ class process { public: + /** \brief A paraméterként kapott méretű blokkot kérvényez a memórától + * a heap::allocate() függvényen keresztül. + * + * \param block_size A processznek szükséges memória. + * \param mem heap& A paraméterként kapott memória referenciája. + * Erre szükség van, különben a processz a későbbiekben nem fogja tuni, hogy + * melyik memóriában van, így nem tudja felszabadítási kérvényét jelezni. + * + */ process(memnum block_size, heap& mem):mem(mem){pid=mem.allocate(block_size);} + + /** \brief Jelzi a memória felé, hogy nincs már szüksége a foglalt blokkra. + * + * \param false + * + */ ~process(){mem.free(pid);} protected: memnum pid;/**< A process pid-ja */ diff --git a/NHF/main.cpp b/NHF/main.cpp index efa44ac7cbb760c7e49a32c7af51b872d6d32d9e..3b542204aed871fee538d19c141c1ca324050d5a 100644 --- a/NHF/main.cpp +++ b/NHF/main.cpp @@ -7,7 +7,7 @@ using namespace std; int main() { - heap mem(20); + heap mem(23); cout<<mem; cout<<mem.allocate(5)<<endl;///0 cout<<mem.allocate(2)<<endl;///5 @@ -17,6 +17,7 @@ int main() mem.free(5); mem.free(10); cout<<mem; + cout<<mem.allocate(1)<<endl; mem.free(7); cout<<mem; return 0; diff --git a/NHF/src/heap.cpp b/NHF/src/heap.cpp index 283dfacd36527fc644d8cf9fcdd831953c0f2265..b5eabbfc17a4e60598371cc87be991b5209fdbba 100644 --- a/NHF/src/heap.cpp +++ b/NHF/src/heap.cpp @@ -2,7 +2,7 @@ heap::heap(const memnum size):size(size) { - blocks=new mem_block[size]; + blocks=new mem_block[size];//bad_alloc hibát adott esetben illik elkapni blocks[0].block_size=size;//az egész memória egy nagy töltetlen blokk } @@ -25,18 +25,10 @@ memnum heap::allocate(const memnum block_size) { if(block_size<0) throw "Kivétel";//hibakezelés jobban - memnum start; - try - { - start=findfit(block_size); - } - catch(const char*) - { - - } + memnum start=findfit(block_size);//A kivételt majd lekezeljük kint. memnum original_block_size=blocks[start].block_size; blocks[start].set(true,block_size); - for(memnum i=start+1; i<start+block_size; i++) + for(memnum i=start+1; i<start+block_size; i++)//warning: ‘start’ may be used uninitialized in this function [-Wmaybe-uninitialized]| blocks[i].set(true); //Az eredeti blokk maradék részének felparaméterezése memnum new_start=start+block_size; @@ -51,11 +43,13 @@ void heap::free(const memnum pid) throw "Kivétel";//hibakezelés jobban if(!blocks[pid].filled) throw "Érvénytelen pid.";//hibakezelés jobban + else if(blocks[pid].filled && blocks[pid].block_size==0) + throw "Érvénytelen pid.";//Az előzőtől különböző üzenetet lehet érdemes visszaadni. memnum next_block_idx=pid+blocks[pid].block_size; for(memnum i=pid+1; i<next_block_idx; i++) blocks[i].reset(); /* - * Az új üres blokk méreténél figyelembe kell venni, + * Az új üres blokk létrehozásánál figyelembe kell venni, * hogy az utána következő blokk telített, illetve, * hogy az előtte lévő blokk telített-e. * Ezeket adott esetben össze kell vonni. @@ -99,9 +93,8 @@ void heap::free(const memnum pid) blocks[pid].set(false,new_empty_block_size); } } - -std::ostream& operator<<(std::ostream& os,heap& mem) -//Még csak teszt jelleggel, a későbbiekben ez a függvény teljesen más funkcíiót fog ellátni. +#ifdef DEBUG +std::ostream& operator<<(std::ostream& os,const heap& mem) { for(memnum i=0; i<mem.size;i++) { @@ -110,3 +103,34 @@ std::ostream& operator<<(std::ostream& os,heap& mem) os<<"-------------------------------------------\n"; return os; } +#else +std::ostream& operator<<(std::ostream& os,const heap& mem)//nem biztos, hogy jó ötlet az, ha kaszkádosítható +{ + if(mem.size<10) + throw "A memória túl kicsit, nem kiírható."; + const char mem_end[]="#------#", + filled_unit[]="======", + empty_unit[]="......", + border='|'; + os<<mem_end<<std::endl; + memnum unit_size=mem.size/10; + //A févég fennmaradó rész mindig legfeljebb 10 byte, így elhanyagolható. + //A ciklus második kilépési feltétele felelős az elhanyagolásért. + for(memnum i=0; i<mem.size && i+unit_size<=mem.size; i+=unit_size)//itt még van egy kis hiba!? + { + const char *content=NULL; + memnum filled=0; + for(memnum j=i; j<i+unit_size; j++) + { + filled+=mem.blocks[j].filled; + } + if(filled>unit_size/2) + content=filled_unit; + else + content=empty_unit; + os<<border<<content<<border<<std::endl; + } + os<<mem_end<<"\n---------------------------------------"<<std::endl; + return os; +} +#endif