soon. We can keep track of the last

soon. We can keep track of the last time each block was accessed (assign a timestamp
to the block), and select as the victim block the block that has been used
least recently. This is the least recently used (LRU) algorithm. Unfortunately,
LRU requires the system to keep a history of accesses for every cache block,
which requires significant space and slows down the operation of the cache.
There are ways to approximate LRU, but that is beyond the scope of this book.
(Refer to the references at the end of the chapter for more information.)
First in, first out (FIFO) is another popular approach. With this algorithm,
the block that has been in cache the longest (regardless of how recently it has
been used) would be selected as the victim to be removed from cache memory.
Another approach is to select a victim at random. The problem with LRU and
FIFO is that there are degenerate referencing situations in which they can be made to
thrash (constantly throw out a block, then bring it back, then throw it out, then bring
it back, repeatedly). Some people argue that random replacement, although it sometimes
throws out data that will be needed soon, never thrashes. Unfortunately, it is
difficult to have truly random replacement, and it can decrease average performance.
The algorithm selected often depends on how the system will be used. No
single (practical) algorithm is best for all scenarios. For that reason, designers use
algorithms that perform well under a wide variety of circumstances.

Results (Thai) 1:

เร็ว ๆ นี้ เราสามารถติดตามการล่าสุดเข้าถึงแต่ละช่วงเวลา (เวลากำหนดไปบล็อก), และเลือกเป็นเหยื่อบล็อกบล็อกที่ใช้น้อยล่าสุด อัลกอริทึม (LRU) อย่างน้อยใช้อยู่ อับLRU ต้องการระบบการเก็บประวัติหาในบล็อกทุกแคซึ่งต้องการพื้นที่สำคัญ และช้าลงการทำงานของแคชมีวิธีในการประมาณ LRU แต่ที่เกินขอบเขตของหนังสือเล่มนี้(ดูการอ้างอิงท้ายบทสำหรับข้อมูลเพิ่มเติม)ครั้งแรก ก่อนออกก่อน (FIFO) เป็นวิธีการยอดนิยมอีก กับอัลกอริทึมนี้บล็อกที่ได้รับในแคชที่ยาวที่สุด (ไม่ว่าเพิ่ง มีการใช้) จะถูกเลือกเป็นเหยื่อออกจากหน่วยความจำแคชอีกวิธีคือการ เลือกเหยื่อแบบสุ่ม ปัญหากับ LRU และFIFO คือมี degenerate อ้างอิงสถานการณ์ที่พวกเขาสามารถทำการthrash (ตลอดเวลาทิ้งบล็อก แล้วนำกลับมา แล้วโยนมันออก แล้วนำมันกลับ ซ้ำ) บางคนโต้เถียงแทนที่สุ่ม แม้ว่าบางครั้งthrows ออกนั้นจะต้องไม่ช้า ไม่ thrashes อับ มันเป็นยากให้แทนแบบสุ่มอย่างแท้จริง และสามารถลดประสิทธิภาพการทำงานเฉลี่ยอัลกอริทึมที่เลือกมักจะขึ้นอยู่กับว่าจะใช้ระบบ ไม่ใช่อัลกอริทึม (ปฏิบัติ) เดียวเหมาะสำหรับทุกสถานการณ์ ใช้เหตุผล นักออกแบบอัลกอริทึมที่ทำได้ดีภายใต้สถานการณ์ที่หลากหลาย

Results (Thai) 2:

