Régió alapú memóriakezelés

A régió alapú memóriakezelés  egy olyan memóriakezelési mód , amelyben minden, a memóriában létrehozott objektum egy adott "régióhoz" van hozzárendelve.

A régió, más néven zóna, aréna [1] , régió vagy memória kontextus, lefoglalt objektumok halmaza, amelyek egyidejűleg hatékonyan felszabadíthatók. A verem alapú memóriakezeléshez hasonlóan a régió alapú memóriakezelés megkönnyíti a memóriafoglalást és -felszabadítást, lehetővé téve azt minimális többletköltséggel. A veremhez képest azonban a régiókat használó memóriakezelés rugalmasabb lehet: lehetővé teszik az objektumok hosszabb élettartamát, mint a verem keretbe helyezve. A tipikus megvalósításokban az ugyanabban a régióban lévő összes objektum ugyanabban a szomszédos memóriacím-tartományban van lefoglalva, hasonlóan ahhoz, ahogyan a veremkereteket általában lefoglalják.

Előnyök

A verem alapú memóriafoglaláshoz képest a régió alapú memóriakezelés természetesebb módot tesz lehetővé a memóriafoglalás párhuzamos programozásban való megvalósítására. Emellett a régiók nagyban megkönnyítik a virtualizációval és a különféle memóriateljesítmény-optimalizálási technikákkal végzett munkát, leegyszerűsítve azt a feladatot, hogy az azonos régióhoz tartozó összes objektumot egyidejűleg gyorsabban vagy lassabb hozzáférésű memóriába helyezzük [2] .

Példa

Egyszerű példaként tekintsük a következő C kódot , amely lefoglal, majd felszabadít egy adatstruktúrát, például egy linkelt listát :

Régió * r = Régió létrehozása (); ListNode * head = NULL ; for ( int i = 1 ; i <= 1000 ; i ++ ) { ListNode * newNode = allocateFromRegion ( r , sizeof ( ListNode )); newNode -> next = fej ; head = newNode ; } // ... // (itt használd a listát) // ... deleteRegion ( r );

Bár a linkelt lista létrehozása sok műveletet igényel, egy művelettel gyorsan megsemmisíthető, felszabadítva azt a területet, ahol a listaelemek el lettek helyezve. Nincs szükség a lista szkennelésére és elemeinek egyenkénti törlésére.

Megvalósítás

Az egyszerű explicit régiók könnyen megvalósíthatók; a következő leírás David Hanson [ 3 ] cikkén alapul . Minden régió nagy memóriablokkok összekapcsolt listájaként van megvalósítva; minden blokknak elég nagynak kell lennie ahhoz, hogy sok objektum számára lefoglaljon memóriát. A régió adatstruktúra tartalmaz egy mutatót a blokkon belüli következő szabad pozícióra, és ha a blokk megtelik, a memóriakezelő rendszer hozzárendel egy új blokkot, és hozzáadja a listához. Amikor egy régiót felszabadítanak, a következő szabad pozíció mutatója visszaáll az első blokk elejére, és a már létrehozott blokkok teljes listája újra felhasználható a régión belüli objektumok áthelyezésére. Egy alternatív megvalósításban egy régió felszabadításakor a hozzá rendelt blokkok listája visszakerülhet a globális szabad listába, ahonnan a többi régió később új blokkokat allokálhat. Egy ilyen egyszerű sémán belül azonban nem lehetséges egy blokkon belül egyedileg felszabadítani a memóriát meghatározott objektumokból.

A lefoglalt bájtonkénti többletterhelés nagyon alacsony ennél a sémánál. A memóriafoglalás szinte minden epizódja csak a mutató összehasonlítását és frissítését jelenti a következő szabad pozícióhoz. Az egyetlen kivételt azok az epizódok jelentik, amikor a blokkban lévő memória kifogy, és a memóriakezelőnek új blokkot kell csatolnia a régióhoz. A régió felszabadítása egy meghatározott idejű művelet, amelyet ritkán hajtanak végre. A tipikus szemétgyűjtő rendszerekkel ellentétben a régióalapú adatkezelésnek nem kell minden adatobjektumot a típusával megjelölnie .

