it would look in block 0 of cache,

it would look in block 0 of cache, and if it finds a tag of 000010, the word at offset
4 in this block would be returned to the CPU.
Fully Associative Cache
Direct mapped cache is not as expensive as other caches because the mapping
scheme does not require any searching. Each main memory block has a specific
location to which it maps in cache; when a main memory address is converted to
a cache address, the CPU knows exactly where to look in the cache for that memory
block by simply examining the bits in the block field. This is similar to your
address book: The pages often have an alphabetic index, so if you are searching
for “Joe Smith,” you would look under the “s” tab.
Instead of specifying a unique location for each main memory block, we can
look at the opposite extreme: allowing a main memory block to be placed anywhere
in cache. The only way to find a block mapped this way is to search all of
cache. (This is similar to your author’s desk!) This requires the entire cache to be
built from associative memory so it can be searched in parallel. That is, a single
search must compare the requested tag to all tags in cache to determine whether
the desired data block is present in cache. Associative memory requires special
hardware to allow associative searching, and is, thus, quite expensive.
Using associative mapping, the main memory address is partitioned into two
pieces, the tag and the word. For example, using our previous memory configuration
with 214 words, a cache with 16 blocks, and blocks of 8 words, we see from
Figure 6.8 that the word field is still 3 bits, but now the tag field is 11 bits. This tag
must be stored with each block in cache. When the cache is searched for a specific
main memory block, the tag field of the main memory address is compared to all
the valid tag fields in cache; if a match is found, the block is found. (Remember,
the tag uniquely identifies a main memory block.) If there is no match, we have a
cache miss and the block must be transferred from main memory.
With direct mapping, if a block already occupies the cache location where a
new block must be placed, the block currently in cache is removed (it is written
back to main memory if it has been modified or simply overwritten if it has not
been changed). With fully associative mapping, when cache is full, we need a
replacement algorithm to decide which block we wish to throw out of cache (we
call this our victim block). A simple first-in, first-out algorithm would work, as

Results (Thai) 1:

มันจะดูในบล็อก 0 แคช และถ้าพบว่าป้ายของ 000010 คำที่ตรงข้าม4 ในบล็อกนี้จะถูกส่งกลับไป CPUแคชที่เกี่ยวข้องทั้งหมดแคแมปไม่ราคาแพงที่อื่น ๆ แคชโดยตรงเนื่องจากการแมปแผนงานต้องการค้นหาใด ๆ แต่ละบล็อกหน่วยความจำหลักได้เฉพาะตำแหน่งที่แม็ปในแคช เมื่อแปลงที่อยู่หน่วยความจำหลักการที่อยู่แค CPU รู้ว่าตำแหน่งที่จะค้นในแคชสำหรับหน่วยความจำบล็อก โดยเพียงแค่ตรวจสอบบิตในฟิลด์บล็อค นี่คือคล้ายกับของคุณสมุดรายชื่อ: หน้ามักจะมีดัชนีตัวอักษร ดังนั้นหากคุณกำลังค้นหาสำหรับ "โจสมิธ คุณจะค้นหาภายใต้แท็บ"s"แทนการระบุสถานที่เฉพาะสำหรับแต่ละบล็อคหน่วยความจำหลัก ที่เราสามารถดูตรงข้ามมาก: ให้บล็อกหน่วยความจำหลักจะอยู่ที่ใดในแคช วิธีเดียวที่จะค้นหาบล็อกแมปวิธีนี้คือการ ค้นหาทั้งหมดแคช (นี่คือคล้ายกับโต๊ะของผู้เขียนของคุณ) แคชทั้งหมดจะต้องสร้างจากความทรงจำที่เกี่ยวข้องเพื่อให้สามารถค้นหาพร้อมกัน เดียวคือค้นหาต้องเปรียบเทียบแท็กแท็กทั้งหมดในแคชของการตรวจสอบการร้องขอหรือไม่บล็อกข้อมูลที่ระบุอยู่ในแคช หน่วยความจำที่เกี่ยวข้องต้องการพิเศษฮาร์ดแวร์ให้สัมพันธ์กันค้น และ มี ดังนั้น จึงค่อนข้างแพงใช้การแม็ปที่สัมพันธ์กัน อยู่หน่วยความจำหลักจะแบ่งออกเป็นสองชิ้น แท็ก และคำ ตัวอย่าง ใช้การกำหนดค่าหน่วยความจำของเราก่อนหน้านี้เราดูจากคำ 214 แค 16 บล็อก และบล็อกคำ 8รูป 6.8 ฟิลด์คำว่ายังคง 3 บิต แต่ขณะนี้ฟิลด์แท็กเป็น 11 บิต แท็กนี้ต้องเก็บไว้กับแต่ละบล็อกในแคช เมื่อแคคือค้นหาเฉพาะหน่วยความจำหลักบล็อก ฟิลด์แท็กที่อยู่ในหน่วยความจำหลักถูกเปรียบเทียบกับทั้งหมดฟิลด์ถูกแท็กในแคช ถ้าพบการแข่งขัน บล็อคจะพบ (จำไว้ว่าป้ายเฉพาะระบุบล็อกหน่วยความจำหลัก) ถ้ามีไม่ตรงกัน เรามีการนางสาวแคและบล็อคต้องโอนย้ายจากหน่วยความจำหลักกับตรงแม็ป บล็อกแล้วใช้ตำแหน่งของแคชซึ่งเป็นต้องทำบล็อกใหม่ ลบบล็อกอยู่ในแคช (มันเขียนกลับไปยังหน่วยความจำหลักถ้ามีการปรับเปลี่ยนหรือเพียงแค่ประกาศว่า มีไม่การเปลี่ยนแปลง) มีการแมปแบบจับคู่ทั้งหมด เมื่อแคเต็ม เราต้องการเปลี่ยนอัลกอริทึมการบล็อกที่เราต้องการโยนออกจากแคช (เราตัดสินใจโทรนี้เหยื่อของบล็อก) ง่าย ๆ ในครั้งแรก first-out อัลกอริทึมจะทำงาน เป็น

