ฉันมักสับสนกับแนวคิดของการจำลองเสมือนในระบบปฏิบัติการ พิจารณา RAM เป็นหน่วยความจำกายภาพทำไมเราต้องใช้หน่วยความจำเสมือนในการดำเนินการกระบวนการ?
หน่วยความจำเสมือนนี้อยู่ที่ไหนเมื่อกระบวนการ (โปรแกรม) จากฮาร์ดไดรฟ์ภายนอกถูกนำไปยังหน่วยความจำหลัก (หน่วยความจำกายภาพ) เพื่อดำเนินการ
ใครดูแลหน่วยความจำเสมือนและขนาดของหน่วยความจำเสมือนคืออะไร?
สมมติว่าขนาดของ RAM คือ 4GB (เช่นช่องว่างที่อยู่ 2 ^ 32-1) ขนาดของหน่วยความจำเสมือนคืออะไร?
คำตอบ:
หน่วยความจำเสมือนเป็นสิ่งที่เป็นนามธรรมที่จะทำให้โปรแกรมเมอร์มองเห็นภาพลวงตาของการมีหน่วยความจำที่ไม่มีที่สิ้นสุดในระบบของตน
การแม็พหน่วยความจำเสมือนทำขึ้นเพื่อให้สอดคล้องกับที่อยู่จริงทางกายภาพ ระบบปฏิบัติการสร้างและเกี่ยวข้องกับการแมปเหล่านี้ - ใช้ตารางหน้าหมู่โครงสร้างข้อมูลอื่นเพิ่มเติมเพื่อรักษาแมป การแมปหน่วยความจำเสมือนมักพบในตารางเพจหรือโครงสร้างข้อมูลบางอย่างที่คล้ายกัน (ในกรณีของการใช้หน่วยความจำเสมือนอื่น ๆ เราอาจไม่ควรเรียกมันว่า "ตารางเพจ") ตารางเพจอยู่ในหน่วยความจำฟิสิคัลเช่นกันซึ่งมักอยู่ในพื้นที่สงวนเคอร์เนลซึ่งโปรแกรมของผู้ใช้ไม่สามารถเขียนทับได้
โดยทั่วไปหน่วยความจำเสมือนจะมีขนาดใหญ่กว่าหน่วยความจำฟิสิคัล - ไม่มีเหตุผลมากนักสำหรับการแมปหน่วยความจำเสมือนหากหน่วยความจำเสมือนและหน่วยความจำกายภาพมีขนาดเท่ากัน
เฉพาะส่วนที่จำเป็นของโปรแกรมเท่านั้นที่อยู่ในหน่วยความจำโดยทั่วไป - นี่คือหัวข้อที่เรียกว่า "การเพจ" หน่วยความจำเสมือนและการเพจเกี่ยวข้องกันอย่างแน่นหนา แต่ไม่ใช่หัวข้อเดียวกัน มีการใช้งานหน่วยความจำเสมือนอื่น ๆ เช่นการแบ่งส่วน
ฉันอาจจะคิดผิดที่นี่ แต่ฉันจะพนันได้เลยว่าสิ่งที่คุณพบยากที่จะห่อหัวของคุณเกี่ยวข้องกับการใช้งานหน่วยความจำเสมือนโดยเฉพาะซึ่งน่าจะเป็นการเพจ ไม่มีวิธีเดียวในการทำเพจ - มีการใช้งานจำนวนมากและแบบที่ตำราของคุณอธิบายนั้นอาจไม่เหมือนกับระบบปฏิบัติการจริงเช่น Linux / Windows ซึ่งอาจมีความแตกต่างเล็กน้อย
ฉันสามารถพูดได้หลายพันย่อหน้าเกี่ยวกับการเพจ ... แต่ฉันคิดว่าดีกว่าที่จะปล่อยให้คำถามอื่นที่กำหนดเป้าหมายหัวข้อนั้นโดยเฉพาะ
ซอฟต์แวร์ทำงานบนระบบปฏิบัติการบนพื้นฐานที่เรียบง่าย - พวกเขาต้องการหน่วยความจำ ระบบปฏิบัติการของอุปกรณ์จัดเตรียมไว้ในรูปแบบของ RAM จำนวนหน่วยความจำที่ต้องการอาจแตกต่างกันไป - บางโปรแกรมต้องการหน่วยความจำขนาดใหญ่บางโปรแกรมต้องการหน่วยความจำขนาดเล็ก ผู้ใช้ส่วนใหญ่ (ถ้าไม่ใช่ทั้งหมด) เรียกใช้หลายแอปพลิเคชันบนระบบปฏิบัติการพร้อมกันและเนื่องจากหน่วยความจำมีราคาแพง (และขนาดอุปกรณ์มี จำกัด ) จำนวนหน่วยความจำที่มีอยู่จึงมี จำกัด เสมอ ดังนั้นเนื่องจากซอฟต์แวร์ทั้งหมดต้องใช้ RAM จำนวนหนึ่งและทุกโปรแกรมสามารถทำงานได้ในเวลาเดียวกัน OS จึงต้องดูแลสองสิ่ง:
ตอนนี้คำถามหลักคือวิธีการจัดการหน่วยความจำ อะไรควบคุมว่าข้อมูลที่เป็นของซอฟต์แวร์ที่กำหนดจะอยู่ที่ใดในหน่วยความจำ
แนวทางแก้ไขที่เป็นไปได้ 1 : ให้แต่ละโปรแกรมระบุที่อยู่หน่วยความจำที่จะใช้ในอุปกรณ์อย่างชัดเจน สมมติว่าPhotoshopบอกว่ามันจะใช้ที่อยู่หน่วยความจำตั้งแต่
0การ1023(หน่วยความจำจินตนาการเป็น array เชิงเส้นของไบต์ไบต์แรกเพื่อให้เป็นที่สถานที่0,1024ไบต์วันที่สถานที่ตั้ง1023) - คือการครอบครอง1 GBของหน่วยความจำ ในทำนองเดียวกันVLCประกาศว่าจะใช้ช่วงหน่วยความจำ1244ถึง1876ฯลฯ
ข้อดี:
ข้อเสีย:
สิ่งนี้ไม่ได้ปรับขนาด ในทางทฤษฎีแอปอาจต้องใช้หน่วยความจำจำนวนมากเมื่อต้องทำสิ่งที่หนักมาก ดังนั้นเพื่อให้แน่ใจว่าหน่วยความจำจะไม่มีวันหมดพื้นที่หน่วยความจำที่จัดสรรให้จะต้องมากกว่าหรือเท่ากับจำนวนหน่วยความจำนั้นเสมอ จะเกิดอะไรขึ้นถ้าซอฟต์แวร์ที่มีการใช้หน่วยความจำตามทฤษฎีสูงสุด2 GB(ดังนั้นจึงต้องมีการ2 GBจัดสรรหน่วยความจำจาก RAM) ติดตั้งในเครื่องที่มี1 GBหน่วยความจำเพียงอย่างเดียว? ซอฟต์แวร์ควรยกเลิกเมื่อเริ่มต้นโดยบอกว่า RAM ที่มีอยู่น้อยกว่า2 GBหรือไม่? หรือควรดำเนินการต่อและในขณะที่หน่วยความจำเกินจำเป็น2 GBเพียงแค่ยกเลิกและประกันตัวโดยมีข้อความว่าหน่วยความจำไม่เพียงพอ?
ไม่สามารถป้องกันความจำสับสนได้ มีซอฟต์แวร์หลายล้านรายการแม้ว่าแต่ละโปรแกรมจะได้รับการจัดสรรเพียง1 kBหน่วยความจำแต่หน่วยความจำทั้งหมดที่ต้องการจะเกิน16 GBซึ่งมากกว่าที่อุปกรณ์ส่วนใหญ่เสนอ แล้วโปรแกรมต่างๆจะถูกจัดสรรสล็อตหน่วยความจำที่ไม่รุกล้ำพื้นที่ของกันและกันได้อย่างไร? ประการแรกไม่มีตลาดซอฟต์แวร์แบบรวมศูนย์ที่สามารถควบคุมได้ว่าเมื่อมีการเผยแพร่ซอฟต์แวร์ใหม่จะต้องกำหนดหน่วยความจำจำนวนมากนี้ให้กับตัวเองจากพื้นที่ที่ยังไม่ว่างนี้และประการที่สองแม้ว่าจะมี แต่ก็ไม่สามารถทำได้เนื่องจากไม่มี ของซอฟต์แวร์นั้นแทบไม่มีที่สิ้นสุด (ดังนั้นจึงต้องใช้หน่วยความจำที่ไม่มีที่สิ้นสุดเพื่อรองรับทั้งหมด) และ RAM ทั้งหมดที่มีอยู่ในอุปกรณ์ใด ๆ ก็ไม่เพียงพอที่จะรองรับแม้แต่เศษเสี้ยวของสิ่งที่จำเป็นจึงทำให้การรุกล้ำขอบเขตหน่วยความจำของซอฟต์แวร์หนึ่ง ๆ อย่างหลีกเลี่ยงไม่ได้ กับสิ่งอื่น แล้วจะเกิดอะไรขึ้นเมื่อPhotoshopถูกกำหนดตำแหน่งหน่วยความจำ1ให้1023และVLCถูกกำหนด1000ให้1676? เกิดอะไรขึ้นถ้าPhotoshopเก็บข้อมูลบางอย่างที่สถานที่1008แล้วVLCเขียนทับที่มีข้อมูลของตัวเองและต่อมาPhotoshopเข้าถึงโดยคิดว่าเป็นข้อมูลเดียวกันที่เก็บไว้ก่อนหน้านี้หรือไม่? อย่างที่คุณสามารถจินตนาการได้สิ่งเลวร้ายจะเกิดขึ้น
อย่างที่คุณเห็นชัดเจนว่าความคิดนี้ค่อนข้างไร้เดียงสา
แนวทางแก้ไขที่เป็นไปได้ 2 : ลองใช้รูปแบบอื่นโดยที่ OS จะจัดการหน่วยความจำส่วนใหญ่ ซอฟต์แวร์เมื่อใดก็ตามที่ต้องการหน่วยความจำใด ๆ ก็จะร้องขอระบบปฏิบัติการและระบบปฏิบัติการจะรองรับตามนั้น Say OS ช่วยให้มั่นใจได้ว่าเมื่อใดก็ตามที่กระบวนการใหม่ขอหน่วยความจำมันจะจัดสรรหน่วยความจำจากที่อยู่ไบต์ที่ต่ำที่สุดเท่าที่จะเป็นไปได้ (ดังที่กล่าวไว้ก่อนหน้านี้ RAM สามารถจินตนาการได้ว่าเป็นอาร์เรย์เชิงเส้นของไบต์ดังนั้นสำหรับ
4 GBRAM ช่วงแอดเดรสสำหรับ a ไบต์จาก0ถึง2^32-1) หากกระบวนการกำลังเริ่มต้นมิฉะนั้นหากเป็นกระบวนการที่กำลังดำเนินการร้องขอหน่วยความจำกระบวนการนั้นจะจัดสรรจากตำแหน่งหน่วยความจำสุดท้ายที่กระบวนการนั้นยังคงอยู่ เนื่องจากซอฟต์แวร์จะเปล่งที่อยู่โดยไม่พิจารณาว่าที่อยู่หน่วยความจำจริงจะอยู่ที่ใดที่จัดเก็บข้อมูลนั้นระบบปฏิบัติการจะต้องรักษาการทำแผนที่ตามซอฟต์แวร์ของที่อยู่ที่ซอฟต์แวร์ปล่อยไปยังที่อยู่จริงจริง (หมายเหตุ: นั่นเป็นหนึ่งในสองเหตุผลที่เราเรียกแนวคิดนี้Virtual Memoryว่าซอฟต์แวร์ไม่สนใจเกี่ยวกับที่อยู่หน่วยความจำจริงที่ข้อมูลของพวกเขาถูกจัดเก็บพวกเขาเพียงแค่คายที่อยู่ออกมาทันทีและระบบปฏิบัติการจะหาสถานที่ที่เหมาะสมเพื่อให้พอดีและพบ ในภายหลังหากจำเป็น)
บอกว่าอุปกรณ์ที่ได้รับเพียงแค่เปิดระบบปฏิบัติการได้เปิดตัวเพียงตอนนี้ไม่มีกระบวนการอื่น ๆ ที่ทำงาน (ละเว้น OS ซึ่งยังเป็นกระบวนการ!) และคุณตัดสินใจที่จะเปิดตัวVLC ดังนั้นVLCจึงถูกจัดสรรส่วนหนึ่งของ RAM จากที่อยู่ไบต์ต่ำสุด ดี. ขณะที่วิดีโอกำลังทำงานคุณต้องเริ่มเบราว์เซอร์เพื่อดูหน้าเว็บบางหน้า จากนั้นคุณต้องเปิดNotepadเพื่อเขียนข้อความ จากนั้นEclipseจะทำการเข้ารหัส .. ในไม่ช้าหน่วยความจำของคุณ4 GBก็ถูกใช้จนหมดและ RAM มีลักษณะดังนี้:
ปัญหาที่ 1: ตอนนี้คุณไม่สามารถเริ่มกระบวนการอื่นได้เนื่องจาก RAM ทั้งหมดจะถูกใช้จนหมด ดังนั้นจึงต้องเขียนโปรแกรมโดยคำนึงถึงหน่วยความจำสูงสุดที่มีอยู่ในใจ (แม้จะมีน้อยกว่านี้ก็ตามเนื่องจากโปรแกรมอื่น ๆ จะทำงานแบบขนานเช่นกัน!) กล่าวอีกนัยหนึ่งคุณไม่สามารถเรียกใช้แอพที่ใช้หน่วยความจำสูงใน
1 GBพีซีramshackle ของคุณ
เอาล่ะตอนนี้คุณตัดสินใจว่าคุณไม่จำเป็นต้องเปิดEclipseและChromeอีกต่อไปคุณปิดมันเพื่อเพิ่มหน่วยความจำ พื้นที่ที่ถูกครอบครองใน RAM โดยกระบวนการเหล่านั้นจะถูกเรียกคืนโดย OS และตอนนี้ดูเหมือนว่า:
สมมติว่าการปิดทั้งสองนี้จะทำให้มี700 MBพื้นที่ว่าง - ( 400+ 300) MB ตอนนี้คุณต้องเปิดOperaซึ่งจะใช้450 MBพื้นที่ คุณมี450 MBพื้นที่ว่างมากกว่าที่มีอยู่ทั้งหมด แต่ ... มันไม่ได้ติดกันแบ่งออกเป็นแต่ละชิ้นไม่มีสิ่งใดใหญ่พอที่จะใส่450 MBได้ ดังนั้นคุณจึงได้ไอเดียที่ยอดเยี่ยมลองย้ายกระบวนการทั้งหมดด้านล่างไปด้านบนให้มากที่สุดซึ่งจะทำให้เหลือ700 MBพื้นที่ว่างเป็นชิ้นเดียวที่ด้านล่าง นี้เรียกว่าcompaction. เยี่ยมมากยกเว้นว่า ... กระบวนการทั้งหมดที่กำลังดำเนินอยู่ การย้ายจะหมายถึงการย้ายที่อยู่ของเนื้อหาทั้งหมด (โปรดจำไว้ว่า OS จะรักษาการแมปของหน่วยความจำที่พ่นออกมาโดยซอฟต์แวร์ไปยังที่อยู่หน่วยความจำจริงซอฟต์แวร์ Imagine ได้พ่นที่อยู่ที่45มีข้อมูลออก123มาและระบบปฏิบัติการได้จัดเก็บไว้ในตำแหน่ง2012และสร้างรายการในแผนที่การทำแผนที่45เพื่อ2012. หากซอฟต์แวร์ที่ถูกย้ายในขณะนี้หน่วยความจำในสิ่งที่เคยเป็นที่ตั้ง2012จะไม่เป็นที่2012แต่ในสถานที่ใหม่และระบบปฏิบัติการที่มีการอัปเดตแผนที่ตามแผนที่45ไป ที่อยู่ใหม่เพื่อให้ซอฟต์แวร์ได้รับข้อมูลที่คาดหวัง ( 123) เมื่อค้นหาตำแหน่งหน่วยความจำ45เท่าที่ซอฟต์แวร์เกี่ยวข้องสิ่งที่รู้ก็คือที่อยู่นั้น45มีข้อมูล123!)! iลองนึกภาพกระบวนการที่มีการอ้างอิงตัวแปรท้องถิ่น เมื่อมีการเข้าถึงอีกครั้งที่อยู่ของมันก็เปลี่ยนไปและจะไม่สามารถค้นหาได้อีก สิ่งเดียวกันนี้จะถือไว้สำหรับฟังก์ชันวัตถุตัวแปรโดยทั่วไปทุกอย่างมีที่อยู่และการย้ายกระบวนการจะหมายถึงการเปลี่ยนที่อยู่ของทั้งหมด ซึ่งนำเราไปสู่:
ปัญหาที่ 2: คุณไม่สามารถย้ายกระบวนการได้ ค่าของตัวแปรฟังก์ชันและอ็อบเจ็กต์ทั้งหมดภายในกระบวนการนั้นมีค่าฮาร์ดโค้ดตามที่คอมไพเลอร์ spat ออกมาในระหว่างการคอมไพล์กระบวนการขึ้นอยู่กับค่าเหล่านั้นว่าอยู่ในตำแหน่งเดียวกันตลอดอายุการใช้งานและการเปลี่ยนแปลงมีราคาแพง ด้วยเหตุนี้กระบวนการจะทิ้ง "" ขนาดใหญ่ไว้เบื้องหลัง
holesเมื่อออกจากกระบวนการ นี้เรียกว่าExternal Fragmentation.
ละเอียด. สมมติว่าคุณสามารถเลื่อนกระบวนการขึ้นมาได้อย่างน่าอัศจรรย์ ตอนนี้มี700 MBพื้นที่ว่างที่ด้านล่าง:
Operaพอดีกับด้านล่างอย่างราบรื่น ตอนนี้ RAM ของคุณมีลักษณะดังนี้:
ดี. ทุกอย่างดูดี อย่างไรก็ตามมีพื้นที่เหลือไม่มากและตอนนี้คุณต้องเปิดChromeอีกครั้งซึ่งเป็นหน่วยความจำที่รู้จักกันดี! ต้องใช้หน่วยความจำจำนวนมากในการเริ่มต้นและคุณแทบจะไม่เหลือเลย ... ยกเว้นตอนนี้คุณสังเกตเห็นว่ากระบวนการบางอย่างซึ่งตอนแรกใช้พื้นที่ขนาดใหญ่ตอนนี้ไม่ต้องการพื้นที่มากนัก อาจเป็นเพราะคุณหยุดวิดีโอของคุณในVLCแล้วดังนั้นจึงยังคงใช้พื้นที่อยู่บ้าง แต่ไม่มากเท่าที่ต้องการในขณะที่เรียกใช้วิดีโอความละเอียดสูง ในทำนองเดียวกันสำหรับNotepadและภาพถ่าย แรมของคุณมีลักษณะดังนี้:
Holesอีกครั้ง! กลับไปที่ตารางที่หนึ่ง! ยกเว้นก่อนหน้านี้หลุมเกิดขึ้นเนื่องจากกระบวนการยุติขณะนี้เกิดจากกระบวนการที่ต้องการพื้นที่น้อยกว่าเดิม! และคุณมีปัญหาเดียวกันอีกครั้งคือการholesรวมกันให้พื้นที่มากกว่าที่ต้องการ แต่มันกระจัดกระจายไปทั่วไม่ได้ใช้ประโยชน์มากนักในการแยก ดังนั้นคุณต้องย้ายกระบวนการเหล่านั้นอีกครั้งเป็นการดำเนินการที่มีราคาแพงและเป็นกระบวนการที่เกิดขึ้นบ่อยมากเนื่องจากกระบวนการต่างๆมักจะลดขนาดลงตลอดอายุการใช้งาน
ปัญหาที่ 3: กระบวนการตลอดอายุการใช้งานอาจลดขนาดลงทำให้เหลือพื้นที่ว่างที่ไม่ได้ใช้ซึ่งหากจำเป็นต้องใช้จะต้องใช้การดำเนินการที่มีราคาแพงในการเคลื่อนย้ายหลายกระบวนการ นี้เรียกว่า
Internal Fragmentation.
ดีตอนนี้ระบบปฏิบัติการของคุณทำสิ่งที่จำเป็นย้ายกระบวนการไปรอบ ๆ และเริ่มChromeและหลังจากนั้นสักครู่ RAM ของคุณจะมีลักษณะดังนี้:
เย็น. ตอนนี้สมมติว่าคุณกลับมาดูAvatarในVLCอีกครั้ง ความต้องการหน่วยความจำจะเพิ่มขึ้น! แต่ ... ไม่มีพื้นที่เหลือให้มันเติบโตเนื่องจากNotepadถูกแนบอยู่ที่ด้านล่าง ดังนั้นอีกครั้งกระบวนการทั้งหมดต้องเลื่อนไปด้านล่างจนกว่าVLCจะพบพื้นที่เพียงพอ!
ปัญหาที่ 4: หากกระบวนการต้องเติบโตมันจะเป็นการดำเนินการที่มีราคาแพงมาก
ละเอียด. สมมติว่ามีการใช้Photosเพื่อโหลดรูปภาพจากฮาร์ดดิสก์ภายนอก การเข้าถึงฮาร์ดดิสก์จะนำคุณจากขอบเขตของแคชและ RAM ไปยังดิสก์ซึ่งจะช้าลงตามลำดับขนาด เจ็บปวดอย่างไม่อาจเพิกถอนได้ช้าลงอย่างเหนือชั้น เป็นการดำเนินการ I / O ซึ่งหมายความว่าไม่ได้ผูกกับ CPU (ค่อนข้างตรงกันข้าม) ซึ่งหมายความว่าตอนนี้ไม่จำเป็นต้องครอบครอง RAM อย่างไรก็ตามมันยังคงใช้ RAM อย่างดื้อรั้น หากคุณต้องการเปิดFirefoxในระหว่างนี้คุณไม่สามารถทำได้เนื่องจากมีหน่วยความจำไม่มากนักในขณะที่รูปภาพถูกนำออกจากหน่วยความจำในช่วงระยะเวลาของกิจกรรมที่ถูกผูกไว้กับ I / O จะทำให้หน่วยความจำมีอิสระมากขึ้น ตามด้วยการบดอัด (ราคาแพง) ตามด้วยFirefox ที่เหมาะสม
ปัญหาที่ 5: งานที่ถูกผูกไว้ของ I / O ยังคงใช้ RAM อยู่ซึ่งนำไปสู่การใช้ RAM น้อยเกินไปซึ่งอาจถูกใช้โดยงานที่เชื่อมต่อกับ CPU ในระหว่างนี้
อย่างที่เราเห็นเรามีปัญหามากมายแม้จะใช้หน่วยความจำเสมือนก็ตาม
มีสองวิธีที่จะรับมือกับปัญหาเหล่านี้ - และpaging ให้เราคุยsegmentation pagingในวิธีการนี้พื้นที่ที่อยู่เสมือนของกระบวนการถูกแมปไปหน่วยความจำทางกายภาพในชิ้น - pagesเรียกว่า pageขนาดโดยทั่วไปคือ4 kB. การทำแผนที่ได้รับการดูแลโดยสิ่งที่เรียกว่า a page tableกำหนดที่อยู่เสมือนสิ่งที่เราต้องทำคือค้นหาว่าที่pageอยู่นั้นเป็นของใดจากนั้นpage tableค้นหาตำแหน่งที่เกี่ยวข้องสำหรับสิ่งนั้นpageในหน่วยความจำกายภาพจริง (เรียกว่าframe) และกำหนดให้ ว่าออฟเซ็ตของที่อยู่เสมือนภายในpageนั้นเหมือนกันสำหรับที่อยู่pageเช่นเดียวกับframeค้นหาที่อยู่จริงโดยการเพิ่มออฟเซ็ตนั้นไปยังที่อยู่ที่ส่งคืนโดยไฟล์page table. ตัวอย่างเช่น:
ทางด้านซ้ายคือพื้นที่แอดเดรสเสมือนของกระบวนการ สมมติว่าพื้นที่ที่อยู่เสมือนต้องใช้หน่วยความจำ 40 หน่วย หากพื้นที่ที่อยู่ทางกายภาพ (ทางด้านขวา) มีหน่วยความจำ 40 หน่วยเช่นกันอาจเป็นไปได้ที่จะจับคู่ตำแหน่งทั้งหมดจากทางซ้ายไปยังตำแหน่งทางขวาและเราจะมีความสุขมาก แต่โชคไม่ดีที่จะมีหน่วยความจำกายภาพไม่เพียง แต่มีหน่วยความจำน้อยกว่า (24 ที่นี่) เท่านั้น แต่ยังต้องใช้ร่วมกันระหว่างหลายกระบวนการด้วย! มาดูกันว่าเราจะทำอย่างไรกับมัน
เมื่อขั้นตอนการเริ่มต้นพูดคำขอเข้าถึงหน่วยความจำสำหรับสถานที่35จะทำ ที่นี่ขนาดหน้าคือ8(แต่ละแห่งpageมี8ตำแหน่งพื้นที่ที่อยู่เสมือนทั้งหมดของ40สถานที่จึงประกอบด้วย5หน้า) ดังนั้นตำแหน่งนี้จึงเป็นของหมายเลขหน้า 4( 35/8). ภายในpageตำแหน่งนี้มีค่าชดเชยเป็น3( 35%8) ดังนั้นสถานที่แห่งนี้สามารถระบุได้โดย tuple =(pageIndex, offset) (4,3)นี่เป็นเพียงการเริ่มต้นดังนั้นจึงยังไม่มีการจัดเก็บส่วนใดของกระบวนการไว้ในหน่วยความจำกายภาพจริง ดังนั้นpage tableซึ่งจะรักษาการแมปของเพจทางด้านซ้ายไปยังเพจจริงทางด้านขวา (ซึ่งเรียกว่าframes) ว่างเปล่า ดังนั้น OS จึงยกเลิกการใช้งาน CPU ช่วยให้ไดรเวอร์อุปกรณ์เข้าถึงดิสก์และดึงข้อมูลหมายเลขหน้า 4สำหรับกระบวนการนี้ (โดยทั่วไปจะเป็นหน่วยความจำจากโปรแกรมบนดิสก์ซึ่งมีที่อยู่ตั้งแต่32ถึง39) เมื่อมาถึงระบบปฏิบัติการจะจัดสรรเพจไว้ที่ใดที่หนึ่งใน RAM พูดว่าเฟรมแรกนั้นเองและpage tableสำหรับกระบวนการนี้จะสังเกตว่าเพจ4แมปไปยังเฟรม0ในแรม ในที่สุดข้อมูลก็อยู่ในหน่วยความจำกายภาพแล้ว ระบบปฏิบัติการจะค้นหาตารางเพจสำหรับทูเปิลอีกครั้ง(4,3)และคราวนี้ตารางเพจแจ้งว่าเพจ4ถูกแมปกับเฟรม0ในแรมแล้ว ดังนั้น OS จึงไปที่0เฟรม th ใน RAM เข้าถึงข้อมูลที่ออฟเซ็ต3ในเฟรมนั้น (ใช้เวลาสักครู่เพื่อทำความเข้าใจสิ่งนี้pageframeซึ่งเป็นความจริงจากดิสก์จะถูกย้ายไป ดังนั้นไม่ว่าค่าชดเชยของตำแหน่งหน่วยความจำแต่ละตำแหน่งในเพจจะเป็นอย่างไรมันก็จะเหมือนกันในเฟรมเช่นกันเนื่องจากภายในpage/ frameหน่วยความจำยังคงอยู่ที่เดิมค่อนข้าง!) และส่งคืนข้อมูล! เนื่องจากข้อมูลไม่พบในหน่วยความจำแบบสอบถามแรกของตัวเอง แต่จะต้องมีการดึงข้อมูลจากดิสก์ที่จะโหลดลงในหน่วยความจำก็ถือว่าพลาด
ละเอียด. ตอนนี้คิดว่าเข้าถึงหน่วยความจำสำหรับสถานที่28จะทำ มันเดือดถึง(3,4). Page tableในขณะนี้มีเพียงหนึ่งรายการ, หน้าทำแผนที่กรอบ4 0ดังนั้นนี่จึงเป็นอีกครั้งที่พลาดกระบวนการปล่อย CPU ใหม่ไดรเวอร์อุปกรณ์ดึงหน้าจากดิสก์กระบวนการกลับมาควบคุม CPU อีกครั้งและpage tableอัปเดตแล้ว สมมติว่าเพจ3ถูกจับคู่กับเฟรม1ใน RAM แล้ว ดังนั้น(3,4)จะกลายเป็น(1,4)และข้อมูลสถานที่ใน RAM ที่จะถูกส่งกลับ ดี. ด้วยวิธีนี้สมมติว่าการเข้าถึงหน่วยความจำถัดไปคือตำแหน่ง8ซึ่งแปล(1,0)ว่า เพจ1ยังไม่อยู่ในหน่วยความจำทำซ้ำขั้นตอนเดียวกันและpageจัดสรรที่เฟรม2ใน RAM ตอนนี้การแมปกระบวนการ RAM ดูเหมือนภาพด้านบน ณ เวลานี้แรมซึ่งมีหน่วยความจำเพียง 24 หน่วยเท่านั้นที่มีอยู่เต็มไปหมด 30สมมติว่าการร้องขอการเข้าถึงหน่วยความจำต่อไปสำหรับกระบวนการนี้ก็คือจากที่อยู่ มันแมปไป(3,6)และpage tableบอกว่าหน้าเว็บที่3อยู่ใน RAM 1และแผนที่กรอบ เย้! ดังนั้นข้อมูลจึงถูกดึงมาจากตำแหน่ง RAM (1,6)และส่งคืน สิ่งนี้ถือเป็นการตีเนื่องจากข้อมูลที่ต้องการสามารถรับได้โดยตรงจาก RAM ดังนั้นจึงรวดเร็วมาก ในทำนองเดียวกันการร้องขอการเข้าถึงสามต่อไปกล่าวว่าสำหรับสถานที่11, 32, 26, 27ทั้งหมดที่มีเพลงฮิตคือข้อมูลที่ร้องขอโดยกระบวนการที่พบโดยตรงในแรมโดยไม่จำเป็นต้องมองหาที่อื่น
ตอนนี้สมมติว่าคำขอเข้าถึงหน่วยความจำสำหรับตำแหน่ง3มา มันแปลไป(0,3)และpage tableสำหรับกระบวนการนี้ซึ่งขณะนี้มี 3 รายการสำหรับหน้า1, 3และ4บอกว่าหน้านี้ไม่ได้อยู่ในหน่วยความจำ เช่นเดียวกับกรณีก่อนหน้านี้เรียกข้อมูลจากดิสก์อย่างไรก็ตามไม่เหมือนกับกรณีก่อนหน้านี้คือ RAM เต็ม! แล้วจะทำยังไงดีล่ะ? นี่คือความสวยงามของหน่วยความจำเสมือนเฟรมจาก RAM ถูกขับออกไป! (ปัจจัยต่างๆควบคุมว่าเฟรมใดจะถูกขับออกไปอาจเป็นไปLRUตามที่เฟรมซึ่งถูกเข้าถึงน้อยที่สุดสำหรับกระบวนการจะถูกขับออกไปอาจเป็นfirst-come-first-evictedพื้นฐานที่เฟรมที่จัดสรรเวลานานที่สุดที่ผ่านมาถูกขับออกเป็นต้น .) ดังนั้นเฟรมบางส่วนจึงถูกขับออกไป พูดกรอบที่ 1 (เพียงแค่สุ่มเลือก) อย่างไรก็ตามframeมีการจับคู่กับบางส่วนpage! (ปัจจุบันมีการแมปโดยตารางหน้าไปยังหน้า3ของกระบวนการเดียวของเรา) ดังนั้นกระบวนการที่จะต้องมีการบอกข่าวเศร้านี้ที่หนึ่งframeซึ่งโชคร้ายเป็นของคุณที่จะถูกขับไล่ออกจาก RAM pagesไปที่ห้องทำอีก กระบวนการนี้ต้องตรวจสอบให้แน่ใจว่าได้อัปเดตpage tableด้วยข้อมูลนี้นั่นคือการลบรายการสำหรับคู่ของเฟรมหน้านั้นออกเพื่อให้ในครั้งต่อไปที่มีการร้องขอสิ่งpageนั้นกระบวนการนี้pageจะบอกกระบวนการว่าสิ่งนี้ไม่อยู่ในหน่วยความจำอีกต่อไป และต้องดึงข้อมูลจากดิสก์ ดี. ดังนั้นเฟรม1จะถูกขับออกไปเพจ0จะถูกนำเข้าและวางไว้ที่นั่นใน RAM และรายการสำหรับเพจ3จะถูกลบออกและแทนที่ด้วย0การแมปเพจไปยังเฟรมเดียวกัน1. ตอนนี้การทำแผนที่ของเรามีลักษณะเช่นนี้ (สังเกตการเปลี่ยนสีในวินาทีframeทางด้านขวา):
เห็นสิ่งที่เพิ่งเกิดขึ้น? กระบวนการนี้ต้องเติบโตขึ้นต้องใช้พื้นที่มากกว่า RAM ที่มีอยู่ แต่ไม่เหมือนกับสถานการณ์ก่อนหน้านี้ที่ทุกกระบวนการใน RAM ต้องย้ายเพื่อรองรับกระบวนการที่กำลังเติบโตที่นี่มันเกิดขึ้นโดยการpageเปลี่ยนเพียงครั้งเดียว! สิ่งนี้เกิดขึ้นได้จากข้อเท็จจริงที่ว่าหน่วยความจำสำหรับกระบวนการไม่จำเป็นต้องอยู่ติดกันอีกต่อไปมันสามารถอยู่ในที่ต่างๆเป็นชิ้น ๆ OS จะเก็บรักษาข้อมูลว่าอยู่ที่ไหนและเมื่อจำเป็นก็จะถูกสอบถามอย่างเหมาะสม หมายเหตุ: คุณอาจกำลังคิดว่าถ้าส่วนใหญ่เป็น a missและต้องโหลดข้อมูลจากดิสก์ลงในหน่วยความจำอยู่ตลอดเวลา? ใช่ในทางทฤษฎีเป็นไปได้ แต่คอมไพเลอร์ส่วนใหญ่ได้รับการออกแบบในลักษณะที่ตามมาlocality of referenceเช่นถ้าข้อมูลจากสถานที่ตั้งของหน่วยความจำบางจะใช้ข้อมูลต่อไปจำเป็นจะตั้งอยู่ที่ไหนสักแห่งใกล้มากอาจจากเดียวกันpageที่pageซึ่งเต็มไปเพียงแค่เข้าไปในหน่วยความจำ ด้วยเหตุนี้การพลาดครั้งต่อไปจะเกิดขึ้นหลังจากผ่านไประยะหนึ่งความต้องการหน่วยความจำที่กำลังจะมาถึงส่วนใหญ่จะเป็นไปตามหน้าที่เพิ่งเข้ามาหรือหน้าที่อยู่ในหน่วยความจำซึ่งเพิ่งใช้งานล่าสุด หลักการเดียวกันนี้ช่วยให้เราสามารถขับไล่สิ่งที่เพิ่งใช้น้อยที่สุดได้pageเช่นกันโดยมีตรรกะที่ว่าสิ่งที่ไม่ได้ถูกใช้มาระยะหนึ่งก็ไม่น่าจะใช้ได้ในระยะหนึ่งเช่นกัน อย่างไรก็ตามมันไม่ได้เป็นเช่นนั้นเสมอไปและในกรณีพิเศษใช่ประสิทธิภาพอาจได้รับผลกระทบ เพิ่มเติมเกี่ยวกับเรื่องนี้ในภายหลัง
แนวทางแก้ไขปัญหาที่ 4: ตอนนี้กระบวนการสามารถเติบโตได้อย่างง่ายดายหากประสบปัญหาพื้นที่สิ่งที่ต้องมีก็คือการ
pageเปลี่ยนแบบง่ายๆโดยไม่ต้องย้ายกระบวนการอื่นใด
แนวทางแก้ไขปัญหาที่ 1: กระบวนการสามารถเข้าถึงหน่วยความจำได้ไม่ จำกัด เมื่อต้องการหน่วยความจำมากกว่าที่มีอยู่ดิสก์จะถูกใช้เป็นข้อมูลสำรองข้อมูลใหม่ที่ต้องการจะถูกโหลดลงในหน่วยความจำจากดิสก์และข้อมูลที่ใช้ล่าสุด
frame(หรือpage) จะถูกย้ายไปยังดิสก์ สิ่งนี้สามารถดำเนินต่อไปได้อย่างไม่มีที่สิ้นสุดและเนื่องจากพื้นที่ดิสก์มีราคาถูกและแทบไม่ จำกัด จึงทำให้เกิดภาพลวงตาของหน่วยความจำที่ไม่ จำกัด อีกเหตุผลหนึ่งของชื่อVirtual Memoryมันทำให้คุณมีภาพลวงตาของความทรงจำที่ไม่มีอยู่จริง!
เย็น. ก่อนหน้านี้เราประสบปัญหาที่แม้ว่ากระบวนการจะลดขนาดลง แต่พื้นที่ว่างนั้นยากที่จะเรียกคืนโดยกระบวนการอื่น ๆ (เนื่องจากจะต้องมีการบดอัดที่มีค่าใช้จ่ายสูง) ตอนนี้เป็นเรื่องง่ายเมื่อกระบวนการมีขนาดเล็กลงหลาย ๆ กระบวนการpagesจะไม่ถูกใช้อีกต่อไปดังนั้นเมื่อกระบวนการอื่น ๆ ต้องการหน่วยความจำมากขึ้นการLRUขับไล่แบบง่าย ๆจะขับไล่สิ่งที่ใช้น้อยpagesออกจาก RAM โดยอัตโนมัติและแทนที่ด้วยหน้าใหม่จาก กระบวนการอื่น ๆ (และแน่นอนว่าการอัปเดตpage tablesกระบวนการเหล่านั้นทั้งหมดรวมถึงกระบวนการดั้งเดิมซึ่งตอนนี้ต้องใช้พื้นที่น้อยลง) ทั้งหมดนี้ไม่มีการดำเนินการบดอัดที่มีราคาแพง!
วิธีการแก้ปัญหา 3: เมื่อใดก็ตามกระบวนการลดขนาดของ
framesแรมจะถูกใช้น้อยลงเพื่อให้ง่ายLRUขับไล่ตามสามารถขับไล่หน้าเว็บเหล่านั้นออกไปและแทนที่ด้วยpagesต้องตามกระบวนการใหม่จึงหลีกเลี่ยงโดยไม่จำเป็นต้องInternal Fragmentationcompaction
สำหรับปัญหาที่ 2 โปรดใช้เวลาสักครู่เพื่อทำความเข้าใจสถานการณ์นี้จะถูกลบออกโดยสิ้นเชิง! ไม่จำเป็นต้องย้ายกระบวนการเพื่อรองรับกระบวนการใหม่เนื่องจากตอนนี้กระบวนการทั้งหมดไม่จำเป็นต้องพอดีในครั้งเดียวมีเพียงบางหน้าเท่านั้นที่ต้องพอดีกับเฉพาะกิจซึ่งเกิดขึ้นโดยการขับframesออกจาก RAM ทุกอย่างเกิดขึ้นในหน่วยpagesดังนั้นจึงไม่มีแนวคิดในholeตอนนี้และด้วยเหตุนี้จึงไม่มีคำถามว่ามีอะไรเคลื่อนไหว! อาจต้องpagesย้าย10 คนเนื่องจากข้อกำหนดใหม่นี้มีหลายพันรายการpagesที่ไม่ถูกแตะต้อง ในขณะที่ก่อนหน้านี้กระบวนการทั้งหมด (ทุกบิต) ต้องถูกย้าย!
วิธีการแก้ปัญหาที่ 2: เพื่อรองรับกระบวนการใหม่ข้อมูลจากชิ้นส่วนที่ใช้เพียงน้อยเมื่อเร็ว ๆ นี้ของกระบวนการอื่น ๆ
pagesจะต้องมีการขับไล่ตามความจำเป็นและนี้เกิดขึ้นในหน่วยขนาดคงที่เรียกว่า ดังนั้นจึงไม่มีความเป็นไปได้holeหรือExternal Fragmentationกับระบบนี้
ตอนนี้เมื่อกระบวนการต้องดำเนินการ I / O บางอย่างก็สามารถยกเลิก CPU ได้อย่างง่ายดาย! ระบบปฏิบัติการเพียงแค่ขับไล่ทั้งหมดpagesออกจาก RAM (อาจเก็บไว้ในแคช) ในขณะที่กระบวนการใหม่จะใช้ RAM ในระหว่างนี้ เมื่อการดำเนินการ I / O เสร็จสิ้น OS ก็จะคืนค่าเหล่านั้นpagesไปยัง RAM (แน่นอนโดยการแทนที่pagesจากกระบวนการอื่น ๆ อาจมาจากกระบวนการที่มาแทนที่กระบวนการเดิมหรืออาจมาจากบางกระบวนการที่ต้องทำ I / โอตอนนี้และด้วยเหตุนี้จึงสามารถสละความทรงจำได้!)
แนวทางแก้ไขปัญหาที่ 5: เมื่อกระบวนการดำเนินการ I / O กระบวนการนั้นสามารถยกเลิกการใช้ RAM ได้อย่างง่ายดายซึ่งกระบวนการอื่น ๆ สามารถนำไปใช้ประโยชน์ได้ สิ่งนี้นำไปสู่การใช้ RAM อย่างเหมาะสม
และแน่นอนว่าตอนนี้ไม่มีกระบวนการใดที่เข้าถึง RAM โดยตรง แต่ละกระบวนการกำลังเข้าถึงตำแหน่งหน่วยความจำเสมือนซึ่งแมปกับที่อยู่ RAM จริงและดูแลโดยpage-tableกระบวนการนั้น การทำแผนที่ได้รับการสนับสนุนจาก OS ระบบปฏิบัติการช่วยให้กระบวนการทราบว่าเฟรมใดว่างเพื่อให้สามารถติดตั้งหน้าใหม่สำหรับกระบวนการได้ เนื่องจากการจัดสรรหน่วยความจำนี้ได้รับการดูแลโดยระบบปฏิบัติการเองจึงสามารถมั่นใจได้ว่าจะไม่มีกระบวนการใดรุกล้ำเข้าไปในเนื้อหาของกระบวนการอื่นโดยการจัดสรรเฉพาะเฟรมว่างจาก RAM หรือเมื่อรุกล้ำเข้าไปในเนื้อหาของกระบวนการอื่นใน RAM จึงสื่อสารกับกระบวนการได้ page-tableเพื่ออัปเดต
แนวทางแก้ไขปัญหาดั้งเดิม: ไม่มีความเป็นไปได้ที่กระบวนการจะเข้าถึงเนื้อหาของกระบวนการอื่นเนื่องจากการจัดสรรทั้งหมดได้รับการจัดการโดยระบบปฏิบัติการเองและทุกกระบวนการจะทำงานในพื้นที่ที่อยู่เสมือนแซนด์บ็อกซ์ของตัวเอง
ดังนั้นpaging(ในเทคนิคอื่น ๆ ) ร่วมกับหน่วยความจำเสมือนคือสิ่งที่เป็นพลังให้กับซอฟต์แวร์ในปัจจุบันที่ทำงานบน OS-es! สิ่งนี้ช่วยให้นักพัฒนาซอฟต์แวร์ไม่ต้องกังวลเกี่ยวกับจำนวนหน่วยความจำที่มีอยู่ในอุปกรณ์ของผู้ใช้เก็บข้อมูลไว้ที่ใดวิธีป้องกันไม่ให้กระบวนการอื่น ๆ ทำให้ข้อมูลซอฟต์แวร์ของตนเสียหาย ฯลฯ อย่างไรก็ตามแน่นอนว่าไม่สามารถพิสูจน์ได้ทั้งหมด มีข้อบกพร่อง:
Pagingท้ายที่สุดคือทำให้ผู้ใช้เห็นภาพลวงตาของหน่วยความจำที่ไม่มีที่สิ้นสุดโดยใช้ดิสก์เป็นข้อมูลสำรองสำรอง การดึงข้อมูลจากหน่วยความจำสำรองเพื่อใส่ลงในหน่วยความจำ (เรียกว่าpage swapและในกรณีที่ไม่พบหน้าที่ต้องการใน RAM จะเรียกว่าpage fault) มีราคาแพงเนื่องจากเป็นการดำเนินการ IO ซึ่งจะทำให้กระบวนการช้าลง การแลกเปลี่ยนหน้าดังกล่าวเกิดขึ้นหลายครั้งติดต่อกันและกระบวนการจะช้าลงอย่างเจ็บปวด เคยเห็นซอฟต์แวร์ของคุณทำงานได้ดีและสวยงามและทันใดนั้นมันก็ช้ามากจนเกือบจะแฮงค์หรือทำให้คุณไม่มีตัวเลือกในการรีสตาร์ท? อาจเกิดการสลับหน้ามากเกินไปทำให้ช้า (เรียกว่าthrashing)กลับมาที่ OP
เหตุใดเราจึงต้องการหน่วยความจำเสมือนในการดำเนินการกระบวนการ - ตามที่คำตอบอธิบายอย่างยาวเพื่อให้ซอฟต์แวร์เป็นภาพลวงตาของอุปกรณ์ / ระบบปฏิบัติการที่มีหน่วยความจำไม่สิ้นสุดเพื่อให้ซอฟต์แวร์ใด ๆ ไม่ว่าจะเล็กหรือใหญ่สามารถทำงานได้โดยไม่ต้องกังวลเกี่ยวกับการจัดสรรหน่วยความจำหรือกระบวนการอื่น ๆ ที่ทำให้ข้อมูลเสียหายแม้ในขณะที่ วิ่งคู่ขนาน มันเป็นแนวคิดที่นำมาใช้ในการปฏิบัติงานโดยใช้เทคนิคต่าง ๆ ซึ่งหนึ่งในนั้นตามที่อธิบายไว้ที่นี่เป็นเพจจิ้ง นอกจากนี้ยังอาจเป็นการแบ่งกลุ่ม
หน่วยความจำเสมือนนี้อยู่ที่ไหนเมื่อกระบวนการ (โปรแกรม) จากฮาร์ดไดรฟ์ภายนอกถูกนำไปยังหน่วยความจำหลัก (หน่วยความจำกายภาพ) เพื่อดำเนินการ - หน่วยความจำเสมือนไม่ได้ยืนอยู่ที่ใดต่อหนึ่งมันเป็นนามธรรมที่ปรากฏอยู่เสมอเมื่อมีการบูตซอฟต์แวร์ / กระบวนการ / โปรแกรมตารางหน้าใหม่จะถูกสร้างขึ้นและมีการแมปจากที่อยู่ที่พ่นออกมา ประมวลผลไปยังที่อยู่จริงใน RAM เนื่องจากที่อยู่ที่แพร่กระจายออกไปตามกระบวนการไม่ใช่ที่อยู่จริงในแง่หนึ่งก็คือสิ่งที่คุณสามารถพูดthe virtual memoryได้
ใครดูแลหน่วยความจำเสมือนและขนาดของหน่วยความจำเสมือนคืออะไร? - ได้รับการดูแลควบคู่ไปกับระบบปฏิบัติการและซอฟต์แวร์ ลองนึกภาพฟังก์ชั่นในโค้ดของคุณ (ซึ่งในที่สุดก็รวบรวมและสร้างเป็นไฟล์ปฏิบัติการที่สร้างกระบวนการ) ซึ่งมีตัวแปรในเครื่อง - an int i. เมื่อรหัสดำเนินการiรับที่อยู่หน่วยความจำภายในสแต็กของฟังก์ชัน ฟังก์ชันนั้นจะถูกเก็บไว้เป็นวัตถุที่อื่น ที่อยู่เหล่านี้เป็นคอมไพเลอร์ที่สร้างขึ้น (คอมไพเลอร์ที่รวบรวมโค้ดของคุณลงในไฟล์ปฏิบัติการ) - แอดเดรสเสมือน เมื่อดำเนินการiจะต้องอยู่ที่ไหนสักแห่งในที่อยู่จริงเป็นเวลานานของฟังก์ชันนั้นเป็นอย่างน้อย (เว้นแต่จะเป็นตัวแปรคงที่!) ดังนั้น OS จึงจับคู่คอมไพเลอร์ที่อยู่เสมือนที่สร้างขึ้นของiลงในที่อยู่จริงจริงดังนั้นเมื่อใดก็ตามที่ภายในฟังก์ชันนั้นรหัสบางตัวต้องการค่าของiกระบวนการนั้นจะสามารถสอบถามระบบปฏิบัติการสำหรับที่อยู่เสมือนนั้นได้และระบบปฏิบัติการจะสามารถสืบค้นที่อยู่ทางกายภาพสำหรับค่าที่จัดเก็บไว้และส่งคืนกลับมาได้
สมมติว่าขนาดของ RAM คือ 4GB (เช่นช่องว่างที่อยู่ 2 ^ 32-1) ขนาดของหน่วยความจำเสมือนคืออะไร? - ขนาดของ RAM ไม่เกี่ยวข้องกับขนาดของหน่วยความจำเสมือนขึ้นอยู่กับระบบปฏิบัติการ ตัวอย่างเช่นใน 32 บิต Windows ก็คือ16 TBเมื่อวันที่ 64 บิต Windows 256 TBก็คือ แน่นอนว่ามันถูก จำกัด ด้วยขนาดดิสก์เนื่องจากเป็นที่สำรองข้อมูลหน่วยความจำ
ฉันกำลังคัดลอกข้อความที่ตัดตอนมาจากหน้าคนด้านบนอย่างไร้ยางอาย
VIRT - Virtual Image (kb) จำนวนหน่วยความจำเสมือนทั้งหมดที่ใช้โดยงาน ประกอบด้วยโค้ดข้อมูลและไลบรารีที่ใช้ร่วมกันทั้งหมดรวมทั้งเพจที่ถูกสลับออกและเพจที่ถูกแมป แต่ไม่ได้ใช้
SWAP - ขนาดที่สลับ (kb) หน่วยความจำที่ไม่มีอยู่ แต่มีอยู่ในงาน นี่คือหน่วยความจำที่ถูกสลับออกไป แต่อาจรวมถึงหน่วยความจำที่ไม่ใช่ที่อยู่อาศัยเพิ่มเติม คอลัมน์นี้คำนวณโดยการลบหน่วยความจำกายภาพออกจากหน่วยความจำเสมือน
ดูที่นี่: หน่วยความจำเสมือน Physical Vs
หน่วยความจำเสมือนจะถูกเก็บไว้ในฮาร์ดไดรฟ์และจะใช้เมื่อแรมเต็ม หน่วยความจำกายภาพถูก จำกัด ไว้ที่ขนาดของชิป RAM ที่ติดตั้งในคอมพิวเตอร์ หน่วยความจำเสมือนถูก จำกัด ด้วยขนาดของฮาร์ดไดรฟ์ดังนั้นหน่วยความจำเสมือนจึงมีความสามารถในการจัดเก็บข้อมูลเพิ่มเติม