Történelem és fogalmak

Maga a régió fogalma nagyon régi. Először 1967-ben valósították meg a Douglas Ross AED ingyenes tárolócsomagban , amelyben a memóriát zónák hierarchiájára osztották fel. Az egyes zónák esetében a memóriakezelés fegyelme egyedileg konfigurálható. Mindegyik zóna felszabadítható egyetlen közös művelettel. Így ebben a szoftvercsomagban Ross először valósította meg gyakorlatilag a régió alapú memóriakezelés koncepcióját [4] . 1976-ban az AREA adattípus bekerült az adatstruktúrák csoportkezelésére vonatkozó PL/I nyelvi szabványba [5] . 1990-ben Hanson bebizonyította, hogy a C-ben explicit módon meghatározott régiók (amelyeket arénáknak nevezett) a memóriakezelésben olyan teljesítményt biztosítanak, amelyet lefoglalt bájtonként eltöltött időként mérünk, és még a leggyorsabb ismert kupackiosztási mechanizmust is felülmúlja [3] . Az explicit régiók fontos szerepet játszottak számos korai C-alapú szoftverprojekt fejlesztésében, ideértve az Apache HTTP Servert , ahol pooloknak, és a PostgreSQL -t, ahol memóriakontextusnak nevezik [6] . A hagyományos kupackiosztáshoz hasonlóan ezek a sémák sem biztosítanak memória-hozzáférési biztonságot ; a programozó hozzáférhet egy memóriarégióhoz, miután azt egy függő hivatkozáson keresztül felszabadította, vagy elfelejti felszabadítani a régiót, ami memóriaszivárgást eredményez .

A régiók származtatása

1988-ban a tudósok elkezdték feltárni, hogyan használhatják fel a régiókat a biztonságos memóriafoglaláshoz, és bevezették a régiókövetkeztetés fogalmát . Ennek a technikának a részeként a fordítóprogram a fordítási szakaszban beilleszti a kódba a régiók lefoglalására és felszabadítására vonatkozó direktívákat, valamint az egyedi memóriahelyű objektumokat, amelyek statikusan kapcsolódnak egy adott régióhoz. A fordító tudja, hogyan kell ezt úgy megtenni, hogy garantálni tudja a lógó mutatók és memóriaszivárgások hiányát. A korai munkában Ruggieri és Murtagh ennek a technikának egy olyan változatát vizsgálta, amelyben az egyes funkciók végrehajtásakor egy régió jön létre, és felszabadul, amikor befejeződik [7] . Ennek során adatfolyam-elemzést alkalmaztak az egyes statikusan lefoglalt memóriaobjektumok élettartamának meghatározására, majd az objektumot hozzárendelték a legfiatalabb régióhoz a létrehozási idő szerint, amely az adott élettartammal rendelkező objektumokat tartalmazza. 1994-ben ezt a munkát Tofte és Talpin eredeti munkájában foglalta össze, akik a Ruggieri és Murtagh által javasolt technikát kiterjesztették a magasabb rendű típus- és funkciópolimorfizmus támogatására a Standard ML funkcionális programozási nyelvben . Tofte és Talpin munkája a típuskövetkeztetésen és a régiótípusok elméleti koncepcióin és a régiószámításon alapuló eltérő algoritmust használt [8] [9] . Javasolták a lambda kalkulus kiterjesztését, beleértve a régiókat, mint speciális entitást. Valójában a következő két konstrukciót adták hozzá a lambda-számításhoz:

e 1 ρ-nél: számítsuk ki az e 1 kifejezés eredményét, és tároljuk a ρ tartományban; ρ letrégió e2 végén: hozzon létre egy régiót és kapcsolja össze ρ-vel; számítsuk ki e 2 -t , majd szabadítsuk fel a régiót.

E szintaktikai struktúra miatt a régiók "beágyazottak", ami azt jelenti, hogy ha r 2 jön létre r 1 után , akkor azt is fel kell szabadítani r 1 előtt . Az eredmény egy "halom" régió. Ezenkívül a régiókat ugyanabban a funkcióban kell felszabadítani, amelyben létrejöttek. A korlátozásokat Aiken és munkatársai részben enyhítették [10] .

