Emuláció

Az emuláció ( angolul  emulation ) a számítástechnikában  szoftverek, hardverek vagy ezek kombinációinak olyan komplexuma, amelyet arra terveztek, hogy az egyik számítástechnikai rendszer ( vendég ) funkcióit átmásolják (vagy emulálják ) egy másik számítógépre , amely különbözik az első számítógépes rendszertől ( host ) oly módon, hogy az emulált viselkedés a lehető legjobban megfeleljen az eredeti rendszer ( guest ) viselkedésének. A cél a viselkedés minél pontosabb reprodukálása, szemben a számítógépes szimuláció különféle formáival., amelyben valamilyen absztrakt modell viselkedését szimulálják. Például egy hurrikán vagy egy kémiai reakció szimulálása nem emuláció.

Emuláció a számítástechnikában

Az emuláció egy eszközben lévő számítógépes program azon képességére utal, hogy emuláljon ( szimuláljon ) egy másik programot vagy eszközt. Például sok nyomtatót úgy terveztek, hogy emulálják a HP Laserjet nyomtatókat , mivel ezekhez a nyomtatókhoz nagy mennyiségű szoftver áll rendelkezésre. Ha egy nem HP nyomtató emulál egy HP nyomtatót, akkor a HP nyomtatókhoz tervezett bármely program képes lesz nem HP nyomtatókkal együttműködni, és azonos kimenetet produkálni.

A hardveres emulációt külön eszközként készült emulátorok képviselik. Például a DOS-kompatibilis kiegészítő kártyák, mint a Centris 610 és a Performa 630, amelyeket néhány Macintosh -ra telepítettek, hogy lehetővé tegyék a DOS-programok PC -ről történő futtatását . Egy másik példa az FPGA - alapú hardveremulátorok .

Elméletileg a Church-Turing tézis szerint bármely működési környezet emulálható egy másikon. A gyakorlatban azonban ez gyakran rendkívül nehéz, mert az emulált rendszer pontos viselkedése nincs dokumentálva, és csak visszafejtéssel határozható meg. A dolgozat nem mondja ki azt sem, hogy ha az emuláció teljesítménye kisebb, mint az eredeti rendszeré, akkor az emulált szoftver lényegesen lassabban fog futni, mint az eredeti hardveren kellene, ami emuláció leállását vagy instabil teljesítményét okozhatja.

Elektronikus archiválás

Az emuláció az elöregedő számítástechnikai rendszerek elektronikus archiválásának egyik módja . Ebben az értelmezésben az emuláció célja az eredeti digitális környezet hű reprodukálása, amelynek megvalósítása nehéz és időigényes lehet, de értékes, mert lehetőség nyílik a hiteles digitális tárggyal való szoros kapcsolat kialakítására [1] .

Az emuláció az eredeti digitális eszköz hardver- és szoftverkörnyezetét kezeli , és egy modern gépen újraalkotja [2] . Az emuláció lehetővé teszi a felhasználó számára, hogy bármilyen típusú alkalmazásszoftverhez vagy operációs rendszerhez hozzáférjen egy modern platformon, miközben a szoftver ugyanúgy fut, mint az eredeti környezetben [3] . Jeffrey Rothenberg, az emuláció elektronikus archiválási alkalmazásának egyik korai támogatója úgy véli, hogy „az ideális egyetlen bővíthető, hosszú távú megoldás lenne, amelyet egyszer és mindenkorra ki lehet fejleszteni, és amelyet egységesen, automatikusan és szinkronban alkalmaznának. például minden frissítési ciklus) minden típusú dokumentumra és adathordozóra” [4] . Megjegyzi továbbá, hogy ennek a megoldásnak nem csak a régi rendszerekre kell vonatkoznia, hanem könnyen hordozhatónak kell lennie a még ismeretlen jövőbeli rendszerekre is [5] . A gyakorlatban, ha egy alkalmazás új verzióját adják ki annak érdekében, hogy biztosítsák a kompatibilitást és az összes összetevő migrációját, akkor ehhez az alkalmazáshoz létre kell hozni egy emulátort, amely hozzáférést biztosít az összes említett összetevőhöz.

