Transcript C9_memory_hirarchy

‫היררכית הזיכרון‬
‫מבוסס על פרק ‪ 6‬של‬
‫‪Computer Systems – a programmers perspective / Bryant & O’hallrron‬‬
‫נושאים‬
‫‪ ‬טכנולוגיות זיכרון ומגמות‬
‫‪ ‬לוקאליות‬
‫‪ ‬זיכרון מטמון‬
‫)‪Random-Access Memory (RAM‬‬
‫‪ ‬יחידת זיכרון בסיסית נקראת 'תא' )‪ .(cell‬כל תא יכול לאחסן סיבית אחת‪.‬‬
‫)‪Static RAM (SRAM‬‬
‫‪ ‬אחסון הסיבית בעזרת מעגל עם ‪ 6‬טרנזיסטורים‪.‬‬
‫‪ ‬מאחסן את המידע באופן בלתי מוגבל‪ ,‬כל עוד מחובר לחשמל‬
‫‪ ‬יחסית לא רגיש להפרעות חשמליות‬
‫‪ ‬יקר יותר ומהיר יותר מ ‪DRAM‬‬
‫)‪Dynamic RAM (DRAM‬‬
‫‪ ‬אחסון הסיבית בעזרת קבל וטרנזיסטור‬
‫‪ ‬יש 'לחזק' מחדש את המידע כל ‪ 0.1‬שניות )‪.(refresh‬‬
‫‪ ‬רגיש להפרעות‬
‫‪ ‬איטי יותר וזול יותר מ ‪SRAM‬‬
‫–‪–2‬‬
SRAM vs DRAM :‫השוואה‬
Transis. Access
per bit
time
Persist? Sensitive?
Cost
Applications
SRAM
6
1X
Yes
No
100x
cache memories
DRAM
1
10X
No
Yes
1X
Main memories
–3–
‫נדיפים‬-‫זיכרונות לא‬
‫ מאבדים את המידע כשאין חשמל‬:‫ הם זיכרונות נדיפים‬SRAM ‫ ו‬DRAM 
read-only memory ‫ אשר באופן כללי נקראים‬,‫ יש גם זיכרונות לא נדיפים‬
(ROM)
.‫ ישנם זיכרונות כאלה שגם ניתן לכתוב אליהם‬:‫השם מטעה‬

:ROM ‫ סוגים של‬
Programmable ROM (PROM)
Eraseable programmable ROM (EPROM)

Electrically eraseable PROM (EEPROM)
)Flash memory( ‫זיכרונות הבזק‬



Firmware
ROM ‫מאחסנים תכנית ב‬
BIOS (basic input/output system) :‫ תוכניות העולות בזמן עליית המחשב‬
graphics cards, disk controllers. 
–4–

‫מגמות באחסון מידע‬
SRAM
DRAM
Disk
–5–
metric
1980
1985
1990
1995
2000
2000:1980
$/MB
access (ns)
19,200
300
2,900
150
320
35
256
15
100
2
190
100
metric
1980
1985
1990
1995
2000
2000:1980
$/MB
8,000
access (ns)
375
typical size(MB) 0.064
880
200
0.256
100
100
4
30
70
16
1
60
64
8,000
6
1,000
metric
1985
1990
1995
2000
2000:1980
100
75
10
8
28
160
0.30
10
1,000
0.05
8
9,000
10,000
11
9,000
1980
$/MB
500
access (ms)
87
typical size(MB) 1
CPU ‫מגמות בתדירות שעון של‬
processor
clock rate(MHz)
cycle time(ns)
–6–
1980
8080
1
1,000
1985
286
6
166
1990
386
20
50
1995
Pent
150
6
2000
P-III
750
1.6
2000:1980
750
750
‫ והזיכרון‬CPU ‫הפרש המהירויות בין ה‬
!‫ההפרש רק גדל עם השנים‬
100,000,000
10,000,000
1,000,000
Disk seek time
ns
100,000
DRAM access time
10,000
SRAM access time
1,000
CPU cycle time
100
10
1
1980
1985
1990
year
–7–
1995
2000
‫היררכית הזיכרון‬
‫מאפיינים בסיסיים‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫זיכרונות מהירים עולים יותר ביחס לנפח שלהם וקטנים יותר‪.‬‬
‫ההפרש במהירויות בין ‪ CPU‬למהירות הזיכרון רק מתרחב‬
‫לתוכניות כתובות היטב יש לוקאליות‬
‫מסיבות אלה‪ :‬הזיכרון מאורגן בצורה היררכית‬
‫–‪–8‬‬
‫דוגמה להיררכית הזיכרון‬
L0:
registers
,‫קטן יותר‬
,‫מהיר יותר‬
‫יקר יותר‬
L1:
L2:
L3:
,‫גדול יותר‬
,‫איטי יותר‬
‫זול יותר‬
L4:
CPU registers hold words retrieved
from L1 cache.
on-chip L1
cache (SRAM)
off-chip L2
cache (SRAM)
L1 cache holds cache lines retrieved
from the L2 cache memory.
L2 cache holds cache lines
retrieved from main memory.
main memory
(DRAM)
Main memory holds disk
blocks retrieved from local
disks.
local secondary storage
(local disks)
Local disks hold files
retrieved from disks on
remote network servers.
L5:
–9–
remote secondary storage
(distributed file systems, Web servers)
‫זיכרון מטמון ‪Cache‬‬
‫זיכרון מטמון‪ :‬זיכרון קטן ומהיר יותר שמשמש כ‪"-‬מבוא" לזיכרון גדול‬
‫ואיטי יותר‪.‬‬
‫לכל ‪ ,k‬ההתקן הקטן יותר ברמה ‪ k‬משמש כזיכרון מטמון של ההתקן‬
‫ברמה ‪ k+1‬בהיררכיה‪.‬‬
‫מדוע זה עובד טוב ?‬
‫‪ ‬תוכניות ניגשות למידע ברמה ‪ k‬יותר מאשר למידע ברמה ‪.k+1‬‬
‫‪ ‬התוצאה‪ :‬זיכרון גדול מאוחסן בזול (הרמות התחתונות)‪ ,‬אך יחד‬
‫עם זאת רב הגישות לזיכרון נעשות בצורה מהירה מאוד (הרמות‬
‫העליונות)‪.‬‬
‫– ‪– 10‬‬
‫העברת מידע בין רמות‬
‫מאחסן חלק מהמידע הנמצא ברמה הבאה‬
‫‪14‬‬
‫‪10‬‬
‫‪9‬‬
‫המידע המועבר הוא בגודל של בלוקים‬
‫סטנדרטיים‬
‫‪10‬‬
‫‪4‬‬
‫המידע מאוחסן בבלוקים‬
‫‪3‬‬
‫‪8‬‬
‫‪4‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪7‬‬
‫‪6‬‬
‫‪5‬‬
‫‪4‬‬
‫‪11‬‬
‫‪10‬‬
‫‪9‬‬
‫‪8‬‬
‫‪15‬‬
‫‪14‬‬
‫‪13‬‬
‫‪12‬‬
‫רמה ‪k‬‬
‫רמה ‪k+1‬‬
‫– ‪– 11‬‬
‫גודל הבלוק‬
‫לא קבוע בין רמות‪.‬‬
‫למשל‪ :‬האינפורמציה הדרושה לביצוע פקודה היא בדר"כ בין ‪ 1‬ל ‪16‬‬
‫בתים‪.‬‬
‫אך הזיכרון מחזיר ‪ cache-line‬שגודלו‪ ,‬תלוי במחשב הספציפי‪ ,‬יכול‬
‫להגיע למאות בתים‪ .‬מכאן נובעת החשיבות של הלוקאליות‪.‬‬
‫– ‪– 12‬‬
‫מבנה וגדלים של בלוקים להעברה בין רמות‬
‫רגיסטרים‪ :‬מספר קטן של‬
‫'מלים' בנות ‪ 4‬בתים‬
‫גודל בלוק להעברה‪ 4 :‬בתים‪.‬‬
‫ל ‪ L1‬יש מקום לשני בלוקים‪ ,‬כל‬
‫אחד בגודל ‪ 4‬מלים‪.‬‬
‫‪line 0‬‬
‫‪line 1‬‬
‫גודל בלוק להעברה‪ 4 :‬מלים‬
‫כל אחת בגודל ‪ 4‬בתים‪.‬‬
‫סה"כ ‪ 16‬בתים‪.‬‬
‫‪abcd‬‬
‫‪block 10‬‬
‫‪...‬‬
‫זיכרון ראשי‪ :‬מערך גדול‬
‫של בלוקים בגודל ‪ 4‬מלים‪.‬‬
‫‪pqrs‬‬
‫‪block 21‬‬
‫‪...‬‬
‫‪wxyz‬‬
‫‪block 30‬‬
‫‪...‬‬
‫– ‪– 13‬‬
‫מעבר המידע‬
‫תוכנית זקוקה לאובייקט ‪.d‬‬
‫‪Request‬‬
‫‪12‬‬
‫‪14‬‬
‫‪Cache hit‬‬
‫‪‬‬
‫התוכנית מוצאת את ‪ d‬ברמה ‪ ,k‬למשל בבלוק‬
‫‪.14‬‬
‫‪14‬‬
‫‪12‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪3‬‬
‫‪14‬‬
‫‪9‬‬
‫*‪4‬‬
‫‪12‬‬
‫‪Level‬‬
‫‪k:‬‬
‫‪Cache miss‬‬
‫‪‬‬
‫‪ d‬לא נמצא ברמה ‪ ,k‬אז צריך להביא אותו‬
‫מרמה ‪ .k+1‬נניח למשל שנמצא בבלוק ‪.12‬‬
‫‪‬‬
‫אם רמה ‪ k‬מלאה‪ ,‬אז צריך לפנות את אחד‬
‫מהבלוקים‪ .‬את מי נפנה ?‬
‫‪ ‬השיטה המקובלת‪ :‬נפנה את הבלוק‬
‫שהשתמשו בו לפני הזמן הרב ביותר‬
‫)‪(LRU – least recently used‬‬
‫‪Request‬‬
‫‪12‬‬
‫‪12‬‬
‫*‪4‬‬
‫‪3‬‬
‫‪2‬‬
‫‪1‬‬
‫‪0‬‬
‫‪7‬‬
‫‪6‬‬
‫‪5‬‬
‫‪4‬‬
‫*‪4‬‬
‫‪11‬‬
‫‪10‬‬
‫‪9‬‬
‫‪8‬‬
‫‪15‬‬
‫‪14‬‬
‫‪13‬‬
‫‪12‬‬
‫‪Level‬‬
‫‪k+1:‬‬
‫– ‪– 14‬‬
‫זיכרון מטמון – "פספוסים"‬
‫סוגים של ‪:cache misses‬‬
‫‪cold miss ‬‬
‫‪‬‬
‫זיכרון המטמון ריק‬
‫‪Capacity miss ‬‬
‫‪ ‬זיכרון המטמון קטן מדי‪ :‬התוכנית זקוקה למידע זמין רב יותר מגודל זיכרון‬
‫המטמון‪.‬‬
‫‪Conflict miss ‬‬
‫‪‬‬
‫בדר"כ הזיכרון ברמה ‪ k‬מגביל את המיקום של הבלוקים מרמה ‪.k+1‬‬
‫למשל בלוק ‪ i‬מרמה ‪ k+1‬יוצב בבלוק ‪ i mod 4‬ברמה ‪.k‬‬
‫‪ ‬למה ? למשל מאיץ את תהליך העדכון בכיוון ההפוך‬
‫‪‬‬
‫ייתכן שלמרות שרמה ‪ k‬מספיקה לתוכנית הנוכחית‪ ,‬המידע שהיא זקוקה‬
‫לו ממופה לאותו בלוק ברמה ‪ .k‬למשל פניה לבלוקים ‪ 0,8,0,8,0,8‬תפספס‬
‫כל פעם‪.‬‬
‫– ‪– 15‬‬
‫מדדים לביצועים של זיכרון מטמון‬
‫‪Miss Rate‬‬
‫‪ ‬מספר הפעמים שהמידע לא נמצא ב ‪ / cache‬מספר הפניות לזיכרון‪.‬‬
‫‪ ‬מספרים אופייניים‪:‬‬
‫‪3-10% for L1‬‬
‫יכול להיות פחות מ ‪ 1%‬ב ‪ ,L2‬אך תלוי בגורמים רבים‪.‬‬
‫‪Hit Time‬‬
‫‪‬‬
‫‪‬‬
‫הזמן הלוקח להעביר שורה מה ‪ cache‬למעבד (כולל הזמן לקבוע אם‬
‫המידע נמצע שם)‬
‫מספרים אופייניים‪:‬‬
‫‪1 clock cycle for L1 ‬‬
‫‪3-8 clock cycles for L2 ‬‬
‫‪Miss Penalty‬‬
‫‪‬‬
‫הזמן הנוסף הנדרש כשהמידע לא ב ‪.cache‬‬
‫‪ ‬בדר"כ ‪ 25-100 cycles‬כשהמידע המבוקש בזיכרון הראשי‪.‬‬
‫– ‪– 16‬‬
‫ בהיררכית הזיכרון‬cache ‫סוגי‬
Cache Type
What Cached
Where Cached
Registers
4-byte word
CPU registers
0 Compiler
TLB
Address
translations
32-byte block
32-byte block
4-KB page
On-Chip TLB
0 Hardware
On-Chip L1
Off-Chip L2
Main memory
Parts of files
Main memory
1 Hardware
10 Hardware
100 Hardware+
OS
100 OS
L1 cache
L2 cache
Virtual
Memory
Buffer cache
Network buffer Parts of files
cache
Browser cache Web pages
Local disk
Web cache
Remote server
disks
– 17 –
Web pages
Local disk
Latency
(cycles)
Managed
By
10,000,000 AFS/NFS
client
10,000,000 Web
browser
1,000,000,000 Web proxy
server
‫לוקאליות (‪)Locality‬‬
‫העיקרון של לוקאליות‪:‬‬
‫‪ ‬תוכניות נוטות לשוב ולהשתמש במידע שהשתמשו בו לאחרונה או‬
‫שנמצא (פיזית) ליד מידע זה‪.‬‬
‫‪ ‬לוקאליות של זמן )‪ :(temporal locality‬מידע שהשתמשנו בו‬
‫לאחרונה‪ ,‬קרוב לוודאי שנשתמש בו שוב בקרוב‪.‬‬
‫‪ ‬לוקאליות של מקום )‪ :(spatial locality‬קרוב לודאי שעוד מעט נפנה‬
‫למידע שנמצא קרוב למידע שהשתמשנו בו זה עתה‪.‬‬
‫– ‪– 18‬‬
‫לוקאליות‬
‫;‪sum = 0‬‬
‫)‪for (i = 0; i < n; i++‬‬
‫;]‪sum += a[i‬‬
‫;‪return sum‬‬
‫דוגמאות ללוקאליות‪:‬‬
‫• מידע‬
‫לוקאליות מקום‬
‫• נפנה לאיברי מערך אחד אחרי השני‬
‫לוקאליות זמן‬
‫• בכל פעם נפנה ל ‪sum‬‬
‫• פקודות‬
‫לוקאליות מקום‬
‫• נפנה לפקודות הכתובות ברשימה – זו אחר זו‪.‬‬
‫לוקאליות זמן‬
‫• שוב ושוב נסתובב בלולאה ‪while‬‬
‫– ‪– 19‬‬
‫דוגמה ללוקאליות‬
.‫זיהוי לוקאליות היא דרישה חשובה ממתכנת מקצועי‬
?‫לאיזה תוכנית יש לוקאליות טובה יותר‬
int sumarrayrows(int a[M][N])
{
int i, j, sum = 0;
int sumarraycols(int a[M][N])
{
int i, j, sum = 0;
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
sum += a[i][j];
return sum
}
– 20 –
for (j = 0; j < N; j++)
for (i = 0; i < M; i++)
sum += a[i][j];
return sum
}
cache ‫כתיבת קוד יעיל בהקשר של ה‬
)temporal locality( ‫גישה לאותו משתנה בהפרש זמנים קצר היא יעילה‬
‫גישה למשתנים קרובים בזיכרון (למשל איברים רצופים במערך) היא יעילה‬
(spatial locality)
:‫דוגמאות‬

cold cache, 4-byte words, 4-word cache blocks
int sumarrayrows(int a[M][N])
{
int i, j, sum = 0;
int sumarraycols(int a[M][N])
{
int i, j, sum = 0;
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
sum += a[i][j];
return sum;
}
}
Miss rate = 1/4 = 25%
– 21 –
for (j = 0; j < N; j++)
for (i = 0; i < M; i++)
sum += a[i][j];
return sum;
Miss rate = 100%
‫דוגמה ללוקאליות‬
? ‫מה צריך לעשות בשביל לשפר את התוכנית הבאה‬
int sumarray3d(int a[M][N][N])
{
int i, j, k, sum = 0;
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
for (k = 0; k < N; k++)
sum += a[k][i][j];
return sum
}
– 22 –