Computer Architecture

Computer Architecture
Copy from: http://cenalulu.github.io/linux/all-about-cpu-cache/
黃婷婷共筆

memory

main memory 跟 second memory 之間加一個virtual memory的系統，就access 的狀況來看會有分

random access memory: 你在任何一個位置去access任何一個，它的access time是一樣的。

對應另外一個你的location不一樣，那他access的時間就會不一樣，就是我們的magnetic disk，也就是所謂的secondary memory。

Ram又分為:

SRAM(static random access memory) : 主要用在cache的部分，access main memory要花很長時間的，由於CPU的時脈很快，如果資料因為卡在main memory的讀寫速度不夠快的話，那麼就會造成資料阻塞，所以在main memory之前加入了cache的機制，low density(容量比較小)、high power、expensive、fast([跟transistor)，如果電量一直維持的話內容會持續被latch住，3~9的 ns基本上就是一個clock cycle就可以完成他。
DRAM(dynamic random access memory) : main memory是DRAM做成的，high density(容量大)、low power、cheap、slow。DRAM是用電容去implement他的0跟1的。用完˙之後電流就會流掉了，所以需要reflash。DRAM有著2-dimension的array一樣，用raw address搭配column address來get要讀得完整的data( memory as a 2D matrix ( read row to activate and read column to select ))，30~90 ns 也就是100個clock cycles就可以完成。
access SRAM 比 DRAM 快幾乎100倍
L1 cache has capacities between 4 to 16 kilobytes and accessing speeds of 10 nanoseconds, while the L2 cache can reach sizes of 512 kilobytes and a speed of only 20 to 30 nanoseconds.The typical accessing speed of a RAM is 60 nanoseconds and a capacity of up to several gigabytes. Hard drives - 12 milliseconds and several hundred gigabytes to a couple of terabytes of storing capacity
想要快, 又想要容量大 -> solution : Memory Hierarchy :

因為moore’s law的關係，我們的transistor(電晶體)越來越小，所以速度越來越快，但是DRAM是另外的製程，memory跟processor的gate越來越大，造成即使processor的速度快但在memory時造成load、store的資料阻塞，所以才需要memory hierarchy，越靠近我們的processor，就採用速度快容量小的memory，即使願意花很多錢，讓cache的數變多造成容量變大，也會卡在register的small effect，越遠的就是容量比較大比較慢的memory。

Why aren’t all caches as fast as L1?

To make all the cache memories run at the same speed as the L1 cache - 10 nanoseconds - would be extremely expensive and in fact the computer doesn’t need large amounts of cache memory due to locality of reference. Locality of reference means that no matter how large or small in size a running application is, only a small part of the respective program is being stored into the cache at one given time.

This is because the vast majority of programs mostly contain fairly large amounts of code lines which are executed only once. The other lines are represented by program loops which are executed over and over again. Less than 10 percent of processor time is spent by the programs running at one time.

補充內容: transistor特性、DRAM製程、對memory的一些基本認知、說明CPU旁的cache及latency

在upper level到lower level傳輸data之間時，我們要define一個基本basic的單位量，所以在cache跟main memory之間就稱為block而在main memory 到 second memory之間裡的virtual memory系統就稱為page。

Why memory hierarchy works ?
因為90/10的rule，(10% of code executed 90% of time) 百分之90的時間都花在百發之10的內容(在program裡面常常會用到loop而不斷的重複再做)，常常在用的就放在cache中這就是temporal locality，
array、program counter(PC=PC+4)的思維也就是space locality。
理論上簡單分 (upper level) registers -> caches -> memory -> disk (lower level)

Memory Hierarchy : Terminology(術語 專有名詞)
Hit : data appears in upper level.
Hit rate, Hit time
Miss : data need to be retrieved from a block in the lower level.
Miss rate, Miss Penalty
Questions for Hierarchy Design :

block placement, block finding, block replacement, write strategy (四種議題在memory的upper level與lower level之間對應常討論，少(upper level)對多(lower level)多人搶位置當然會這些議題存在)

Cache是跟Processor綁再一起的，而DRAM(main memory)則沒有跟processor綁在一起的。

cache:

Basics of cache(基本簡單的cache實現) : direct-mapped cache

Address mapping : modulo(取餘數) number of blocks
direct map來實現基本的cache實作(upper level 8個位置,lower level 32個)，upper level 位置少，對應lower level位置多，多個人搶一個位置，那麼因為位置不夠，所以牽扯到搶位置的話，怎麼搶，灰歸灰 橘歸橘，也就是lower level除與upper level取餘數，就是這樣相對應的。舉例: 20 % 4 = 4，換成binary 的話就是(10100 % 100 = 100)也就是直接取後面三個bit就行了，因為八是1000所以直接看後面的三個bit就行了。
再來說明Tag，今天當upper 8 對 lower 32時，會產生一個block對應四個block的狀況，所以除了把lower的data放進去upper之外，還要擺地址，但今天不需要擺地址全部都擺進去，今天一對四的狀況，後面三個bit都一樣，所以只要放前面的bit放進去就好，這就是tag。所以cahce有你的main memory的data跟tag(前半段的address)。
還有多一個bit叫做valid bit代表用來判斷是否為正確的資料。
有否data就是miss/hit判斷，當有資料但tag不一樣時，就要寫回去，需要replacement。如果今日一個block代表一個word也就是4bytes那麼，就需要最小的兩個bit ( 00 , 01 , 10 , 11 )代表byte offset(或稱block offset因為現在搬移是以一個block為單位，但這是會記錄一個block裡面的第幾個byte)來判斷說是哪代表哪一個byte，memory address拆成，有10個bits用來代表index對應到cache就是有2^10=1k的size的word，就是用來判別在cache中的index，然後記得要保留最後幾個bits來代表byte offset。
cache 架構會不一樣, block size 也會不一樣 , 所以tag是多少個bits也不一樣 -> 要計算(下圖為一個示意圖參考) :

維基解釋

舉例:

address 32 (tag,index,byte offset):
一個block 1 words = 4 bytes所以最末2bits來表示，cache 有幾個blcok，1k的size=2^10 = 1024所以，保留末端2bit前的10bits，最後剩下的前20個bit留給tag用。
64個block, 16bytes/blcok，2^6=64所以空出6個bits來做index，一個block有16bytes所以byte offset=4 bits表示即可，那剩下22bits留給tag使用。
Block Size Considerations :

Larger blocks should reduce miss rate , due to spatial locality
但是因為 cache size 是固定的, 所以block number 就會減少, 這樣表示更多人要來搶這個block. -> tradeoff
解釋:

cache的size是固定的，block size larger代表space locality很好，有足夠的空間來存放，減少miss rate的發生，但如果設計太大的話，代表你的number of the block會變少了，但可能會有變成更多人去搶少的位置，所以miss rate還是會常發生，且當你的block size變大時，你每次搬的時間就會變長，所以才會有early restart or critical work first 的機制來解決此問題(用硬體來實現)，可以看微笑曲線的分析，來看出最佳的block size是多少。

cache有關的行為 read / write

先看read流程:

如果hit的話 CPU proceeds normally ，如果miss的話，先stall CPU pipeline ，在(以5-stage-pipeline來說)第四個stage時要把它停下來，花很多cycles浪費在其他level的cache或更深的main memory中去拿資料，再來就有instruction cache or data cache 像L1 cache一樣，如果instruction cache miss的話就重新restart fetch instruction，如果是data cache miss的話就完成之前的data就好。

write(去寫cache ->記住你是去寫copy的所以要寫回main memory的資料做一至性調整):

write consistency，因為有兩個copy，一個在cache另外一個在lower level。 使他有write policy : write back /write through的不同。

Write through : 只要cache的copy data一改變also update memory
slow -> solution : write buffer. CPU continuous immediately.
優點 : data 在cache和在memory 永遠維持一致性
缺點 : 浪費memory 的 bandwidth (traffic)
Write back : 當cache中的 block 要被 replace 掉的時候, 再write back 回 memory(並用dirty bit做一個檢查機制)
a. use dirty bit. 有被改寫過的 dirty bit 就設 1沒有就是0

解釋:

維持一致性每一次都寫回到main memory 中這叫做write through，這樣很花時間的，所以另外一種就是write back，如果此data是dirty的話當整個寫完後，才把他寫回到main memory中。write through 空出一個buffer 讓CPU繼續run然後將要改寫的data放在buffer中，從buffer中慢慢寫回去，除非buffer滿的話才會再讓CPU來處理此狀況，然後此buffer採用FIFO的排程。

write back : 維持新的update在cache中，什麼時候寫回去呢?就是在當要被replace 時才去做update 才寫回到main memory中，所以要用write back的話，就要有一個dirty bit來判斷是否需要把此copy寫回到main memory中，如果dirty bit =0代表新其他tag的新資料可以直接覆蓋在該index中，不用做寫回的動作。而寫都是寫到buffer中。

Write cache miss :

是否要 allocate to cache 呢?
第一個方法 : write back - fetch the block. 把cache 內的 replace掉
第二個方法 : write through - 直接寫到 memory內 , 不用搬進 cache內
解釋:

代表資料不在cache中時，到底要不要allocate 有兩種狀況，write back的話，代表不在cache的這塊block我們就直接fetch進來到此block中，把cache的block replace 掉(更新cache內的black內容)，write though的話可以fetch或不fetch而直接寫到main memory中而不用把它搬進來。

Example: MIPS processor

16kbytes = 256個block ，一個block 16個words，1個word=4 bytes用2個bit來表示，4個bit來描述哪一個word，看他第幾個block從index看，八個address因為他有256個block 用8個bit去表示他，(tag,index,word offset,byte offset) 。

Direct map cache的缺點就是當今天就是有多個人搶一個椅子的狀況時限制多，improve此機制為為fully associative ，我要從main memory當中上去到cache裡頭的話，只要有空位就擺(在任何一個位置都可以)，要想辦法解決map到哪裡，在search的時候時間就會比較長，如果sequential的話ㄧ定超花時間，所以其實是同時去check cache entry，需要許多個 comparator 也就是硬體成本較昂貴 ，還有一種的就是採取折衷辦法，n-way的set-associative ，假如cache裡ㄧ個號碼(index)有兩個位置(2-way)，那麼就可以容納兩個人可以稍微彈性點，硬體成本就比fully associative 還便宜些 。

cache direct map index相衝圖

cache 4-way set associative 圖參考

以範例介紹n-way 的set-associative ，32 bits ( tag(22), index(8), byte offset(2) )，1個block size是1個word=4bytes所以用2bits來表示，cache是4-way的set-associative且用8個bits代表2^8=256個set，每個set有4個block(因為4-way)，在知道是(0~255)中第幾個set之後去比較address的前22個bits也就是比較tag來區別是4-way中的哪一個set hit or miss。

Data Placement Policy :

Direct mapped cache :
Each memory block mapped to one location
N-way set associative cache : 不錯的參考
Each memory block has choice of N locations
fully associative cache :
Each memory block can be placed in ANY cache
Cache Block Replacement 有一些機制 ：
Direct mapped : 沒選擇
Set associative or fully associative :
Random
Least Recently Used (LRU) 最近最少用到的 : use a pointer pointing at each block in turn
我們拿到的是 byte address, 要取得他的 block address 就要先把後面的byte offset 先不看才可以得到 block address. 假設現在一個 block 有兩個 word, 也就等於 8 bytes , 表示byte address 後面三個 bits 是不用看的. 有 block address 後再去用 index and tag去找他在哪個 block.
解釋:
再來討論當位置擺滿時，下一個人要來搶此位置時，該怎麼做replacement(cache的block replacement)，有Random、LRU(least recently use最近最不用到的就搬出去，需要比較多的hardware來track the access history and replace the block that has not been used for the longest time，用point 來指出誰最近最用不到，代表待會要搬出去)，N-way associative 需要N個comparator以及ㄧ個N-way的mux(多工器)來選擇出哪一個bock，所以N-way有一個compare的delay與direct map相比會慢ㄧ些。
Multiple Caches
Primary cache 是level 1 cache 是small fast，level 2 cache larger than level-1 cache slower than level 1 cache but still faster than main memory ，當level 1 cache miss時就會level 2 cache來serve CPU，primary cache目的是用來降低hit time，level 2 cache 雖然又增加了一點hit time但盡量避免去main memory 的 access time ，Out of order CPU can execute instruction units during cache miss : pending store stays in load/store unit , dependent instructions wait in reservation and independent instructions continue。在cache這邊的議題會有一個hardware的cache controller來控管在cache miss時的處理機制，process會停下來等你把cache東西拿進來在說。

Virtual memory system

Main memory 跟 disk之間的議題:

Memory <–> Disk （之前談的是 Cache <–> Memory）, 概念其實和之前的一樣
很多program之間 只要搬部份的 program 進 memory 內, 由 OS 控制
Program share main memory :
每一個人有自己的 private virtual address holding its frequently used code and data.
Upper level (physical memory) <–> Lower level (virtual memory)，address 的 high order 表示 frame number , low order 表示 offset ，要access data 會先拿到 virtual address, 透過 page table 做了 address translation 後, 即可找到 physical address, 即可 access 到 data.”block” -> “page” , “miss” -> “page fault”
Basic Issues :
Size of data blocks ?
如何放置(placement) policy to the page ?
如何替換(replacement) policy to the page ?
解釋:

讓program經過一個機制(map到main memory上)，main memory的位址有限，program所需的memory總合有可能會大於main memory所提供的size，這一層發生的miss被稱為page miss，需要花幾百萬個cycles(millions of cycles)來從disk搬資料到main memory中，由OS(Software)來掌管這一層的搬移但仍需要ㄧ些hardware輔助，搬的單位就是page -> block ，page fault -> (在cache狀況)cache miss ，在main memory 當中切成跟pageㄧ樣大小的一塊一塊單位稱為frame，ㄧ個page是要map到main memory中的一塊frame，program share main memory(Multi-programming)，常用的放在main memory 不常用的就放在disk，不用全部搬到main memory中，program有自己的private virtual address，需要一個table知道真正在哪(舉例:虛擬38對應真實5)

virtual address 搭配page table轉成physical address對應到main memory的圖及過程找一下

Page Table :
存放 placement 的資訊. 放在 main memory 內
Problem :
page table 太大，How many memory references for each address translation? 2 次. 一次查 page table , 一次 access memory
Page fault :
表示page 不在 main memory內.Hardware must detect situation but it cannot remedy the situation.
software 解決.The faulting process can be context switch

解釋:

在這邊採用fully associative ，所以需要一個page table來做translation，一個word是4bytes的話，只需用到2個bit來表示，所以在virtual address 這邊如果一個page是2^12bytes的話只需要空出12bits來當作page offset，在每次access main memory時會先去check page table如果有紀錄(virtual address 對應到physical address)即可從page table中找到在main memory的frame中的data，不在代表page table裡面沒有此紀錄那代表你的data還在disk中而這就是產生page fault，產生page fault 的話 OS就會開始著手處理，進行interrupt把data從disk搬到main memory(做I/O)此時你的process就是在waiting的state直到搬完了才會回到ready queue中等待CPU的scheduler來進行排程分配資源，在page table中會進行search該page在main memory的話那又代表hit，page table register in CPU points to page table in physical memory(告訴你從哪邊開始的page table)對應到x86架構的cpu 應該是CR3?!

CR3(查一下)
Control register in x86(參考維基):

CR0:

The CR0 register is 32 bits long on the 386 and higher processors. On x86-64 processors in long mode, it (and the other control registers) is 64 bits long. CR0 has various control flags that modify the basic operation of the processor.

CR2:

Contains a value called Page Fault Linear Address (PFLA). When a page fault occurs, the address the program attempted to access is stored in the CR2 register.

CR3:

Used when virtual addressing is enabled, hence when the PG bit is set in CR0. CR3 enables the processor to translate linear addresses into physical addresses by locating the page directory and page tables for the current task. Typically, the upper 20 bits of CR3 become thepage directory base register (PDBR), which stores the physical address of the first page directory entry.

實際上的Page table:

簡述實體記憶體位址的計算方式：

cr3 + Page Directory (10 MSBs) = 指向 table_base
table_base + Page Table (10 個中間的 bits) = points to page_base
page_base + Offset = physical address (取得 page frame)
既然 Page Directory 與 Page Table 長度都是 10 bits，可定址的範圍就是 1024 * 1024 kb，並且 Offset 可以定址到 2^12 (4096 bytes)，因此，全部由 Page Directory 規範的可定址範圍就是 1024 * 1024 * 4096 (等於 2^32 = 4 GB)。所以，在 x86 硬體架構來說，可定址的上限就是 4 GB。

參考維基、參考jserv’s blog

延伸補充之前JSERV提的PAE:

PAE(physical address extension ) jesev blog 許富皓課堂有提到 他人看許富皓影片共筆

原本的page table structure (最後的12bits做offset) 每一個page table entry 32 bits ，斜線代表從上面來的這幾個bits，

PAE有四個，page point entry PAE的切換(用CR4的第五個bit enable)，64bits 的page

Page Replacement and Writes:

fully associative -> 如果都滿了的話, 誰要出去?誰要被替換? -> 需要policy
To reduce page fault rate -> prefer least-recently used (LRU) replacement
Reference bit (use bit), 過了一段時間會刷新, 把全部的bit都設為零，一定是Write back.需要 dirty bits ( 有被寫過的設為1 , 之後要write back 回 disk )
解釋:

page table就會告訴你相對應的frame number，在page table還有status bits(dirty bit(判別有無被寫過)、reference bit(紀錄誰最近(一段時間)沒被用到(0,1)))，virtual address(page number,page offset)，page number對應出找哪一個page並藉由page table register來指向說從哪邊開始加上此page number(譬如說page number是38然後page table register指向100代表從100開始然後往後+38)並再搭配page offset知道是從讀此page裡面的哪一個byte，所以page offset在virtual address跟physical address是一樣的，因為每次得到一個virtual address時需要經有兩次的reference(page table的機制，知道在哪後才去main memory的frame中去抓)，所以應該會想產生一個cache的咚咚靠近CPU這樣增快它的access也就是TLB(translation look aside buffer)的誕生。

page faults代表你要 access的page不在你的main memory的frame中，會產生很大的penalty可以用硬體偵測到，但無法完全用hardware來fix它，所以須要用Software來處理，如果physical address滿的話就要做replacement(1.pick a page table to discard , 2. load the page from disk, 3. update the page table, 4. process 在ready queue等到CPU分配資源)，如果還有空的就直接搬進來， page replacement參照reference bit，write 的話是參照(dirty bit，有被寫過的話就要記得write到disk中如果沒有的話就不需要改disk的值)並用write back，因為write through是代表每次有update就要寫回去lower level(disk)中，太花時間了。

有多大的 page 就要有多大的 page table 來做對應，舉例 page table太大的問題:

32 bits的virtual address , 4Kbytes的page, 4bytes/entry，一個page有2^12bytes代表空出lower 12bits，剩下higher 20bits當作page number，也就是剩下2^20個page table entry，也就是2^22 (4M)bytes的page table。如果每個process在同一時間都要create這麼大的table的話這樣main memory會占用太大的空間了，不需要一次把整個page table放在main memory中，因為只會用到某幾塊幾塊而已。

page table size太大的問題，Solutions :

用 bound registers 來限制 table size; add more if exceed.
讓 pages grow in both directions，2 tables -> 2 registers, one for hash , one for stack
不懂第二個方法的意思
multiple levels of page tables
舉例2-level page table 把address拆成兩份(10,10,12(page offset)) 參考search page table
要再查一下實際過程以及圖

TLB:

某個 entry 一直用到 (locality), 就要一直做 address translation(查 page table), 那不如不要放在main memory, 就放在 CPU 旁邊 -> TLB
TLB : 其實就是常常用的 page table entry , 然後放在 CPU 旁邊. 就不用去 main memory 去 translate 它
TLB hits
TLB miss:
translation miss (在 page table內的 entry 沒擺上來)，page fault (這個 page 根本不在我的 main memory 內)
解釋:

page table access太慢(用TLB(translation look aside buffer)修正:

把常常用的Translation 放在CPU的附近，他是Page table的一小部分copy，為了加速用的。靠hardware(buffer)幫忙放置在CPU旁，增快access的速度，原本一開始只有一個buffer而到現在因為這部分成本降低所以增加了許多buffer演變成像cache一樣，每次CPU access時都會先檢查TLB。如果TLB hit的話就只要一次reference就可以access到main memory了，如果TLB miss 的話代表兩種可能性，可能只是不在TLB裡面但是在Page table中有紀錄所以從page table中尋找，如果沒有的話代表就是此page entry根本不在main memory當中而在disk swap中也就是是page fault。

TLB跟cache的關係:

cache search is physical address:

cache search is virtual address:

TLB and Cache

Translation 在 TLB, 得到一個 physical address 後 那個東西已經在 cache內了 , 就不用去 main memory 拿. -> 不用任何的 memory access
另一個方法: 如果 cache 內是 virtual address的話, 那TLB就不需要去做 translation, 直接去 cache內找有沒有hit. 省去做 translation 的時間. (Cache is virtually indexed and virtually tagged)
Problem :
相同的 virtual address 會對應到不同的 physical addresses(consistency 問題) -> tag + process id
Synonym/alias problem : two different virtual addresses map to same physical address (需要hardware 支援)
所以基本上 cache 還是用 physical address -> Virtually Indexed but Physically Tagged (Overlapped Access).
解釋:

如果TLB hit是得到一個physical address，就去cache中拿，也就是說cache 去check的是physical address，經由這樣的搭配就不需要真的去memory拿。

在Cache內進行找data的address可以用physical address或者是virtual address，如果是physical的話，需要經過TLB or page table的translation 來把virtual 轉成physical然後再到cache內進行search，而如果是virtual的話，這狀況會希望成立是因為想要將TLB 與 Cache一起來get virtual address並同時做找到physical address及data，就不需要多run一層，但這會有問題會產生的，問題1:多個process的virtual address可能是一樣的但其data不見得是一樣的，解決辦法就是利用process都要一個id (pid)，加在tag中代表即使是相同的virtual address但未必有相同的data，問題2:兩個virtual address可能會對應到相同的physical address，由於cache內只是存main memory的copy，所以需要保持資料的一致性如果把其中一個update另外一個也需要做update(需要很多hardware去做這件事情)，所以解決辦法是Virtually index physically tag的方法。

Virtually index physically tag:

要讓page size夠大才能夠剛好match cache的index及byte offset，參考virtual address 轉physical address並搭配cache的圖(有兩個(cache是physical address,cache是virtual address)有關底下的pipt、vivit)。

vivt、pipt

Physically indexed, physically tagged (PIPT) caches use the physical address for both the index and the tag. While this is simple and avoids problems with aliasing, it is also slow, as the physical address must be looked up (which could involve a TLB miss and access to main memory) before that address can be looked up in the cache.
Virtually indexed, virtually tagged (VIVT) caches use the virtual address for both the index and the tag. This caching scheme can result in much faster lookups, since the MMU does not need to be consulted first to determine the physical address for a given virtual address. However, VIVT suffers from aliasing problems, where several different virtual addresses may refer to the same physical address. The result is that such addresses would be cached separately despite referring to the same memory, causing coherency problems. Another problem is homonyms, where the same virtual address maps to several different physical addresses. It is not possible to distinguish these mappings by only looking at the virtual index, though potential solutions include: flushing the cache after a context switch, forcing address spaces to be non-overlapping, tagging the virtual address with an address space ID (ASID), or using physical tags. Additionally, there is a problem that virtual-to-physical mappings can change, which would require flushing cache lines, as the VAs would no longer be valid.
Virtually indexed, physically tagged (VIPT) caches use the virtual address for the index and the physical address in the tag. The advantage over PIPT is lower latency, as the cache line can be looked up in parallel with the TLB translation, however the tag cannot be compared until the physical address is available. The advantage over VIVT is that since the tag has the physical address, the cache can detect homonyms. VIPT requires more tag bits, as the index bits no longer represent the same address.
Physically indexed, virtually tagged (PIVT) caches are only theoretical as they would basically be useless. A cache with this structure would be just as slow as PIPT, suffering from aliasing problems at the same time like VIVT.
參考維基

challenge in memory hierarchy(做memory常考慮的議題):

假設cache size變大，upper level可以容納更多的lower level(address,data)來降低miss rate，但產生的問題是access time會變長(變慢的意思)。
假設增加set-associative(2 way-> 4 way)，可以增加比較tag的空間不用常常做replacement想要降低miss rate ，但產生的問題是access time會變長(變慢的意思)。
假設block size變大，回想微笑曲線，目的是為了降低miss rate增加space 的 locality，但會產生增加miss penalty(搬進搬出需要搬很多東西)，因為cache 的size是固定的，當block size變大時裡面的number of block變少了，就需要常常做replacement。
以下此部分內容還要再搭配計結講義重新記錄:
cache control (CPU , cache, memory) 相關的cache FSM(Finite state machine)4 state狀態圖

cache coherence protocol :
問題來自現代是屬於一個processor裡面有多個core，每個都有cache之間data一致性的問題。
Snooping: Each cache monitors bus reads/writes (每個core都有它自己的cache control來去窺看別人有沒有update本身擁有的data，需要做更新)
Broadcasts an invalidate message on the bus.
理論與現實的結合:
現在的cache(3-level cache)、現在的TLB(2-level TLB) ARM-Cortex-A15 、Intel Haswell
multiple TLB: Similar to caches, TLBs may have multiple levels. CPUs can be (and nowadays usually are) built with multiple TLBs, for example a small “L1” TLB (potentially fully associative) that is extremely fast, and a larger “L2” TLB that is somewhat slower. When ITLB and DTLB are used, a CPU can have three (ITLB1, DTLB1, TLB2) or four TLBs.
參考
因為Out of order來彌補當cache miss的所造成miss penalty，才不致讓performance降低，思考write back是在pipeline的第幾個stage!!!第四個~and why?

多個core搭配cache的關係: 參考 參考

memory與OS的關係: 參考1

virtual memory : 參考

MMU: 參考

multiple TLB: 參考 參考

TLB TLB2 TLB3

pipeline的out of order

process 的virtual memory的一些概念stack(從高往低)、heap 、dynamic data(從低往高) ？!

要讀的網頁:

arm 公司簡介 arm與cortex的筆記

mtk資訊1 mtk資訊2 mtk資訊3 mtk資訊4 mtk_linkit_one Cortex-A7 架構

mtk的真八核 mt6592(八個Cortex-A7)，MT6592的安兔兔跑分成績接近30000分，既然A15和A7核心可以用ARM的“big.LITTLE”結構粘到一起，那麼LITTLE.LITTLE自然也是可以的——把兩組四核Cortex A7用膠水“粘”在一起，一顆八核處理器就誕生了（如果MTK願意，big.big想必也是沒什麼難度的）。因為這一代ARM處理器的一個多核心簇最多只能做4個同步運行的核心，超過四個核就必須用CCI-400匯流排這個“膠水”去連接才可以實現。從速度上來說，處理器內部的通信可要比額外的匯流排強多了。你完全可以把MT6592這個“八核”當成是“兩個四核”，它由兩個互相非同步的處理器簇構成，每個處理器簇內又包含了一個同步的四核心處理器，邏輯上確實夠複雜的。

ubuntu智慧型手機