Előnyök

Akadályok

Médiaművészet

Mivel a médiaművészet elsősorban digitális formátumban készül, az emuláció rendkívül fontos számára az elektronikus archiválás eszközeként. Az olyan figurák, mint Cory Arcangel, visszaszerzik az elavult technológiákat, és felhasználják azokat munkájuk során, felértékelve a decentralizált és informális folyamat fontosságát a digitális kultúra megőrzésében.

Az emulációt gyakran használják a médiaművészetben a digitális információk megőrzésének eszközeként, amelyet később változatlan formában reprodukálnak, függetlenül az elöregedő és elavult berendezésektől. A paradoxon az, hogy emulációt és emulátorokat kell építeni, hogy futhassanak a jövő gépein [11] .

Emuláció használata új rendszerek fejlesztéséhez

Az emuláció különböző típusait széles körben használják új rendszerek fejlesztése és tervezése során. Az emuláció leegyszerűsíti a fejlesztést azáltal, hogy lehetővé teszi a tervezési hiányosságok azonosítását, kivizsgálását és kijavítását a fizikai megvalósítás előtt [12] . Az emuláció különösen hasznos a többmagos rendszerek fejlesztésében, ahol a párhuzamos feldolgozási konfliktusokat gyakran meglehetősen nehéz azonosítani és diagnosztizálni az emulációval elérhető virtuális vezérelt hardver használata nélkül [13] . Ezenkívül az emuláció lehetővé teszi, hogy a hardver tényleges gyártása előtt elkezdjen szoftverfejlesztést [14] , így ellenőrizni a benne rejlő jellemzőket.

Az emuláció típusai

A legtöbb létező emulátor csak a . Így ha ROM-ban tárolt operációs rendszerre vagy más szoftverre van szükség, azt külön be kell szerezni (de emulálható is). A jövőben az operációs rendszert és a szoftvert is ugyanúgy értelmezi majd az emulátor, mint az eredeti hardveren. Az emulált bináris gépi kódok értelmezőjén kívül néhány egyéb berendezést (például bemeneti és kimeneti eszközöket) is emulálni kell. Például, ha egy adott memóriaterületre írva valamit megjeleníteni kell a képernyőn, akkor ezt a viselkedést is emulálni kell.

A limitben az emulátornak az eredeti áramköri terv paraméterei és jellemzői alapján létrehozott modellből kell indulnia, beleértve a virtuális tápegységet is, de a gyakorlatban ez kivételes megoldás lenne. Az emulátorok általában a rendelkezésre álló dokumentációra és az eszköz logikai diagramjára épülő modellből indulnak ki. Egyes rendszerek emulációjához fontos a nagy emulációs pontosság, egészen az egyes elemek órajelétől, a nem dokumentált funkciókig, a kiszámíthatatlan analóg komponensekig és hibákig. Ez különösen fontos a klasszikus otthoni számítógépek, például a Commodore 64 emulátorainak implementálásakor, amelyekhez a programok gyakran a játék készítői és a demoscene által kifejlesztett kifinomult, alacsony szintű programozási technikákat alkalmaznak .

Ezzel szemben néhány más eszköz nagyon korlátozott közvetlen hozzáféréssel rendelkezett a hardverhez. Ilyen esetekben egy egyszerű kompatibilitási réteg is elegendő lehet. Az emulált program rendszerkérelmei a gazdagép rendszerkérelmeivé alakulnak, vagyis a FreeBSD , NetBSD és OpenBSD rendszerek a Linux kompatibilitási réteget használják zárt forráskódú Linux alkalmazások futtatására . Például a Nintendo 64 GPU -ja teljesen programozható volt, és a legtöbb játékfejlesztő beágyazott gyári programokat használt, amelyek önállóak voltak, és FIFO pufferen keresztül kommunikáltak a játékkal . Ezért sok emulátor egyáltalán nem emulálja a GPU-t, ehelyett ugyanúgy értelmezi a CPU-parancsokat, mint az eredeti program.

