Mainframe నుంచి VPS వరకు కంప్యూటింగ్ చరిత్ర

మీ VPS ఎక్కడి నుంచి వస్తుంది

Mainframe నుంచి cloud వరకు computing చరిత్రలో ఒకే ఆలోచన క్రమంగా చౌకగా మారింది. ఆ ఆలోచనే time-sharing: ఖరీదైన ఒకే machine ను ఒకేసారి అనేక మంది ఉపయోగించుకునేలా చేసి, ప్రతి ఒక్కరికీ దాని private view ను అందించడం. కంప్యూటర్‌ను ఉపయోగించే వ్యక్తుల కంటే దాని ధర ఎక్కువగా ఉండటం వల్ల ఇది సుమారు 1960లో ఆవిష్కరించబడింది. మీరు ఈరోజు అద్దెకు తీసుకునే VPS లోని ప్రతి భాగం ఆ సమస్యను పరిష్కరించడానికి రూపొందించబడింది: వినియోగదారుల మధ్య isolation, CPU time ను కేటాయించే scheduler, hypervisor, మరియు వినియోగించిన గంటలను లెక్కించే bill. ఆ సమస్య పూర్తిగా తొలగిపోలేదు. Hardware చౌకగా మారింది. అందువల్ల ఒకప్పుడు research grant అవసరమైన భాగం ఇప్పుడు నెలకు కొన్ని dollars మాత్రమే ఖర్చవుతుంది.

1959 నుంచి 1961 వరకు: time-sharing ఎందుకు ఆవిష్కరించబడింది

1950లలో కంప్యూటర్ batch విధానంలో పనిచేసేది. మీరు మీ ప్రోగ్రామ్‌ను cards పై punch చేసి, ఆ deck ను operator కు ఇచ్చి, printout కోసం తరువాత తిరిగి వచ్చేవారు. ఒక character ను తప్పుగా నమోదు చేస్తే ఒక రోజు సమయం వృథా అయ్యేది. యంత్రం నిరంతరం పనిచేస్తూ ఉండేది. అదే ప్రధాన ఉద్దేశం. ఎందుకంటే IBM 7090 వంటి యంత్రం మిలియన్ల డాలర్లు ఖర్చయ్యేది, దాని కోసం వేచి ఉన్న వ్యక్తుల సమయం ఏ invoice లోనూ కనిపించేది కాదు.

January 1959లో John McCarthy MITలోని ఒక memoలో దీనికి విరుద్ధమైన వాదనను ప్రతిపాదించారు. యంత్రం వ్యక్తి కోసం వేచి ఉండాలి. అదే సంవత్సరం UNESCO conferenceలో Christopher Strachey time-sharing యొక్క ఒక రూపాన్ని వివరించారు. అయితే ఆయన ఉద్దేశం అనేక మంది ఒకేసారి typing చేయడం కాదు; ఇతర jobs నడుస్తున్నప్పుడు ఒక programmer debugging చేయడం. 1961లో MIT centennial సందర్భంగా మాట్లాడినప్పుడు McCarthy మరింత ముందుకు వెళ్లారు. Computing ను electricity లాగా meter చేసి, public utilityగా విక్రయించవచ్చని ఆయన అన్నారు.

ఆ సమయంలో దీనికి వచ్చిన అభ్యంతరం time-sharing యంత్రాన్ని వృథా చేస్తుందనే విషయం. Users మధ్య మారడానికి cycles ఖర్చవుతాయి, ఆ cyclesే ఖరీదైనవి. ఆ అభ్యంతరం సరైనదే. కానీ అది ఇక ప్రాధాన్యం లేకుండా పోయింది. ఎందుకంటే అరవై సంవత్సరాల పాటు ఒక cycle ధర తగ్గింది, అయితే మానవ శ్రద్ధ యొక్క ఒక గంట ధర తగ్గలేదు.

CTSS కనిపెట్టాల్సినవి