Ez a kiterjesztett lambda-számítás bizonyíthatóan memóriabiztos köztes reprezentációként szolgált a szabványos ML programok gépi kódba fordításához. Egy olyan fordító létrehozása azonban, amely nagy programok esetén is jó eredményeket tudna adni, számos gyakorlati korlátba ütközött. Ezeket új elemzéssel kellett megoldani, beleértve a rekurzív hívásokkal, a tail -rekurzív hívásokkal végzett munkát, valamint az egy értéket tartalmazó régiók kiiktatását a generált köztes reprezentációból. Ez a munka 1995-ben fejeződött be [11] . Eredményeit az ML Kit, az ML egy olyan változata használta fel, amelynek memóriakezelése régiókon alapult a szemétgyűjtés helyett. Az ML Kit megjelenése lehetővé tette a közepes méretű tesztprogramok két összeállításának közvetlen összehasonlítását, amelyek nagyon eltérő eredményeket adtak ("10-szer gyorsabb és négyszer lassabb") attól függően, hogy egy adott tesztprogram mennyire "régióbarát" volt [12] . Az ML Kit-et végül a nagy alkalmazásokhoz bővítették. Két kiegészítést valósítottak meg benne: a modulok külön összeállítását és egy hibrid technikát, amely kombinálja a régióhatárok levonását a rendszeres szemétszállítással. [13] [14]

A koncepció megvalósítása más programozási nyelveken

Az ML Kit fejlesztése után a régiókat más programozási nyelvekhez is elkezdték implementálni:

  • A C programozási nyelv különféle kiterjesztésében :
    • A C biztonságos dialektusában Cyclone , amely sok egyéb funkció mellett az explicit régiók támogatását is hozzáadta. Ez a nyelv nagyrészt a meglévő alkalmazások C-re való migrálására és a régiók használatára való finomítására összpontosított [15] [16] [17] .
    • A C kiterjesztése, az RC, explicit régiókat is megvalósított [18] . Ez a nyelv azonban régióspecifikus referenciaszámlálást használ a memória biztonságának további szavatolása érdekében azáltal, hogy egyetlen régiót sem szabadul fel idő előtt [19] [20] . A régiók csökkentik a referenciaszámlálás többletköltségét, mivel a régiókra vonatkozó belső hivatkozások nem igénylik a számlálók frissítését, amikor megváltoznak. Az RC explicit statikus típusú rendszert tartalmaz a régiók számára, amely lehetővé teszi bizonyos refcount-frissítések elkerülését [21] .
    • A C Control-C nevű részhalmaza megköveteli, hogy a programok régiókat használjanak (és a végrehajtás bármely időpontjában csak egy régiót). Ezeket a korlátozásokat a nyelv szerzői a statikus memória biztonságát szolgáló tervezés részének tekintik [22] .
  • A régiókat a Java egy részhalmazára implementálták [23] , és a memóriakezelés kritikus összetevőjévé váltak a Realtime Java nyelvben , amely egyesíti ezeket a tulajdonosi típusokkal , hogy vezérelje az objektumok tokozását, és kiküszöbölje a futásidejű ellenőrzéseket a régió felszabadítása érdekében [24]. [25] [26] . A közelmúltban egy félautomata rendszert javasoltak a valós idejű beágyazott Java-alkalmazások régiódetektálására, amely egyesíti a fordítási idejű statikus elemzést, a futási időben vezérelt régiókiosztási szabályzatot és a programozó-fordító tippeket [27] [28]. A régiók kiválóan alkalmasak valós idejű számításra , mivel a fenntartásuk időköltsége statikusan kiszámítható, és sokkal egyszerűbb, mint a hagyományos szemétgyűjtők.
  • Régiókat implementáltak a Prolog [29] [30] és a Mercury [31] [32] logikai programozási nyelvekhez ; ezekben az implementációkban a Tofte és a Talpin régiókövetkeztetési modelljét kiterjesztették a backtracking és a prolog cut utasításokra .
  • A régió alapú memóriakezelést a ParaSail párhuzamos programozási nyelv használja . A ParaSail [33] explicit mutatók hiánya miatt a memóriakezelés megvalósítása során nincs szükség további referenciaszámláló mechanizmusra.