A beágyazott rendszerekhez és játékkonzolokhoz való programok fejlesztői gyakran nagyon pontos emulátorokra, úgynevezett szimulátorokra építik termékeiket , mielőtt fizikai hardveren futtatnák azokat. Erre azért van szükség, hogy a végleges hardververzió megjelenése előtt létre tudjon hozni és tesztelni lehessen, valamint gyorsan lehessen hibakeresni a programot anélkül, hogy időt vesztegetne másolásra és hibakereső mellékhatások bevezetésére . A szimulátort sok esetben a hardvergyártó építi és biztosítja, aminek elméletileg növelnie kell a pontosságát.

A matematikai koprocesszor emulációt matematikai utasításokkal összeállított programok futtatására használják olyan gépeken, ahol nincs társprocesszor telepítve, ahol a CPU extra terhelése negatívan befolyásolhatja a teljesítményt. Ha a társprocesszor nincs telepítve és nincs beépítve a CPU-ba, egy matematikai utasítás végrehajtásakor egy megszakítást (nincs társprocesszor) hívunk meg, elindítva a matematikai emulátor szubrutint. Az utasítás sikeres végrehajtása után a vezérlés visszakerül a programhoz.

Az emulátor szerkezeti összetétele

Az emulátor általában több modulból áll , amelyek mindegyike az eredeti eszköz külön emulált alrendszerének felel meg. A legáltalánosabb esetben az emulátor a következő blokkokból áll:

A rendszerbuszokat általában nem emulálják az emuláció egyszerűsítése és a teljesítmény növelése érdekében. Ehelyett a virtuális perifériák közvetlenül a processzorral vagy a memória alrendszerrel kommunikálnak.

Memória alrendszer

Emuláláskor a teljes memória-alrendszer leképezhető egyszerű tömbként, amelynek minden eleme egy emulált szó méretű. Ez a megközelítés azonban kudarcra van ítélve, mert ebben az esetben egyetlen logikai memóriacím sem fog megegyezni a fizikai memóriával. Ez akkor a legkifejezettebb, ha az eredeti hardver fejlett memóriakezeléssel rendelkezik (ebben az esetben az MMU logikát a memória alrendszer  moduljában kell megvalósítani, akár külön modulként, akár a virtuális CPU részeként).

Azonban még ha az emulált eszköz nem is tartalmaz MMU-t, vannak más tényezők, amelyek megbontják a logikai és fizikai memória egyenértékűségét: sok (ha nem mindegyik) architektúra rendelkezik RAM -mal leképezett I/O portokkal; még azok is rendelkeznek ROM -leképezett memóriablokkokkal , amelyek nem rendelkeznek velük . Ez azt jelenti, hogy a memória tömbábrázolását nem szabad használni, ha a ROM-ot emulálni kell. Az olyan funkciók, mint a bankváltás vagy a szegmenscímzés , szintén megnehezíthetik a memóriaemulációt.

Ennek eredményeként a legtöbb emulátornak legalább két rutinja van, egy a memóriából való olvasáshoz és egy a memóriába íráshoz, amelyek felelősek a megfelelő objektum megfelelő területéhez való hozzáférésért.

A korlátozott címzésű emulációs rendszerekre, ahol a 0 -tól (ROM-méret) - 1 -ig terjedő memóriacímek csak olvashatók, az összes többi pedig a RAM-hoz tartozik, az alábbiakhoz hasonló jellemző.

void WriteMemory ( szó cím , szó érték ) { wordRealAddress ; _ RealAddress = Cím + BaseRegister ; if (( RealAddress < LimitRegister ) && ( RealAddress > ROMSIZE )) { Memória [ RealAddress ] = Érték ; } másik { RaiseInterrupt ( INT_SEGFAULT ); } } szó ReadMemory ( szó cím ) { wordRealAddress ; _ RealAddress = Cím + BaseRegister ; if ( RealAddress < LimitRegister ) { return Memória [ RealAddress ]; } másik { RaiseInterrupt ( INT_SEGFAULT ); return NULL ; } }