ในไม่ช้า เราสามารถติดตามครั้งสุดท้ายที่แต่ละบล็อกการเข้าถึง (กำหนด timestamp
บล็อก) และเลือกเป็นเหยื่อป้องกันบล็อกที่มีการใช้
น้อยที่สุดเมื่อเร็ว ๆ นี้ นี่คือการใช้น้อยที่สุดเมื่อเร็ว ๆ นี้ (อาร์) อัลกอริทึม แต่น่าเสียดายที่
อาร์จำเป็นต้องใช้ระบบที่จะทำให้ประวัติศาสตร์ของการเข้าถึงทุกบล็อกแคช
ซึ่งต้องใช้พื้นที่อย่างมีนัยสำคัญและช้าลงการดำเนินงานของแคช.
มีวิธีที่จะใกล้เคียงกับอาร์มี แต่ที่อยู่นอกเหนือขอบเขตของหนังสือเล่มนี้.
(โปรดดูที่ การอ้างอิงในตอนท้ายของบทสำหรับข้อมูลเพิ่มเติม.)
เป็นครั้งแรกในครั้งแรกออกก่อน (FIFO) เป็นอีกหนึ่งวิธีการที่เป็นที่นิยม ด้วยขั้นตอนวิธีนี้
บล็อกที่ได้รับในแคชที่ยาวที่สุด (โดยไม่คำนึงถึงวิธีการที่เมื่อเร็ว ๆ นี้ได้
ถูกนำมาใช้) จะได้รับการคัดเลือกให้เป็นเหยื่อที่จะถูกลบออกจากหน่วยความจำแคช.
อีกวิธีหนึ่งคือการเลือกเหยื่อที่สุ่ม ปัญหากับอาร์และ
FIFO คือว่ามีสถานการณ์การอ้างอิงเลวที่พวกเขาสามารถทำเพื่อ
ฟาด (อย่างต่อเนื่องโยนออกบล็อกแล้วนำมันกลับมาแล้วโยนมันออกแล้วนำ
มันกลับมาซ้ำแล้วซ้ำอีก) บางคนยืนยันว่าการเปลี่ยนสุ่มแม้ว่าบางครั้งมันก็
พ่นออกจากข้อมูลที่จะต้องเร็ว ๆ นี้ไม่เคยซัด แต่มันเป็น
เรื่องยากที่จะมีการทดแทนที่สุ่มอย่างแท้จริงและจะสามารถลดประสิทธิภาพการทำงานโดยเฉลี่ย.
อัลกอริทึมที่เลือกมักจะขึ้นอยู่กับวิธีการที่ระบบจะถูกนำมาใช้ ไม่มี
เดียว (ปฏิบัติ) ขั้นตอนวิธีการที่ดีที่สุดสำหรับทุกสถานการณ์ สำหรับเหตุผลที่นักออกแบบใช้
อัลกอริทึมที่มีประสิทธิภาพดีภายใต้ความหลากหลายของสถานการณ์

Results (Thai) 3:

เร็ว ๆ นี้ เราสามารถเก็บติดตามของเวลาเมื่อแต่ละบล็อกก็เข้าถึงได้ ( กำหนดเวลา
เพื่อบล็อก ) และเลือกเป็นเหยื่อบล็อกบล็อกที่มีการใช้
อย่างน้อย เมื่อเร็วๆ นี้ นี้เป็นอย่างน้อยที่ใช้เมื่อเร็ว ๆนี้ ( เลย ) ขั้นตอนวิธี แต่น่าเสียดายที่
เลยต้องระบบเก็บประวัติการใช้งานทุกแคชบล็อก
ซึ่งต้องใช้พื้นที่และช้าลง ที่สำคัญการดำเนินงานของแคช
ไม่มีวิธีเลยประมาณ แต่ที่เกินขอบเขตของหนังสือเล่มนี้ .
( อ้างถึงการอ้างอิงท้ายบทสำหรับข้อมูลเพิ่มเติม )
เข้าก่อนออกก่อน ( FIFO ) เป็นแนวทางหนึ่งที่เป็นที่นิยม ด้วยวิธีนี้
บล็อกที่ได้รับในแคชที่ยาวที่สุด ( ไม่ว่าเมื่อเร็ว ๆ นี้มันมี
ถูกใช้ ) จะถูกเลือกเป็นเหยื่อ จะถูกลบออกจากหน่วยความจำ แคช
อีกวิธีหนึ่งคือการเลือกเหยื่อแบบสุ่ม ปัญหาเลยและ
FIFO คือ มีการอ้างถึงสถานการณ์ที่พวกเขาสามารถทำให้
ฟาด ( อย่างต่อเนื่องโยนออกจากบล็อก แล้วนำมันกลับมา แล้วโยนมันออกไป แล้วเอา
กลับซ้ำๆ ) บางคนเถียงว่าสุ่มแทน แม้ว่าบางครั้ง
พ่นข้อมูลที่จะต้องใช้เร็วๆ นี้ ไม่เคย thrashes .แต่มันก็ยากที่จะมีแทน
สุ่มอย่างแท้จริง และสามารถลดประสิทธิภาพเฉลี่ย
ขั้นตอนวิธีการเลือกมักจะขึ้นอยู่กับว่าระบบจะถูกใช้ ไม่โสด ( ภาคปฏิบัติ )
วิธีที่ดีที่สุดสำหรับทุกสถานการณ์ สำหรับเหตุผลที่ , นักออกแบบอัลกอริทึมที่ใช้
ได้ดีภายใต้ความหลากหลายของสถานการณ์