వివాదానికి ముగింపు పలకడానికి Fernando Corbató బృందం MIT Computation Centerలో Compatible Time-Sharing System (CTSS)ను నిర్మించింది. ఇది మొదటిసారిగా November 1961లో IBM 709పై ప్రదర్శించబడింది. అది నలుగురు usersకు సేవలందిస్తూ, ప్రతి user పని తాత్కాలికంగా అతనికి కేటాయించిన magnetic tape driveకు మార్చేది. “Compatible” అంటే machine కింద పాత batch systemను కూడా నడపగలదని అర్థం. కొత్త పని మాత్రమే చేసే computerను ఎవరూ కొనరు.

నలుగురు users చిన్న సంఖ్యే. ఆ స్థాయికి చేరుకోవడానికి పరిష్కరించాల్సిన సమస్యల జాబితా మాత్రం చిన్నది కాదు. మీ kernel ప్రస్తుతం పరిష్కరిస్తున్న సమస్యల జాబితా కూడా ఇదే. ఒక పొడవైన job మిగతా terminals అన్నింటినీ నిలిపివేయకుండా CTSSకు scheduler అవసరమైంది. ఒక program crash అయినప్పుడు మొత్తం system కాకుండా ఒక్క user మాత్రమే ప్రభావితమయ్యేలా memory protection అవసరమైంది. logout తర్వాత కూడా నిలిచి ఉండే storage అవసరమైంది. అందుకే modern user గుర్తించగలిగే తొలి file systemsలో ఒకటి CTSSలో ఉంది. అలాగే ఒక user మరొక user filesను చదవకుండా passwords అవసరమయ్యాయి.

ఆ భాగాలకు కొత్త పేర్లు పెట్టండి; మీ వద్ద Linux box ఉంటుంది. Linux 6.6లో CFS స్థానాన్ని EEVDF తీసుకుంది. Memory protectionను MMU (memory management unit) అందిస్తుంది. ఇది ప్రతి processకు ప్రత్యేక virtual address space ఇస్తుంది. logout తర్వాత కూడా నిలిచి ఉండే storage మీ home directory. Password fileను ఇప్పటికీ /etc/passwd అని పిలుస్తారు.

Multics మరియు కంప్యూటర్ యుటిలిటీ

MIT యొక్క తదుపరి వ్యవస్థ, McCarthy వివరించిన యుటిలిటీగా ఉండాల్సి ఉంది. Project MAC 1963లో ప్రారంభమైంది. 1964 ఆగస్టులో General Electric GE-645 కోసం ఒప్పందం కుదుర్చుకుంది. 1965లో మొదటి Multics పత్రాలను ప్రచురించింది. ఆ పేరులోనే భావన ఉంది: Multiplexed Information and Computing Service. ఇక్కడ Service అంటే గంటల ప్రాతిపదికన కొనుగోలు చేసే సేవ.

Multics అభివృద్ధి ప్రణాళిక కంటే చాలా ఎక్కువ సమయం తీసుకుంది. Prototype GE-645 యంత్రాలు 1967 జనవరిలో MIT మరియు Bell Labs కు చేరాయి. Bell Labs 1969 ఏప్రిల్‌లో ప్రాజెక్ట్ నుంచి వైదొలిగింది. Multics 1969 అక్టోబర్ 1న MIT Information Processing Center కస్టమర్లకు అందుబాటులోకి వచ్చింది. ఆ తర్వాత అది ఎక్కడో ఒకచోట productionలో ముప్పై ఒక్క సంవత్సరాలు నడిచింది. చివరి live Multics వ్యవస్థను Nova Scotiaలోని Halifaxలో ఉన్న Canadian Department of National Defence 2000 అక్టోబర్ 30న నిలిపివేసింది.