Központi feldolgozó egység

Általános szabály, hogy a CPU modul az emulátor legösszetettebb része. Sok emulátor előre beépített CPU-modulokat használ, hogy a minőségre és a hatékony emulációra összpontosítson.

Az interpreter  a CPU-emuláció legegyszerűbb formája. Ez egy olyan program, amely követi a programvégrehajtás folyamatát, és minden egyes gépi utasításra, amellyel találkozik, szemantikailag egyenértékű műveleteket hajt végre a gazdagép processzorának eredeti utasításaival. Ez úgy lehetséges, hogy az emulált CPU minden regiszteréhez és jelzőjéhez változókat rendelünk. Az emulált CPU logikája kisebb-nagyobb bonyolultsággal megvalósítható egy programalgoritmusban, olyan szoftveres megvalósítást hozva létre, amely többé-kevésbé tükrözi az eredeti hardvert.

A következő példa bemutatja, hogyan emulálható a CPU az értelmező segítségével. Ebben a példában a megszakítások lekérdezése az utasítás végrehajtása előtt történik, azonban az alacsony teljesítmény miatt ezt a módszert ritkán használják a meglévő emulátorokban (általában gyorsabb a megszakításként működő szubrutin használata).

void Végrehajtás ( void ) { if ( Interrupt != INT_NONE ) { SuperUser = TRUE ; WriteMemory ( ++ StackPointer , ProgramCounter ); ProgramCounter = Interrupt Pointer ; } kapcsoló ( ReadMemory ( ProgramCounter ++ )) { /* * Minden érvényes utasítás kezelése * ide kerül... */ alapértelmezett : Megszakítás = INT_ILLEGAL ; } }

A tolmácsok nagyon népszerűek a számítógépek szimulálására, mivel megvalósításuk sokkal egyszerűbb, mint más teljesítménynyertes megoldások, mivel sebességük gyakran elegendő a modern gépeknél tíz évvel idősebb számítógépek emulálásához.

Az értelmezés alkalmazása a benne rejlő teljesítménybüntetéssel azonban problémát jelenthet, ha olyan számítógépet szeretne emulálni, amelynek processzora egy nagyságrenddel gyorsabb, mint a gazdagép processzora. A közelmúltig sokan haszontalannak tartották az emulációt ilyen esetekben.

A dinamikus fordítási technikák fejlődése segített leküzdeni ezeket a korlátokat. Az emulált programkód egyszerű lefordítása a gazdagép architektúrán végrehajtható kódra több okból is eleve lehetetlen:

  • a kód önmódosító lehet, még akkor is, ha a módosítás csak akkor történik meg, amikor a kódot egy emulált operációs rendszer betölti (pl. lemezről);
  • előfordulhat, hogy nincs megbízható módszer az adatok (nem sugárzott) és a végrehajtható kód elkülönítésére .

Ezeknek a problémáknak a megkerülésére számos trükköt alkalmaznak, beleértve a jól ismert " menet közbeni összeállítást ". A fordító megvárja, amíg a processzorvezérlő folyamat egy lefordítatlan kódot tartalmazó régióba lép. Csak ezután ("menet közben") fordítják le a kódblokkot végrehajtható kóddá. A feldolgozott kód a kódgyorsítótárba kerül , míg az eredeti kód nem módosul. Ebben az esetben még az adatblokkokat is értelmetlen fordításnak veti alá a fordító, aminek egyetlen hatása az lesz, hogy megnöveli a fordítóidőt.