Results (Thai) 2:

ก็จะมีลักษณะในการป้องกัน 0 ของแคชและหากพบป้าย 000010 คำที่ออฟเซต
ที่ 4 ในบล็อกนี้จะถูกส่งกลับไปยัง CPU.
ครบเชื่อมโยงแคช
แคชแมปโดยตรงไม่ได้มีราคาแพงเป็นแคชอื่น ๆ เพราะการทำแผนที่
โครงการ ไม่จำเป็นต้องมีการค้นหาใด ๆ แต่ละบล็อกหน่วยความจำหลักมีเฉพาะ
สถานที่ที่มันแผนที่ในแคช; เมื่ออยู่หน่วยความจำหลักจะถูกแปลงเป็น
อยู่แคช, CPU รู้ว่าที่มองในแคชสำหรับหน่วยความจำที่
บล็อกโดยเพียงแค่การตรวจสอบบิตในด้านการป้องกัน นี้จะคล้ายกับของคุณ
หนังสือที่อยู่: หน้ามักจะมีดัชนีตัวอักษรดังนั้นถ้าคุณกำลังค้นหา
สำหรับ "โจสมิ ธ " คุณจะมองภายใต้ "S" แท็บ.
แทนการระบุสถานที่ที่ไม่ซ้ำกันสำหรับแต่ละบล็อกหน่วยความจำหลักเรา สามารถ
ดูมากตรงข้าม: ช่วยให้บล็อกหน่วยความจำที่จะอยู่ที่ใดก็ได้
ในแคช วิธีเดียวที่จะพบบล็อกแมปด้วยวิธีนี้คือการค้นหาทั้งหมดของ
แคช (นี่คือคล้ายกับโต๊ะเขียนของคุณ!) นี้ต้องใช้แคชทั้งหมดจะได้รับการ
สร้างขึ้นจากหน่วยความจำแบบเชื่อมโยงเพื่อที่จะสามารถค้นหาในแบบคู่ขนาน นั่นคือเดียว
ค้นหาต้องเปรียบเทียบแท็กที่ร้องขอไปยังแท็กทั้งหมดในแคชเพื่อตรวจสอบว่า
บล็อกข้อมูลที่ต้องการอยู่ในแคช หน่วยความจำต้องเชื่อมโยงพิเศษ
ฮาร์ดแวร์เพื่อช่วยให้การค้นหาเชื่อมโยงและเป็นจึงค่อนข้างแพง.
การใช้การทำแผนที่เชื่อมโยงที่อยู่หน่วยความจำหลักจะถูกแบ่งออกเป็นสอง
ชิ้น, แท็กและคำพูด ตัวอย่างเช่นการใช้การตั้งค่าหน่วยความจำก่อนหน้านี้
ที่มี 214 คำแคชกับ 16 บล็อกและบล็อกของ 8 คำที่เราเห็นจาก
รูปที่ 6.8 คำว่าสนามยังคงเป็น 3 บิต แต่ตอนนี้ข้อมูลแท็กเป็น 11 บิต แท็กนี้
จะต้องเก็บไว้กับบล็อกในแคชแต่ละ เมื่อแคชจะค้นหาเฉพาะ
บล็อกหน่วยความจำหลักข้อมูลแท็กที่อยู่หน่วยความจำหลักเมื่อเทียบกับทุก
เขตข้อมูลแท็กที่ถูกต้องในแคช; ถ้าการแข่งขันถูกพบบล็อกที่พบ (อย่าลืมว่า
แท็กระบุบล็อกหน่วยความจำหลัก.) หากมีการจับคู่ไม่มีเรามี
แคชและบล็อกจะต้องได้รับโอนมาจากหน่วยความจำหลัก.
ด้วยการทำแผนที่โดยตรงถ้าบล็อกแล้วตรงบริเวณที่ตั้งของแคชที่
บล็อกใหม่ ต้องวางบล็อกในปัจจุบันแคชจะถูกลบออก (มันถูกเขียน
กลับไปยังหน่วยความจำหลักถ้ามันได้รับการแก้ไขหรือเขียนทับเพียง แต่ถ้ามันไม่ได้
รับการเปลี่ยนแปลง) กับการทำแผนที่เชื่อมโยงอย่างเต็มที่เมื่อแคชเต็มเราต้อง
เปลี่ยนอัลกอริทึมในการตัดสินใจที่บล็อกเราต้องการที่จะโยนออกจากแคช (เรา
เรียกบล็อกนี้เหยื่อของเรา) ง่ายครั้งแรกในขั้นตอนวิธีเข้าก่อนออกก่อนจะทำงานเป็น