Multics ఆలస్యంగా వచ్చింది, నెమ్మదిగా నడిచింది కాబట్టి దాన్ని తరచుగా విఫలమైన ప్రాజెక్ట్‌గా పరిగణిస్తారు. అయితే దాని సాంకేతిక పదజాలం వేరే విషయాన్ని చెబుతుంది. directories లోపల directories ఉండే hierarchical file system, ప్రతి fileకు access control list, ఒక program fileను memoryలా address చేయడానికి అనుమతించిన segmented virtual memory, అలాగే codeకు ఉన్న trust స్థాయిని బట్టి దానికి ప్రాధాన్యత ఇచ్చే protection rings వంటి అంశాలను అది అందించింది. ఈ rings ఇప్పటికీ మీ ముందున్న siliconలో ఉన్నాయి. kernel కోసం ring 0, user code కోసం ring 3 అనే పదజాలం Multics నుంచే వచ్చింది. తరువాత hardware virtualisation, hypervisor కోసం ring 0 కంటే దిగువన మరో modeను జోడించింది. దాన్ని సాధారణంగా ring -1 అని పిలుస్తారు.

Unix: మీరు కొనగలిగే యంత్రంపై time-sharing

Multicsను విడిచిపెట్టిన తర్వాత Ken Thompson తాను ఉపయోగించాలనుకున్న system లేకుండా Bell Labsలో ఉన్నారు. 1969లో discarded PDP-7పై చాలా చిన్న systemను ప్రారంభించారు. మొదటి Unix Programmer's Manual తేదీ November 1971. అప్పటికి ఆ పని PDP-11కు మారింది. 1973లో Thompson మరియు Dennis Ritchie kernelను Cలో తిరిగి రాశారు. అందువల్ల systemను ప్రతి కొత్త hardware కోసం మళ్లీ చేతితో రాయాల్సిన అవసరం లేకుండా కొత్త hardwareకు మార్చవచ్చు.

అందుకే మీరు Multics వారసత్వంలో కాకుండా Unix వారసత్వంలోని systemలో type చేస్తున్నారు. Multicsకు Multics కోసం నిర్మించిన hardware అవసరమైంది. Unix చౌకగా మరియు అందుబాటులో ఉన్న ఏ hardwareపైనైనా నడిచింది. చివరికి నిర్ణయాత్మక లక్షణంగా మారింది ఇదే.

Ritchie మరియు Thompson రచించిన "The UNIX Time-Sharing System" July 1974లో Communications of the ACMలో ప్రచురితమైంది. ఆ paper మీ VPSను వివరిస్తుంది: processes, ఒక hierarchical file system, plain byte streamsగా files, fork, permission bitsతో users మరియు groups, అలాగే kernelలో భాగం కాకుండా ఒక సాధారణ programగా ఉండే shell. యాభై రెండు సంవత్సరాల తర్వాత కూడా ఆ interface విస్తరించబడుతూనే ఉంది; దాన్ని ఎప్పుడూ భర్తీ చేయలేదు.

1972లో mainframeలు నిజంగా virtual machines ను నడిపాయా?

అవును. చాలా మంది గమనించని విషయం ఇదే. MIT Multics ను నిర్మిస్తున్న సమయంలో IBM యొక్క Cambridge Scientific Center అదే లక్ష్యాన్ని మరో దిశ నుంచి సాధించడానికి ప్రయత్నించింది. అనేక మంది వినియోగదారులకు ఒకే operating system సేవలు అందించే బదులు, Robert Creasy మరియు Les Comeau ప్రతి వినియోగదారుడికి పూర్తి simulated computer ను అందించే control program ను నిర్మించారు. CP-40 జనవరి 1967లో production లోకి వచ్చింది. ప్రతి వినియోగదారుడికి virtual System/360 లభించేది. దాని లోపల చిన్న single-user operating system అయిన CMS నడిచేది.