Bizonyos esetekben, például régi játékok futtatásakor, a nagy emulációs sebesség nem kívánatos, mivel a játékokat a jövőbeni számítógépek teljesítményének figyelembevétele nélkül hozták létre. Egy 30 MHz-es CPU-val rendelkező PC-re tervezett játékban a játékosnak játékszintenként 300 játékmásodperc adható, ha ugyanazt a játékot 300 MHz-es CPU-val rendelkező PC-n futtatják, akkor a játékosnak 300 játékmásodperce lesz, ami 30-nak felel meg. valódi másodpercek. Más programok, például egyes DOS programok, egyáltalán nem futnak egy gyors számítógépen. A gyakorlatban, ha egy olyan rendszert emulálnak, amely "fekete doboz" volt, és a kernelben nem történtek várt változások, akkor a programok bizonyos hardverparaméterektől (például a CPU frekvenciától) függhetnek. Így az ilyen alkalmazások helyes emulálásához az emulációs sebesség nagyon pontos szabályozására van szükség.

Bemenet és kimenet

Mint már említettük, a rendszerbuszokat ritkán emulálják. Minden I / O eszközt külön kell figyelembe venni, mivel az emulátor nem valósít meg univerzális interfészt. Mivel minden I/O eszköz tökéletesen illeszthető az emulált eszköz paramétereihez, ez teljesítménynövekedést eredményez. A szabványosított, egységes API -kon alapuló megoldások azonban továbbra is versenyezhetnek az egyszerűsített modellekkel, ha ügyesen vannak megvalósítva. További előnyt jelent majd az „automatikusan” beszerzett bővítményszolgáltatás, amelyen keresztül harmadik féltől származó virtuális eszközök is együttműködhetnek az emulátorral. Az egyesített I/O API-kban nem szükséges megismételni a busz teljes felépítését: áramköre néhány elektronikai komponensre korlátozódik, így szoftveres megvalósításban nem szükséges a párhuzamos számítások konfliktusait feloldó rendszer.

Még az egyes eszközöket külön-külön figyelembe vevő emulátorokban is általában a következő virtuális infrastruktúra található:

  • megszakításkezelés egy olyan rutinon keresztül, amely beállítja a CPU-emulátor által olvasott jelzőket, amikor egy megszakítást deklarálnak, ami lehetővé teszi a virtuális CPU számára, hogy "lekérdezzen megszakításokat";
  • fizikai memória írása és olvasása két, a logikai memóriához hasonló eljárással (az utóbbitól eltérően azonban az előbbi gyakran helyettesíthető egyszerű memóriatömb-hivatkozásokkal).

Emuláció és szimuláció

Az "emulátor" szót az IBM-nél találták meg [15] , miközben az NPL ( IBM System/360 ) terméksorozatot fejlesztették ki "szoftver, mikrokód és hardver újszerű kombinációjával" [16] . Azt találták, hogy a régebbi IBM gépekre írt programok futtatásához a hardveres mikrokód használata sokkal hatékonyabb, mint a szoftveres szimuláció. Korábban, 1957-ben az IBM szoftvertolmácsot szállított, amely lehetővé tette a régebbi IBM 704 számítógépek programjainak futtatását az IBM 709 és IBM 7090 számítógépeken [17] . 1964-ben az IBM mérnökei megalkották az "emuláció" szót, hogy leírják a szimulációs folyamat felgyorsítására szolgáló mikrokód első használatának fogalmát.

Az utóbbi időben ennek a kifejezésnek a használata általánossá vált a szoftverekkel összefüggésben. Az 1980-as évekig az "emuláció" szó kizárólag a mikrokódot használó hardveres megvalósítást jelentette, míg a szoftveres emulációt "szimulációnak" nevezték [18] . Például egy számítógép, amelyet kifejezetten más architektúrára írt programok futtatására terveztek, emulátor volt. Másrészt a szimulátor lehet egy PC-s program, amely képes szimulálni a régi Atari játékokat. Bár a puristák továbbra is rámutatnak erre a terminológiai különbségre, ma már általánosan elfogadott, hogy az emulációt egy bináris kódot futtató gép teljes szimulációjaként említik, míg a szimuláció alapvetően egy absztrakt modellen működő számítógépes szimulációra utal. A számítógépes modellezést szinte minden tudományos és mérnöki tevékenységben alkalmazzák, beleértve a számítástechnikát is, amely számos alkalmazást kínál az absztrakt modellekkel való munkavégzéshez, például kommunikációs hálózatok modellezéséhez.