Hátrányok

A régiókat használó rendszerek olyan problémákkal szembesülhetnek, amikor a régiók nagyon nagyokká válnak, mielőtt felszabadulnának, és ezért nagy arányban tartalmaznak halott adatokat. Az ilyen régiókat általában "memóriaszivárgásnak" nevezik (bár végül felszabadulnak). Ezeknek a szivárgásoknak a kijavításához programátalakításra lehet szükség. Általában új, rövidebb élettartamú régiók hozzáadásával állítják elő. Az ilyen típusú problémák hibakeresése különösen nehéz a régiókövetkeztetést használó rendszereken , ahol a programozónak meg kell értenie a rendszer mögötti következtetési algoritmust, vagy részletesen elemeznie kell a köztes reprezentációt a probléma diagnosztizálásához. A hagyományos szemétgyűjtőket használó programok hibakeresése sokkal egyszerűbb, és a szivárgásba került memória időben történő felszabadítása a program átalakítása nélkül is elérhető, pusztán a felépítésében előforduló logikai hibák kiküszöbölésével. Ezek a megfontolások a régió alapú memóriakezelést és a hagyományos szemétgyűjtést kombináló hibrid rendszereket eredményeztek [13] . Másrészt a szemétgyűjtő programok hibakeresésekor akkor is előfordulhat szivárgás, ha olyan adatokra való hivatkozások tárolódnak, amelyeket soha többé nem használnak fel, és ezt a körülményt sokkal alaposabban kell figyelnie a programozónak, mint egy régióalapú rendszerben. memóriakezelés.

A régió alapú memóriakezelés akkor működik a legjobban, ha a régiók száma viszonylag kicsi, és minden régió sok objektumot tartalmaz. A sok ritka régiót tartalmazó programok belső töredezettségtől szenvednek . Ez végül memóriavesztéshez és a régiók kezelésével kapcsolatos további időhöz vezethet. Ismét, amikor a régió kimenettel dolgozik, ezt a problémát nehezebb lehet diagnosztizálni.

Hibrid technikák

Ahogy fentebb említettük, az RC nyelv hibrid memóriakezelési technikát használ, amely magában foglalja a régiók és a referenciaszámlálást . Ez a megközelítés csökkenti a referenciaszámlálás többletköltségét, mivel az objektumok közötti kapcsolatok egy régión belül nem igénylik a számlálók frissítését, amikor módosítják, hozzáadják vagy eltávolítják őket. Hasonlóképpen, egyes régiócímkézést használó hibrid módszerek kombinálják a szemétgyűjtő objektum elérhetőségének nyomon követését a régiókkal. Az ilyen módszerek magukban foglalják a kupac régiókra való felosztását, egy nyomkövetési lépés végrehajtását, amely megjelöli az élő objektumokat tartalmazó régiókat, majd felszabadítja a címkézetlen régiókat. Ez a megközelítés folyamatos memóriatöredezettség-mentesítést igényel, hogy hatékony legyen [34] .