1968లో System/360-67 కోసం CP-40, CP-67గా మారింది. IBM 2 August 1972న VM/370ను ప్రకటించింది. అంటే యాభై నాలుగు సంవత్సరాల క్రితం చెల్లింపు చేసే customerలకు విక్రయించిన commercial hypervisor అది. ఒక control program వాస్తవ hardware ను multiplex చేసేది. Guest operating systems ఎలాంటి మార్పులు లేకుండా virtual machines లో నడిచేవి. అవి ఆ machine తమదేనని భావించేవి.

దీనికి సంబంధించిన theory రెండు సంవత్సరాల తరువాత వచ్చింది. Unix paper ప్రచురించిన అదే July 1974 Communications of the ACM సంచికలో అది ప్రచురితమైంది. Gerald Popek మరియు Robert Goldberg రాసిన "Formal Requirements for Virtualizable Third Generation Architectures" అనే పత్రం processor virtualisable కావడానికి తప్పనిసరిగా ఏమి చేయాలో వివరించింది. ప్రాథమిక నియమం సంక్షిప్తంగా ఉంటుంది. Machine state ను చదవగలిగే లేదా మార్చగలిగే ప్రతి instruction ను guest kernel mode వెలుపల execute చేసినప్పుడు trap చేయాలి. అప్పుడు hypervisor control తీసుకుని, ఆ state యొక్క ఆ guest కు చెందిన private version తో సమాధానం ఇవ్వాలి. దీనిని trap and emulate అంటారు. IBM hardware ఈ నియమాన్ని పాటించింది.

మినీకంప్యూటర్ ఆ నమూనాను ఎందుకు మార్చింది

DEC సంస్థ PDP-8 ను 22 March 1965న 1965 నాటి డాలర్ల విలువ ప్రకారం సుమారు $18,000 ధరకు పరిచయం చేసింది. $20,000 కంటే తక్కువ ధర కలిగిన మొదటి minicomputer అదే. తరువాత అది 50,000 కంటే ఎక్కువ యూనిట్లు విక్రయించింది. ఆ తర్వాత microprocessor ధరను మరింత తగ్గించింది. ఒక department తనకంటూ ఒక machine కొనగలిగినప్పుడు, తరువాత ఒక వ్యక్తి కూడా అలాంటి machine కొనగలిగినప్పుడు, అందరూ ఒకే central computer ను పంచుకోవడం ఇక పరిష్కరించాల్సిన అవసరం లేని సమస్యగా కనిపించింది. 1980s మరియు 1990s కాలంలో computing desk‌లకు, తరువాత చిన్న x86 servers ఉన్న racks‌కు మారింది.

వనరుల వృథా వేరే రూపంలో తిరిగి వచ్చింది. ప్రతి server‌కు ఒక application మాత్రమే కేటాయించడం అర్థం చేసుకోవడానికి సులభం. కానీ దాంతో hardware లో ఎక్కువ భాగం idle‌గా ఉంటుంది, power మరియు rack space కోసం మాత్రం పూర్తి ఖర్చు చెల్లించాలి. ఇది మరో స్థాయిలో కనిపించిన అదే CTSS సమస్య. ఇప్పుడు ఖరీదైన వనరు processor కాదు; గది స్థలం మరియు విద్యుత్. పరిష్కారం కూడా పాతదే. machine‌ను పంచుకోవాలి.

x86 ను virtualise చేయడం ఎందుకు ఇంత కష్టంగా ఉండేది?

ఎందుకంటే x86, Popek మరియు Goldberg నియమాన్ని ఉల్లంఘించింది. ఆగస్టు 2000లో జరిగిన 9వ USENIX Security Symposiumలో John Scott Robin మరియు Cynthia Irvine, Pentium instruction set ను పరిశీలించి, user-mode code వాటిని అమలు చేసినప్పుడు fault ఇవ్వకుండానే privileged state ను చదివే లేదా మార్చే 17 instructions ఉన్నాయని గుర్తించారు. popf దీనికి ప్రామాణిక ఉదాహరణ. దీన్ని user modeలో అమలు చేస్తే, program set చేయడానికి అనుమతి లేని bits ను processor నిశ్శబ్దంగా పట్టించుకోదు; trap ఇవ్వదు. అందువల్ల trap-and-emulate పై ఆధారపడిన hypervisor, guest ఆ instruction ను ప్రయత్నించిందని తెలుసుకోలేడు.