Logikai áramkörök modellezése

A logikai szimuláció egy speciális szoftver használata a digitális áramkörök és a hardverleíró nyelvek viselkedésének előrejelzésére . A szimuláció a fizikai absztrakció különböző szintjein végezhető: tranzisztorszint , logikai kapuszint , regiszterátviteli szint vagy funkciószint. A modellezés a séma logikai egyenletek formájában történő kidolgozása után és a fizikai előállításának megkezdése előtt történik.

Funkcionális modellezés

A funkcionális modellezés egy számítógépes program használata egy másik, assembly nyelven vagy forráskóddal írt számítógépes program végrehajtásának szimulálására bináris gépi kód helyett . A funkcionális modellezés segítségével a programozó kiadhatja és elemezheti a kiválasztott kódszakasz munkáját, hogy felismerje a hibákat (bugokat), anélkül, hogy bináris kódhoz folyamodna. Ez különbözik a bináris kód végrehajtásától, amely emuláció.

A funkcionális modellezést először az Autonetics alkalmazta 1960 körül, hogy tesztelje a később a D-17B katonai járművön futó assembly nyelvű programokat. Ez lehetővé tette a repülési szoftverek megírását, végrehajtását és tesztelését a D-17B számítási hardverének fizikai legyártása előtt. Ugyanez a cég később funkcionális szimulációt használt a D-37C-n futtatandó repülési szoftver tesztelésére.

Játékkonzol emuláció

A játékkonzol-emulátor egy olyan program, amely lehetővé teszi a személyi számítógépek vagy játékkonzolok számára egy másik konzol emulálását. Leggyakrabban régi játékok futtatására használják PC-n vagy modernebb konzolokon. Az emulátorokat játékok amatőr fordításainak, játékmódosításainak elkészítésére, valamint a felhasználók által generált tartalmak, például demók és új játékok fejlesztésére is használják régebbi rendszerekhez. Az internet nagy szerepet játszott az ilyen típusú emuláció elterjedésében , mivel a legtöbb (ha nem az összes) emulátor nem érhető el a kiskereskedelmi egységekben. Az elmúlt két évtizedben kiadott emulátorok közül néhány a Dolphin , ZSNES , MAME , DeSmuME , ePSXe , Gens , VisualBoyAdvance , Jnes és Nestopia .

Terminál emuláció

A terminálemulátor egy olyan program egy modern számítógéphez vagy más eszközhöz, amely interaktív hozzáférést tesz lehetővé nagyszámítógépes operációs rendszerhez vagy más gazdagéphez, például HP-UX vagy OpenVMS . Az IBM 3270 -hez és a VT100 -hoz hasonló terminálokat már régóta nem gyártanak . Ehelyett egy modern operációs rendszeren futó programot használ, amely egy "hülye" terminált utánozza, és képes megjeleníteni a gazdagép alkalmazás grafikus és szöveges elemeit, elküldeni a billentyűzet bevitelét és a megfelelő terminálprotokoll segítségével parancsokat feldolgozni. Néhány ilyen emulátor az Attachmate Reflection, az IBM Personal Communications, az EmuVM AlphaVM virtuális gépe, a Stromasys CHARON-VAX/AXP és a Micro Focus Rumba alkalmazásokat tartalmazza.

Lásd még