Jegyzetek

  1. ↑ orosz forrásokban ezt a kifejezést szinte nem használják
  2. ↑ Erre például akkor lehet szükség, ha egy párhuzamosan végrehajtott eljárás egy adott példányához kapcsolódó összes objektumot egy többprocesszoros rendszer adott processzorához közeli memóriarészbe helyezzük .
  3. ↑ 1 2 Hanson, David R. Memória gyors lefoglalása és felszabadítása az objektumok élettartama alapján  //  Software: Practice and Experience : Journal. - 1989. - 1. évf. 20 , sz. 1 . - 5-12 . o . - doi : 10.1002/spe.4380200104 . Az eredetiből archiválva: 2012. október 20.
  4. ↑ Ross, Douglas. Az AED ingyenes tárhelycsomagja  (angol)  // Az ACM kommunikációja . - 1967. - 1. évf. 10 , sz. 8 . - P. 481-492 . - doi : 10.1145/363534.363546 .
  5. ↑ American National Standards Institute, inc. Amerikai nemzeti szabványos programozási nyelv PL/I  (angol) . – 1976.
  6. ↑ 2010 PostgreSQL Global Development Group. 41.3. szakasz: Memóriakezelés . PostgreSQL 8.2.15 dokumentáció (1996). Letöltve: 2010. február 22. Az eredetiből archiválva : 2010. február 12..
  7. ↑ Ruggieri, Cristina; Murtagh, Thomas P. (1988). „Dinamikusan allokált objektumok élethosszig tartó elemzése” . POPL '88: A 15. ACM SIGPLAN-SIGACT szimpózium előadásai a programozási nyelvek alapelveiről . New York, NY, USA: ACM. DOI : 10.1145/73560.73585 . Letöltve: 2010. február 22 .
  8. ↑ Tofte, Mads; Jean-Pierre Talpin (1993). A veremkiosztás elmélete polimorf módon tipizált nyelvekben (műszaki jelentés). Számítástechnikai Tanszék, Koppenhágai Egyetem. 93/15. A Citeseer-en archiválva : 2007. június 21.
  9. ↑ Tofte, Mads ; Talpin, Jean-Pierre (1994). „A Typed Call-by-Value λ-kalkulus megvalósítása régióhalom segítségével” . POPL '94: A 21. ACM SIGPLAN-SIGACT szimpózium előadásai a programozási nyelvek alapelveiről . New York, NY, USA: ACM. pp. 188&ndash, 201. DOI : 10.1145/174675.177855 . ISBN  0-89791-636-0 . Archiválva az eredetiből, ekkor: 2014-07-04 . Letöltve: 2014. április 15 . Elavult használt paraméter |deadlink=( súgó )
  10. ↑ Aiken, Alex; Manuel Fähndrich, Raph Levien (1995). Jobb statikus memóriakezelés: A magasabb rendű nyelvek régióalapú elemzésének javítása (műszaki jelentés). EECS Tanszék, Kaliforniai Egyetem, Berkeley. UCB/CSD-95-866. A Citeseer-en archiválva : 2007. június 21.
  11. ↑ Birkedal, Lars ; Tofte, Mads ; Weilstrup, Magnus (1996). „A régiókövetkeztetéstől a Neumann-gépekig a régióreprezentációs következtetésen keresztül” . POPL '96: A 23. ACM SIGPLAN-SIGACT szimpózium előadásai a programozási nyelvek alapelveiről . New York, NY, USA: ACM. pp. 171&ndash, 183. DOI : 10.1145/237721.237771 . ISBN 0-89791-769-3 . Letöltve: 2010. február 22 .  
  12. ↑ Tofte, Mads; Birkedal, Lars; Elsman, Martin; Hallenberg, Niels. Retrospective on Region-Based Memory Management // Magasabb rendű szimbolikus számítástechnika. - 2004. - T. 17 , 3. sz . – S. 245–265 . — ISSN 1388-3690 . - doi : 10.1023/B:LISP.0000029446.78563.a4 .
  13. ↑ 1 2 Hallenberg, Niels; Elsman, Martin; Tofte, Mads. Régiókövetkeztetés és szemétgyűjtés kombinálása // SIGPLAN megjegyzések. - 2003. - T. 37 , 5. sz . – S. 141–152 . — ISSN 0362-1340 . - doi : 10.1145/543552.512547 .
  14. ↑ Elsman, Martin. Szemétgyűjtés biztonsága a régióalapú memóriakezeléshez  //  SIGPLAN Megjegyzések: napló. - 2003. - 1. évf. 38 , sz. 3 . — P. 123–134 . — ISSN 0362-1340 . - doi : 10.1145/640136.604190 .
  15. ↑ Ciklon: Bevezetés a régiókba . Cyclone felhasználói kézikönyv . Letöltve: 2010. február 22. Az eredetiből archiválva : 2010. augusztus 21..
  16. ↑ Grossman, Dan; Morrisett, Greg; Jim, Trevor; Hicks, Michael; Wang, Yanling. Régió alapú memóriakezelés ciklonban // SIGPLAN megjegyzések. - 2002. - T. 37 , 5. sz . – S. 282–293 . - doi : 10.1145/543552.512563 .
  17. ↑ Hicks, Michael; Morrisett, Greg ; Grossman, Dan (2004). „Tapasztalat biztonságos kézi memóriakezeléssel ciklonban” . ISMM '04: A 4. nemzetközi memóriakezelési szimpózium anyaga . New York, NY, USA: ACM. pp. 73&ndash, 84. DOI : 10.1145/1029873.1029883 . ISBN 1-58113-945-4 . Letöltve: 2010. február 22 .  
  18. ↑ Gay, David RC - Biztonságos, régió alapú memóriakezelés a C-hez (lefelé irányuló kapcsolat) . David Gay honlapja . Intel Labs Berkeley (1999). Letöltve: 2010. február 22. Az eredetiből archiválva : 2009. február 26.. 
  19. ↑ Meleg, David ; Aiken, Alex (1998). „Memóriakezelés explicit régiókkal” . PLDI '98: Az ACM SIGPLAN 1998 programozási nyelv tervezéséről és megvalósításáról szóló konferencia anyaga . New York, NY, USA: ACM. pp. 313&ndash, 323. DOI : 10.1145/277650.277748 . ISBN 0-89791-987-4 . Letöltve: 2010. február 22 .  
  20. ↑ Meleg, David Edward (2001). Memóriakezelés explicit régiókkal (PDF) (számítástudományi doktori értekezés). Kaliforniai Egyetem, Berkeley. Archivált (PDF) az eredetiből ekkor: 2019-09-07 . Letöltve: 2010. február 20 . Elavult használt paraméter |deadlink=( súgó )
  21. ↑ Meleg, David ; Aiken, AlexNyelvi támogatás a régiókhoz // SIGPLAN megjegyzések. - 2001. - T. 36 , 5. sz . – S. 70–80 . — ISSN 0362-1340 . - doi : 10.1145/381694.378815 .
  22. ↑ Kowshik, Sumant; Dhurjati, Dinakar; Adve, Vikram (2002). „A kód biztonságának biztosítása valós idejű vezérlőrendszerek futásidejű ellenőrzése nélkül” . CASES '02: A beágyazott rendszerek fordítói, architektúrája és szintézise című 2002-es nemzetközi konferencia anyaga . New York, NY, USA: ACM. pp. 288&ndash, 297. DOI : 10.1145/581630.581678 . ISBN 1-58113-575-0 . Letöltve: 2010. február 22 .  
  23. ↑ Christiansen, Morten V. (1998). Régió alapú memóriakezelés Java nyelven (Masters in Computer Science szakdolgozat). Számítástechnikai Tanszék (DIKU), Koppenhágai Egyetem . Letöltve: 2010. február 20 .  (nem elérhető link)
  24. ↑ Beebee, William S.; Rinard, Martin C. (2001). „A kiterjedt memória megvalósítása valós idejű Java számára” . EMSOFT '01: A beágyazott szoftverekkel foglalkozó első nemzetközi műhelymunka anyaga . London, Egyesült Királyság: Springer-Verlag. pp. 289&ndash, 305. ISBN  3-540-42673-6 . Letöltve: 2010. február 22 . (nem elérhető link)
  25. ↑ Sălcianu, Alexandru; Chandrasekhar Boyapati, William Beebee, Jr., Martin Rinard (2003). Típusrendszer a biztonságos régióalapú memóriakezeléshez valós idejű Java-ban (PDF) (műszaki jelentés). MIT Számítástechnikai Laboratórium. MIT-LCS-TR-869. Archivált (PDF) az eredetiből ekkor: 2021-09-28 . Letöltve: 2020-04-29 . Elavult használt paraméter |deadlink=( súgó )
  26. ↑ Boyapati, Chandrasekhar ; Salcianu, Alexandru ; Beebee, Jr., William (2003). „Tulajdonjogtípusok a biztonságos régióalapú memóriakezeléshez valós idejű Java-ban” . PLDI '03: Az ACM SIGPLAN 2003 programozási nyelv tervezéséről és megvalósításáról szóló konferencia anyaga . New York, NY, USA: ACM. pp. 324&ndash, 337. DOI : 10.1145/781131.781168 . ISBN 1-58113-662-5 . Letöltve: 2010. február 22 .  
  27. ↑ Nahkli, Chaker ; Rippert, Christophe ; Salagnac, Guillaume ; Yovine, Sergio (2007). „Hatékony régióalapú memóriakezelés az erőforrás-korlátozott, valós idejű beágyazott rendszerek számára” (PDF) . "Objektumorientált nyelvek, programok és rendszerek megvalósításáról, fordításáról és optimalizálásáról szóló műhelymunka (ICOOOLPS'2006)" kiadványa . Archivált (PDF) az eredetiből ekkor: 2012-02-26 . Letöltve: 2010. február 22 . Elavult használt paraméter |deadlink=( súgó )
  28. ↑ Salagnac, Guillaume ; Rippert, Christophe (2007). „Félautomata régióalapú memóriakezelés valós idejű Java beágyazott rendszerekhez”. RTCSA '07: A beágyazott és valós idejű számítástechnikai rendszerekről és alkalmazásokról szóló 13. IEEE nemzetközi konferencia anyaga . Washington, DC, USA: IEEE Computer Society. pp. 73&ndash, 80. DOI : 10.1109/RTCSA.2007.67 . ISBN 978-0-7695-2975-2 .  
  29. ↑ Makholm, Henning (2000). Régió alapú memóriakezelés Prologban (PDF) (Masters in Computer Science tézis). Koppenhágai Egyetem, Dánia. Archiválva az eredetiből (PDF) 2011. június 5-én . Letöltve: 2010. február 20 .
  30. ↑ Makholm, Henning (2000). „Régióalapú memóriakezelő a prologhoz” . ISMM '00: A 2. nemzetközi memóriakezelési szimpózium anyaga . New York, NY, USA: ACM. pp. 25&ndash, 34. DOI : 10.1145/362422.362434 . ISBN 1-58113-263-8 . Letöltve: 2010. február 22 .  
  31. ↑ Phan, Quan ; Janssens, GerdaStatikus régióelemzés a Mercury számára. - Springer Berlin / Heidelberg, 2007. - T. 4670/2007. – S. 317–332. — (Számítástechnikai előadásjegyzetek). - ISBN 978-3-540-74608-9 . - doi : 10.1007/978-3-540-74610-2 .
  32. ↑ Phan, Quan ; Somogyi Zoltán (2008). „Futásidejű támogatás régióalapú memóriakezeléshez a Mercuryban” . ISMM '08: A 7. nemzetközi memóriakezelési szimpózium anyaga . New York, NY, USA: ACM. pp. 61&ndash, 70. DOI : 10.1145/1375634.1375644 . ISBN  978-1-60558-134-7 . Archiválva az eredetiből, ekkor: 2018-06-01 . Letöltve: 2014. április 15 . Elavult használt paraméter |deadlink=( súgó )
  33. ↑ Taft, Tucker Mutató nélküli út az objektumorientált párhuzamos programozáshoz . ParaSail blog (2012). Letöltve: 2012. szeptember 14. Az eredetiből archiválva : 2012. augusztus 13..
  34. ↑ Blackburn, Stephen M .; McKinley, Kathryn S. (2008). „Immix: egy mark-region szemétgyűjtő helyhatékonysággal, gyors gyűjtéssel és mutátorteljesítménnyel” . PLDI '08: A 2008-as ACM SIGPLAN programozási nyelv tervezéséről és megvalósításáról szóló konferencia anyaga . New York, NY, USA: ACM. pp. 22&ndash, 32. DOI : 10.1145/1375581.1375586 . ISBN  978-1-59593-860-2 . Archiválva az eredetiből, ekkor: 2018-11-19 . Letöltve: 2014. április 15 . Elavult használt paraméter |deadlink=( súgó )