Hardwareలో ఈ సమస్యను పరిష్కరించడానికి ముందు రెండు విధానాలు వచ్చాయి. 1998లో Stanfordకు చెందిన Disco research నుంచి ఏర్పడిన VMware, guest kernel code ను పరిశీలించి, సమస్య కలిగించే instructions అమలుకు ముందు వాటిని తిరిగి రాసేది. ఈ సాంకేతికతను binary translation అంటారు. University of Cambridge Computer Laboratoryకు చెందిన Xen మాత్రం guestనే మార్చింది. అక్టోబర్ 2003లో SOSPలో సమర్పించిన "Xen and the Art of Virtualization" పత్రం paravirtualisation ను వివరించింది. ఇందులో modified guest kernel, hypervisor intercept చేయలేని instructions ను అమలు చేయకుండా, ఉద్దేశపూర్వకంగా hypervisor ను call చేస్తుంది.

తరువాత IBM 1960లలో చేసిన విధంగానే hardwareలో ఈ సమస్యను పరిష్కరించారు. Intel, 14 November 2005న రెండు Pentium 4 modelsలో VT-x ను విడుదల చేసింది. AMD, May 2006లో AMD-V ను విడుదల చేసింది. రెండూ guest kernel కంటే దిగువ స్థాయిలో పనిచేసే processor mode ను జోడించాయి. అందువల్ల guest తన kernel ను పూర్తి వేగంతో అమలు చేసుకోగలదు. అదే సమయంలో hypervisor, తాను పర్యవేక్షించాల్సిన eventsపై నియంత్రణను కొనసాగిస్తుంది. దీని వల్ల సాధారణ operating systemలోనే ఉండగలంత చిన్న hypervisor సాధ్యమైంది. Avi Kivity రూపొందించిన Qumranetలోని KVM ఇదే చేసింది: Linux kernelనే hypervisorగా మార్చింది. KVM, February 2007లో విడుదలైన Linux 2.6.20లో చేర్చబడింది. నేడు VPS hostsలో పెద్ద భాగం ఉపయోగించేది ఇదే.

VPS కు ఆ పేరు ఎలా వచ్చింది

2000ల ప్రారంభంలో రెండు మార్గాలు కలిశాయి. ఒకటి x86 పై నడిచే పూర్తి virtual machine. అందులో guest తన స్వంత kernel ను boot చేస్తుంది. మరొకటి operating-system-level virtualisation. ఇందులో ఒకే shared Linux kernel ను ప్రత్యేక environments గా విభజిస్తారు. ప్రతి environment కు స్వంత root user మరియు స్వంత process table ఉంటాయి. Linux-VServer మరియు SWsoft's Virtuozzo రెండూ 2001లో కనిపించాయి. SWsoft, Virtuozzo లోని కొంత భాగాన్ని 2005లో open-source OpenVZ గా విడుదల చేసింది. "virtual private server" అనే పదబంధం ఈ వర్గం నుంచే వచ్చింది. ఇది virtual private network అనే పదానికి అనుసరణగా ఏర్పడింది.

Amazon, సర్వర్ అద్దెను API call గా మార్చింది. S3, 14 March 2006న ప్రారంభమైంది. EC2, 25 August 2006న పరిమిత public beta గా అందుబాటులోకి వచ్చింది. అది ఒకే instance type తో, Xen పై నడిచింది. Compute కొనుగోలు ఇక service bureau తో కుదుర్చుకునే ఒప్పందంగా ఉండలేదు. ఒక నిమిషంలో ఫలితాన్ని ఇచ్చే request గా మారింది.