Jegyzetek

  1. Mi az emuláció? (nem elérhető link) . Koninklijke Bibliothek . Letöltve: 2012. december 11. Az eredetiből archiválva : 2011. június 7.. 
  2. 1 2 van der Hoeven, Jeffrey, Bram Lohman és Remco Verdegem. Emuláció a digitális megőrzéshez a gyakorlatban: az eredmények . The International Journal of Digital Curation 2.2 (2007): 123-132.
  3. 1 2 3 Muira, Gregory. A hagyományos örökségpolitika határainak feszegetése: a multimédiás tartalmakhoz való hosszú távú hozzáférés fenntartása . IFLA Journal 33 (2007): 323-326.
  4. Rothenberg, Jeffrey. Az ideális megoldás kritériumai. A technológiai futóhomok elkerülése: működőképes műszaki alapot találni a digitális megőrzéshez. (nem elérhető link) . Könyvtári és Információs Erőforrások Tanácsa (1998). Letöltve: 2008. március 8. Az eredetiből archiválva : 2008. február 20.. 
  5. Rothenberg, Jeffrey. Az emulációs megoldás . A technológiai futóhomok elkerülése: működőképes műszaki alapot találni a digitális megőrzéshez. Washington, DC: Council on Library and Information Resources, 1998. Council on Library and Information Resources. 2008. március 28. 2008 http://www.clir.org/pubs/reports/rothenberg/contents.html
  6. Granger, Stewart. Digitális megőrzés és emuláció: az elmélettől a gyakorlatig. Proc. ichim01 Meeting, vol. 2., 3–7. 2001. Milánó, Olaszország. Toronto: Archívum és Múzeumi Informatika, Torontói Egyetem, 2001. március 28. 2008 http://www.leeds.ac.uk/cedars/pubconf/papers/ichim01SG.html Archiválva 2009. január 31-én a Wayback Machine -nél
  7. Granger, Stewart. Az emuláció mint digitális megőrzési stratégia . D-Lib Magazin 6.19 (2000). 2008. március 29. http://www.dlib.org/dlib/october00/granger/10granger.html
  8. Rothenberg, Jeffrey. Az emulációs megoldás . A technológiai futóhomok elkerülése: működőképes műszaki alapot találni a digitális megőrzéshez. Washington, DC: Council on Library and Information Resources, 1998. Council on Library and Information Resources. 2008. március 28. 2008
  9. Pokémon Black and White - The Cutting Room Floor (link nem érhető el) . Hozzáférés időpontja: 2013. május 25. Az eredetiből archiválva : 2013. június 6. 
  10. Mega Man Star Force - The Cutting Room Floor (a link nem érhető el) . Letöltve: 2013. május 25. Az eredetiből archiválva : 2013. május 12. 
  11. A művészet visszhangja: Emuláció, mint megőrzési stratégia (downlink) . Letöltve: 2007. december 11. Az eredetiből archiválva : 2007. október 27.. 
  12. Peter Magnuson. Teljes rendszerszimuláció: Szoftverfejlesztés hiányzó linkje (2004). Letöltve: 2013. május 25. Az eredetiből archiválva : 2013. május 25..
  13. Hibakeresés és teljes rendszerszimuláció (lefelé irányuló kapcsolat) . Letöltve: 2013. május 25. Az eredetiből archiválva : 2008. október 8.. 
  14. Vania Joloboff. Beágyazott rendszerek teljes rendszerszimulációja (nem elérhető hivatkozás) (2009). Hozzáférés dátuma: 2013. május 25. Az eredetiből archiválva : 2014. február 9.. 
  15. Pugh, Emerson W. IBM építése: Iparág és technológia alakítása  . - MIT, 1995. -  274. o . — ISBN 0-262-16147-8 .
  16. Pugh, Emerson W.; et al. IBM 360 és Early 370 rendszerek  (határozatlan idejű) . - MIT, 1991. - ISBN 0-262-16123-0 . 160-161. oldal
  17. "7090 adatfeldolgozó rendszer" - "IBM 704 programok kompatibilitási szolgáltatása" alszakasz
  18. S. G. Tucker, Emulation of Large Systems . Kommunikáció az ACM (CACM) Vol. 8, sz. december 12 1965, pp. 753-761

Irodalom

Linkek