Results (Thai) 3:

ดูในบล็อก 0 ของแคช และหากพบป้าย 000010 คำที่ตรงข้าม
4 ในบล็อกนี้จะถูกส่งกลับไปยังซีพียู

ตรงแมปอย่างเต็มที่เชื่อมโยงแคชแคชไม่แพงเท่าแคชอื่น ๆเพราะรูปแบบการทำแผนที่
ไม่ต้องค้นหา หลักแต่ละบล็อกหน่วยความจำมีสถานที่เฉพาะ
ที่แผนที่ในแคช เมื่อที่อยู่ในหน่วยความจำหลักจะถูกแปลงเป็น
ที่อยู่ในแคช CPU รู้ดีดูในแคชสำหรับบล็อกหน่วยความจำ
โดยเพียงการตรวจสอบบิตในบล็อกด้าน นี้จะคล้ายกับหนังสือที่อยู่ของคุณ
: หน้ามักจะมีอักขรานุกรม ดังนั้นถ้าคุณกำลังค้นหา
" Joe Smith , " คุณจะดูภายใต้ " แท็บ " .
แทนการระบุสถานที่ที่ไม่ซ้ำกันสำหรับแต่ละหลักบล็อกหน่วยความจำเราสามารถ
ดูที่ตรงข้ามมากช่วยให้บล็อกหน่วยความจำหลักถูกวางไว้ที่ใดก็ได้
ในแคช วิธีเดียวที่จะพบบล็อกแมปวิธีนี้คือการค้นหาทั้งหมดของ
แคช ( นี้จะคล้ายกับผู้เขียนของคุณ 24 ชั่วโมง ! ) นี้ต้องใช้แคชทั้งหมดจะถูกสร้างขึ้นจาก
หน่วยความจำมันสามารถค้นหาในแบบคู่ขนาน นั่นคือ เดียว
ค้นหาต้องเปรียบเทียบขอแท็กแท็กทั้งหมดในแคชเพื่อตรวจสอบว่าข้อมูลที่ต้องการบล็อก
อยู่ในแคช หน่วยความจำต้องใช้ฮาร์ดแวร์พิเศษ
เพื่อให้เชื่อมโยงการค้นหาและจึงค่อนข้างแพง
ใช้เชื่อมโยงแผนที่ , หน่วยความจําหลักที่อยู่จะแบ่งเป็นสอง
ชิ้น , แท็กและคำ ตัวอย่างการใช้หน่วยความจำ
การกำหนดค่าก่อนหน้านี้ของเรากับ 214 คำแคช 16 บล็อก บล็อก 8 คำ เราดูจากรูปที่ 6.8
คำว่าสนามยัง 3 บิต แต่ตอนนี้ป้ายสนามเป็น 11 บิต แท็กนี้
ต้องเก็บไว้กับแต่ละบล็อกในแคช เมื่อแคชค้นหาบล็อกหน่วยความจำหลักเฉพาะ
, แท็กฟิลด์ของหน่วยความจำหลักอยู่เมื่อเทียบกับ
ถูกต้องแท็กเขตข้อมูลในแคช ถ้าการแข่งขันถูกพบ บล็อกจะพบ( จำได้
แท็กพิเศษระบุบล็อก หน่วยความจำหลัก ถ้าไม่มีราคา เราได้พลาด
แคชและบล็อกจะต้องโอนจากหน่วยความจำหลัก .
กับแผนที่โดยตรง ถ้าบล็อกแล้วใช้สถานที่แคชที่
บล็อกใหม่ต้องวางบล็อกอยู่ในแคช คือ ออก ( มันเขียน
กลับสู่หน่วยความจำหลัก ถ้ามันได้รับการแก้ไขหรือเพียงแค่เขียนทับ ถ้ามันไม่ได้
การเปลี่ยนแปลง ) พร้อมเชื่อมโยงแผนที่ เมื่อแคชเต็ม เราต้องเปลี่ยนวิธีตัดสินใจ
ที่บล็อกเราต้องการที่จะโยนออกไปจากแคช ( เรา
เรียกบล็อกนี้เหยื่อของเรา ) แบบเข้าก่อนออกก่อน อัลกอริทึมจะทำงาน เช่น