ఈ రెండు మార్గాలు ఇప్పటికీ ఉన్నాయి. మీరు అద్దెకు తీసుకునే server తో ఏమి చేయగలరో ఈ విభజన ఇంకా నిర్ణయిస్తుంది. KVM VPS తన స్వంత kernel ను boot చేస్తుంది. అందువల్ల మీరు kernel modules ను load చేయవచ్చు. మీ VPS లోనే hypervisor ను కూడా నడపవచ్చు. Container-based plan, host kernel ను share చేస్తుంది. అందువల్ల అది చేయలేరు. Pricing page లోని ఆ ఒక్క పంక్తి వెనుక అరవై సంవత్సరాల చరిత్ర ఉంది. కాబట్టి ఒకదాన్ని ఎంచుకునే ముందు VPS, VM మరియు VPC ఎలా వేరు అవుతాయో అర్థం చేసుకోవడం ఉపయోగకరం.

mainframe నుంచి మీ VPS కు ఏమి మారింది, ఏమి మారలేదు

నాలుగు విషయాలు మారాయి. యంత్రం మీ భవనంలో లేదు. terminal furniture భాగం కాకుండా ఒక program అయింది. మీరు అద్దెకు తీసుకునే unit, మరొకరి operating system లోని account కాకుండా, తన స్వంత kernel కలిగిన పూర్తి computer. అలాగే ధర చాలా తగ్గింది; అందువల్ల కొనుగోలు procurement process కాకుండా card payment అయింది.

అయితే mechanism ఏమాత్రం మారలేదు.

• మీ ssh session ఒక time-sharing terminal. మీకు login మరియు shell లభిస్తాయి. తరువాత మీ process ఎప్పుడు run అవ్వాలో scheduler నిర్ణయిస్తుంది.
• Isolation ఇప్పటికీ hardware ద్వారా అమలవుతుంది. MMU మరియు processor యొక్క privilege levels ఆ పనిని చేస్తాయి. 1967లో CP-40 కు అవసరమైన విధంగానే ఇవి ఇప్పుడు కూడా పనిచేస్తాయి.
• Service bureaus connect hours కు bill చేసిన విధంగానే, మీరు ఇప్పటికీ ఒక machine లోని మీ share కు గడిచిన సమయం ఆధారంగా bill చెల్లిస్తారు.
• ఇతర tenants ప్రభావం మీకు ఇప్పటికీ తెలుస్తుంది. Host పై ఎక్కువ workloads ఉంటే, మీ guest physical CPU కోసం వేచి ఉంటుంది. Linux ఆ వేచిచూడటాన్ని శబ్దం చేసే పొరుగు tenant వల్ల కలిగే CPU steal timeగా report చేస్తుంది.

ఈ చివరి విషయం మొత్తం చరిత్రకు నిజాయితీగల సారాంశం. ఒక machine ను పంచుకోవడం ఒక trade-off. 1961లో computer ధర మనుషుల కంటే ఎక్కువగా ఉండటంతో దీనిని అంగీకరించారు. 2026లో server తన capacityలో పది శాతం మాత్రమే ఉపయోగిస్తే అది వృథా అయిన డబ్బు కాబట్టి దీనిని అంగీకరిస్తున్నారు. ఆ trade-off లో operator వైపు ఉండాలనుకుంటే, మీ సొంత hardware పై Proxmox నడపడం hypervisor ను, operator సమస్యలను రెండింటినీ మీకు అప్పగిస్తుంది.

ఈ నిష్పత్తిని గుర్తుంచుకోండి. లక్షల 1961 dollars ఖర్చైన, ఒక గదిని నింపిన machine పై CTSS నలుగురు users కు సేవలందించింది. 2026లో నెలకు కొన్ని dollars కు లభించే మీ VPS, Corbató బృందం భాగస్వామ్యం చేసుకోవాల్సిన computer కంటే చాలా మెరుగైన computer. అంతేకాదు, అది మీకోసమే ఉంటుంది. మీరు దాన్ని అద్దెకు తీసుకోగల కారణం, చివరకు చవకైన hardware తో కలిసిన అరవై ఐదు సంవత్సరాల క్రితం ప్రతిపాదించిన ఒక ఆలోచన. దానిపై ఏమి ఉంచాలో నిర్ణయిస్తున్నట్లయితే, ముందుగా VPS వాస్తవంగా మీకు ఏమి ఇస్తుందో చదవండి. తరువాత ప్రజలు VPS పై ఏమి నడుపుతారో చూడండి.

FAQ

మొదటి time-sharing computer system ఏది?

CTSS, అంటే Compatible Time-Sharing System, MIT Computation Center లో Fernando Corbató బృందం రూపొందించింది. ఇది మొదట November 1961లో IBM 709పై ప్రదర్శించబడింది. ఇందులో నలుగురు users కు సేవ అందించబడింది. ప్రతి user ను ప్రత్యేక tape drive కు swap out చేశారు. మొత్తం community కోసం అందించిన మొదటి time-sharing service Dartmouth Time-Sharing System. 1 May 1964న John Kemeny మరియు ఒక student programmer రెండు terminals పై ఒకేసారి BASIC programs నడిపారు. ఇద్దరికీ సరైన సమాధానాలు తిరిగి వచ్చాయి.

Virtual machines నిజంగానే 1960sలో కనిపెట్టబడ్డాయా?

అవును. IBM యొక్క Cambridge Scientific Center, January 1967లో CP-40ను productionలోకి తీసుకువచ్చింది. దీనివల్ల ప్రతి user కు CMS operating system నడిచే పూర్తి virtual System/360 అందింది. 1968లో System/360-67పై CP-67 వచ్చింది. IBM, 2 August 1972న VM/370ను ప్రకటించింది. ఇవి మార్పులు చేయని guest operating systems ను నడిపే నిజమైన hypervisors. ఇవి వాణిజ్యపరంగా విక్రయించబడ్డాయి. x86 hardware ఇదే పని చేయగలగడానికి దశాబ్దాల ముందే ఇవి అందుబాటులో ఉన్నాయి.

Mainframesకు virtualisation కష్టం కాకపోయినా x86కు ఎందుకు కష్టమైంది?

Popek మరియు Goldberg 1974లో ప్రతిపాదించిన నియమం ప్రకారం, machine stateను చదవగల లేదా మార్చగల ప్రతి instruction, guest దాన్ని kernel mode వెలుపల నడిపినప్పుడు trap కావాలి. x86 ఈ నియమాన్ని ఉల్లంఘించింది. Robin మరియు Irvine, Pentiumలో user modeలో trap కాకుండా మౌనంగా విఫలమయ్యే పదిహేడు instructionsను గుర్తించారు. అందువల్ల classic trap-and-emulate hypervisor వాటిని చూడలేదు. popf సాధారణ ఉదాహరణ. VMware దీనిని binary translationతో, Xen paravirtualisationతో పరిష్కరించాయి. తరువాత November 2005లో Intel VT-x, May 2006లో AMD-V hypervisor కోసం hardware modeను జోడించాయి.

VPSను అద్దెకు తీసుకోవడం time-sharing account కలిగి ఉండటంతో సమానమా?

Billing model మరియు isolation problem ఒకటే. కానీ unit వేరు. Time-sharing user, అందరితో పంచుకున్న operating systemలో ఒక account పొందేవాడు. అందువల్ల administrator computer centreలో పనిచేసే వ్యక్తి. KVM VPS మీకు మీ స్వంత kernel మరియు మీ స్వంత root account కలిగిన virtual machine ఇస్తుంది. అందువల్ల administrator మీరే. Container-based VPS ఈ రెండింటి మధ్య ఉంటుంది. ఇది host kernelను పంచుకుంటుంది, కానీ మీ స్వంత environmentలో root access ఇస్తుంది.