memory hierarchy caching
play

Memory Hierarchy & Caching CS 351: Systems Programming Michael - PowerPoint PPT Presentation

Jan 12, 2023 •294 likes •1.85k views

Memory Hierarchy & Caching CS 351: Systems Programming Michael Saelee <lee@iit.edu> Computer Science Science Why skip from process mgmt to memory?! - recall: kernel facilitates process execution - via numerous abstractions -

  1. Computer Science Science Modern DRAM is designed to transfer 
 bursts of data (~32-64 bytes) efficiently Cache 100001060 01000000 02000000 03000000 04000000 100001070 05000000 06000000 07000000 08000000 100001080 09000000 0a000000 idea: transfer array from memory to cache 
 on accessing first item , then only access cache!

  2. Computer Science Science 2. where to store cached data? 
 i.e., how to map address k → cache slot

  3. Computer Science Science §Cache Organization

  4. Computer Science Science Memory address 0 1 2 3 Cache index 4 0 5 1 6 2 7 3 8 9 10 11 12 13 14 15

  5. Computer Science Science Memory address 0 1 2 3 Cache index 4 0 5 ? 1 6 2 7 3 8 x 9 10 11 12 13 14 15

  6. Computer Science Science Memory address 0 1 2 3 Cache index 4 0 5 1 6 2 7 3 8 x 9 10 11 12 13 14 15

  7. Computer Science Science Memory address 0 1 2 3 Cache index 4 0 5 1 6 2 7 3 8 x 9 10 11 12 13 14 15

  8. Computer Science Science Memory address 0 1 2 3 Cache index 4 0 5 1 6 2 7 3 8 x 9 10 11 12 index = address mod ( # cache lines ) 13 14 15

  9. Computer Science Science Memory address 0 1 2 3 Cache index 4 0 5 1 6 2 7 3 8 x 9 10 11 12 index = address mod ( # cache lines ) 13 14 15

  10. Computer Science Science Memory address 0000 00 01 0010 0011 Cache index 0100 00 01 01 01 0110 10 0111 11 1000 x 10 01 1010 equivalently, in binary: 1011 for a cache with 2 n lines, 1100 11 01 index = lower n bits of address 1110 1111

  11. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 0011 Cache index 0100 00 0101 01 0110 10 0111 11 1000 1001 each address is mapped 1010 1011 to a single, unique line 1100 1101 in the cache 1110 1111

  12. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 0011 Cache index 0100 00 0101 x 01 0110 10 0111 11 1000 x 1001 1010 e.g., request for memory 
 1011 1100 address 1001 1101 1110 → DRAM access 1111

  13. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 0011 Cache index 0100 00 0101 x 01 0110 10 0111 11 1000 x 1001 1010 e.g., repeated request for 
 1011 1100 address 1001 1101 1110 → cache “hit” 1111

  14. Computer Science Science Memory address 0000 0001 0010 0011 Cache index 0100 00 0101 01 0110 10 0111 11 1000 x 1001 alternative mapping: 1010 1011 for a cache with 2 n lines, 1100 index = upper n bits of address 1101 — pros/cons? 1110 1111

  15. Computer Science Science Memory address 0000 0001 0010 0011 Cache index 0100 00 0101 01 0110 10 0111 vie for the 11 1000 x same line 1001 y (“cache alternative mapping: 1010 collision”) 1011 for a cache with 2 n lines, 1100 index = upper n bits of address 1101 — defeats spatial locality! 1110 1111

  16. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 0011 Cache index 0100 00 0101 x 01 0110 10 0111 11 1000 1001 1010 reverse mapping : where 1011 1100 did x come from? (and is 1101 it valid data or garbage?) 1110 1111

  17. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 Cache 0011 index valid tag data 0100 00 0101 x 01 0110 10 0111 11 1000 1001 1010 must add some fields 1011 - tag field: top part of 
 1100 1101 mapped address 1110 1111 - valid bit : is it valid?

  18. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 Cache 0011 index valid tag data 0100 00 0101 x 1 10 01 0110 10 0111 11 1000 1001 1010 10 | 01 1011 1100 i.e., x “belongs to” 1101 1110 address 1001 1111

  19. Computer Science Science Memory address 0000 1) direct mapping 0001 0010 Cache 0011 index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 z 0 01 11 1000 1001 1010 assuming memory 
 1011 & cache are in sync, 
 1100 1101 “fill in” memory 1110 1111

  20. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 z 0 01 11 1000 1001 1010 assuming memory 
 1011 & cache are in sync, 
 1100 x 1101 “fill in” memory 1110 1111

  21. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 z 0 01 11 1000 1001 1010 what if new request 
 a 1011 arrives for 1011 ? 1100 x 1101 1110 1111

  22. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 a 1 10 11 1000 1001 1010 what if new request 
 a 1011 arrives for 1011 ? 1100 x 1101 - cache “miss” : fetch a 1110 1111

  23. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 a 1 10 11 1000 1001 1010 what if new request 
 a 1011 arrives for 0010 ? 1100 x 1101 1110 1111

  24. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 a 1 10 11 1000 1001 1010 what if new request 
 a 1011 arrives for 0010 ? 1100 x 1101 - cache “hit” ; just return y 1110 1111

  25. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 w 1 01 00 0101 x 1 11 01 0110 y 1 00 10 0111 a b 1 10 11 1000 1001 1010 what if new request 
 a 1011 arrives for 1000 ? 1100 x 1101 1110 1111

  26. Computer Science Science Memory address 0000 1) direct mapping 0001 y 0010 Cache 0011 w index valid tag data 0100 b 1 10 00 0101 x 1 11 01 0110 y 1 00 10 0111 a b 1 10 11 1000 1001 1010 what if new request 
 a 1011 arrives for 1000 ? 1100 x 1101 - evict old mapping to 
 1110 1111 make room for new

  27. Computer Science Science 1) direct mapping - implicit replacement policy — always keep most recently accessed data for a given cache line - motivated by temporal locality

  28. Computer Science Science Requests Initial Cache address hit/miss? index valid tag 0x89 000 0 00101 0xAB 001 0 10010 0x60 010 0 00010 0xAB 011 1 10101 0x83 100 1 00000 0x67 101 0 10011 0xAB 110 1 11110 0x12 111 1 11001 Given initial contents of a direct-mapped 
 cache, determine if each request is a hit 
 or miss . Also, show the final cache.

  29. Computer Science Science Problem: our cache (so far) implicitly deals with single bytes of data at a time But we frequently deal with main() { int n = 10; > 1 byte of data at a time 
 int fact = 1; while (n>1) { (e.g., words) fact *= n; n -= 1; } }

  30. Computer Science Science Solution: adjust minimum granularity 
 of memory ⇔ cache mapping Use a “cache block ” of 2 b bytes † memory remains byte-addressable!

  31. Computer Science Science Memory e.g., block size = 2 bytes 0000 total # lines = 4 0001 0010 Cache 0011 index 0100 00 0101 01 0110 10 0111 11 1000 1001 With a 2 b block size, lower 
 1010 1011 b bits of address constitute 
 1100 1101 the cache block offset field 1110 1111

  32. Computer Science Science Memory e.g., block size = 2 bytes 0000 total # lines = 4 0001 0010 Cache index valid tag 0011 0100 00 0101 01 x 0110 10 y y x 1 0 0111 11 1000 e.g., address 0110 1001 1010 1011 tag field 1100 index 1101 log 2 ( # lines ) bits wide 1110 block offset 1111 log 2 ( block size ) bits wide

  33. Computer Science Science e.g., cache with 2 10 lines of 4-byte blocks tag index 20 10 2 Word Index V Tag 0 1 2 ... data 32 ... ... 1021 1022 1023 = hit

  34. Computer Science Science note: words in memory should be aligned ; i.e., they start at addresses that are 
 multiples of the word size otherwise, must fetch > 1 word-sized block to access a single word! unaligned word w 0 w 1 w 2 2 cache lines w 3

  35. 
 Computer Science Science struct foo { char c; int i; char buf[10]; long l; }; struct foo f = { 'a', 0xDEADBEEF, "abcdefghi", 0x123456789DEFACED }; main() { printf("%d %d %d\n", sizeof(int), sizeof(long), sizeof(struct foo)); } $ ./a.out 4 8 32 $ objdump -s -j .data a.out a.out: file format elf64-x86-64 Contents of section .data: 61000000 efbeadde 61626364 65666768 a.......abcdefgh 69000000 00000000 edacef9d 78563412 i...........xV4. (i.e., C auto-aligns structure components)

  36. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret Given: direct-mapped cache with 4-byte blocks . Determine the average hit rate of strlen 
 (i.e., the fraction of cache hits to total requests)

  37. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret Assumptions: - ignore code caching (in separate cache) - buf contents are not initially cached

  38. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 strlen( ) a \0 strlen( ) a b c d e \0 strlen( ) a b c d e f g h i j k l ...

  39. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 strlen( ) a \0 strlen( ) a b c d e \0 strlen( ) a b c d e f g h i j k l ...

  40. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 or, if unlucky : strlen( ) a \0 a \0 strlen( ) a b c d e \0 strlen( ) a b c d e f g h i j k l ...

  41. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 or, if unlucky : strlen( ) a \0 a \0 — simplifying assumption: first byte of 
 buf is aligned

  42. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 strlen( ) a \0 strlen( ) a b c d e \0 strlen( ) a b c d e f g h i j k l ...

  43. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 strlen( ) a \0 strlen( ) a b c d e \0 strlen( ) a b c d e f g h i j k l ...

  44. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) \0 strlen( ) a \0 strlen( ) a b c d e \0 strlen( ) a b c d e f g h i j k l ...

  45. Computer Science Science strlen: ; buf in %rdi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; result = 0 int strlen(char *buf) { cmpb $0x0,(%rdi) ; if *buf == 0 int result = 0; je 0x10000500 ; return 0 while (*buf++) add $0x1,%rdi ; buf += 1 result++; add $0x1,%eax ; result += 1 return result; movzbl (%rdi) ,%edx ; %edx = *buf } add $0x1,%rdi ; buf += 1 test %dl,%dl ; if %edx[0] ≠ 0 jne 0x1000004f2 ; loop popq %rbp ret strlen( ) a b c d e f g h i j k l ... In the long run, hit rate = ¾ = 75%

  46. Computer Science Science sum: ; arr,n in %rdi,%rsi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; r = 0 int sum(int *arr, int n) { test %esi,%esi ; if n == 0 int i, r = 0; jle 0x10000527 ; return 0 for (i=0; i<n; i++) sub $0x1,%esi ; n -= 1 r += arr[i]; lea 0x4(,%rsi,4),%rcx ; %rcx = 4*n+4 return r; mov $0x0,%edx ; %rdx = 0 } add (%rdi,%rdx,1),%eax ; r += arr[%rdx] add $0x4,%rdx ; %rdx += 4 cmp %rcx,%rdx ; if %rcx == %rdx jne 0x1000051b ; return r popq %rbp ret Again: direct-mapped cache with 4-byte blocks . Average hit rate of sum ? ( arr not cached)

  47. Computer Science Science sum: ; arr,n in %rdi,%rsi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; r = 0 int sum(int *arr, int n) { test %esi,%esi ; if n == 0 int i, r = 0; jle 0x10000527 ; return 0 for (i=0; i<n; i++) sub $0x1,%esi ; n -= 1 r += arr[i]; lea 0x4(,%rsi,4),%rcx ; %rcx = 4*n+4 return r; mov $0x0,%edx ; %rdx = 0 } add (%rdi,%rdx,1),%eax ; r += arr[%rdx] add $0x4,%rdx ; %rdx += 4 cmp %rcx,%rdx ; if %rcx == %rdx jne 0x1000051b ; return r popq %rbp ret sum( 01 00 00 00 02 00 00 00 03 00 00 00 , 3)

  48. Computer Science Science sum: ; arr,n in %rdi,%rsi pushq %rbp movq %rsp,%rbp mov $0x0,%eax ; r = 0 int sum(int *arr, int n) { test %esi,%esi ; if n == 0 int i, r = 0; jle 0x10000527 ; return 0 for (i=0; i<n; i++) sub $0x1,%esi ; n -= 1 r += arr[i]; lea 0x4(,%rsi,4),%rcx ; %rcx = 4*n+4 return r; mov $0x0,%edx ; %rdx = 0 } add (%rdi,%rdx,1),%eax ; r += arr[%rdx] add $0x4,%rdx ; %rdx += 4 cmp %rcx,%rdx ; if %rcx == %rdx jne 0x1000051b ; return r popq %rbp ret sum( 01 00 00 00 02 00 00 00 03 00 00 00 , 3) each block is a miss! (hit rate=0%)

  49. Computer Science Science use multi-word blocks to help with larger array strides (e.g., for word-sized data)

  50. Computer Science Science e.g., cache with 2 8 lines of 2 × 4 byte blocks 21 8 3 32-bit address: Block of 2 × 4 bytes = 2 3 bytes V Tag b 0 b 1 b 2 b 3 b 4 b 5 b 6 b 7 0 1 2 ... 2 8 lines ... 254 255 = Mux hit data

  51. Computer Science Science Cache Index Tag Valid Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 0 173 1 05 E2 6C 05 3B 53 0C 8E 1 2FB 1 9B 26 58 E0 EB 05 4A 4C 2 316 0 F8 3E 29 92 B2 52 B9 2E 3 03A 1 95 07 51 3F 7B 00 DA AC 4 1B9 0 9A AB 9E E3 20 03 C0 06 5 2C2 1 FB 7C EC 25 C8 2B 3E D6 6 315 1 E0 05 FB E8 72 79 BE D4 7 2C7 1 45 2D 92 74 C8 CB 92 85 Are the following (byte) requests hits? 
 If so, what data is returned by the cache? 1. 0x0E9C 2. 0xBEF0

  52. Computer Science Science Cache Index Tag Valid Byte 0 Byte 1 Byte 2 Byte 3 Byte 4 Byte 5 Byte 6 Byte 7 0 173 1 05 E2 6C 05 3B 53 0C 8E 1 2FB 1 9B 26 58 E0 EB 05 4A 4C 2 316 0 F8 3E 29 92 B2 52 B9 2E 3 03A 1 95 07 51 3F 7B 00 DA AC 4 1B9 0 9A AB 9E E3 20 03 C0 06 5 2C2 1 FB 7C EC 25 C8 2B 3E D6 6 315 1 E0 05 FB E8 72 79 BE D4 7 2C7 1 45 2D 92 74 C8 CB 92 85 What happens when we receive the following sequence of requests? - 0x9697A , 0x3A478 , 0x34839 , 0x3A478 , 0x9697B , 0x3483A

  53. Computer Science Science problem: when a cache collision occurs, we must evict the old (direct) mapping — no way to use a different cache slot

  54. Computer Science Science Memory address 0000 2) associative mapping 0001 0010 0011 Cache index 0100 00 0101 ? 01 0110 10 0111 11 1000 x 1001 1010 e.g., request for memory 
 1011 1100 address 1001 1101 1110 1111

  55. Computer Science Science Memory address 0000 2) associative mapping 0001 0010 0011 Cache index 0100 any! 00 0101 01 0110 10 0111 11 1000 x 1001 1010 e.g., request for memory 
 1011 1100 address 1001 1101 1110 1111

  56. Computer Science Science Memory address 0000 2) associative mapping 0001 0010 Cache 0011 index valid tag data 0100 x 1 1001 00 0101 01 0110 10 0111 11 1000 x 1001 use the full address 1010 as the “tag” 1011 1100 - effectively a hardware 
 1101 1110 lookup table 1111

  57. Computer Science Science Memory address 0000 2) associative mapping w 0001 0010 Cache 0011 index valid tag data 0100 x z 1 1001 00 0101 y 1 1100 01 0110 w 1 0001 10 0111 z 1 0101 11 1000 x 1001 - can accommodate 
 1010 1011 y requests = # lines 
 1100 1101 without conflict 1110 1111

  58. Computer Address Science Science 30 2 V Tag Data word = = = = Hit Mux Data = 32 = = = 3 8x3 Encoder comparisons done in parallel (h/w): fast!

  59. Computer Science Science Memory address 0000 2) associative mapping w 0001 0010 Cache 0011 index valid tag data 0100 x z 1 1001 00 0101 y 1 1100 01 0110 w a 1 0001 10 0111 z 1 0101 11 1000 x 1001 - resulting ambiguity: 
 1010 1011 what to do with a new 
 y 1100 1101 request? (e.g., 0111 ) 1110 1111

  60. Computer Science Science associative caches require a replacement policy to decide which slot to evict, e.g., - FIFO (oldest is evicted) - least frequently used (LFU) - least recently used (LRU)

  61. Computer Science Science Memory address 0000 e.g., LRU replacement w 0001 0010 Cache 0011 index valid tag data 0100 z 00 0101 01 0110 a 10 0111 11 1000 x - requests: 0101 , 1001 
 1001 b 1010 1100 , 0001 
 1011 y 1100 1010 , 1001 
 1101 0111,0001 
 1110 1111

Recommend

EE 457 Unit 7a Cache and Memory Hierarchy 2 Memory Hierarchy &amp; Caching Use several

EE 457 Unit 7a Cache and Memory Hierarchy 2 Memory Hierarchy &amp; Caching Use several

1 EE 457 Unit 7a Cache and Memory Hierarchy 2 Memory Hierarchy &amp; Caching Use several levels of faster and faster memory to hide delay of upper levels More Smaller Faster Expensive Unit of Transfer: Word, Half, or Byte (LW, LH, LB

515 views • 40 slides
Abstractions for Practical Systems Caching and the memory hierarchy Operating systems and the

Abstractions for Practical Systems Caching and the memory hierarchy Operating systems and the

CS 240 Stage 3 Abstractions for Practical Systems Caching and the memory hierarchy Operating systems and the process model Virtual memory Dynamic memory allocation Victory lap Memory Hierarchy: Cache Memory hierarchy Cache basics Locality

1.02k views • 49 slides
I/O Caching and Page Replacement I/O Caching and Page Replacement Memory/Storage Hierarchy 101

I/O Caching and Page Replacement I/O Caching and Page Replacement Memory/Storage Hierarchy 101

I/O Caching and Page Replacement I/O Caching and Page Replacement Memory/Storage Hierarchy 101 Memory/Storage Hierarchy 101 Very fast 1ns clock P Multiple Instructions SRAM, Fast, Small per cycle Expensive (cache, registers) $ CPU-DRAM

479 views • 14 slides
1 Memory Read Transaction (1) Memory Read Transaction (2) CPU places address A on the memory

1 Memory Read Transaction (1) Memory Read Transaction (2) CPU places address A on the memory

Today Storage technologies and trends Locality of reference The Memory Hierarchy Caching in the memory hierarchy CSci 2021: Machine Architecture and Organization November 5th-7th, 2018 Your instructor: Stephen McCamant Based on

368 views • 11 slides
1 Memory Read Transaction (1) Memory Read Transaction (2) CPU places address A on the memory

1 Memory Read Transaction (1) Memory Read Transaction (2) CPU places address A on the memory

Today Storage technologies and trends Locality of reference The Memory Hierarchy Caching in the memory hierarchy CSci 2021: Machine Architecture and Organization March 30th-April 1st, 2020 Your instructor: Stephen McCamant Based on

637 views • 10 slides
Memory Hierarchy: Caching CSE 141, S2'06 Jeff Brown The memory subsystem Computer Control

Memory Hierarchy: Caching CSE 141, S2'06 Jeff Brown The memory subsystem Computer Control

Memory Hierarchy: Caching CSE 141, S2'06 Jeff Brown The memory subsystem Computer Control Input Memory Output Datapath CSE 141, S2'06 Jeff Brown Memory Locality Memory hierarchies take advantage of memory locality . Memory

337 views • 33 slides
Caching in the Memory Hierarchy: 5 Minutes Ought to Be Enough for Everybody Anastasia Ailamaki

Caching in the Memory Hierarchy: 5 Minutes Ought to Be Enough for Everybody Anastasia Ailamaki

Caching in the Memory Hierarchy: 5 Minutes Ought to Be Enough for Everybody Anastasia Ailamaki with Raja Appuswamy, Renata Borovica, Manos Karpathiotakis, Tahir Azim, Matt Olma, Manos Athanassoulis, Yannis Alagiannis, and Goetz Graefe The

530 views • 40 slides
1 Basic use of caches Levels in the memory hierarchy When fetching an instruction, first

1 Basic use of caches Levels in the memory hierarchy When fetching an instruction, first

Memory Hierarchy Goal of a memory hierarchy Memory: hierarchy of components of various speeds and Keep close to the ALU the information that will be needed capacities now and in the near future Memory closest to ALU is fastest but

56 views • 5 slides
The Memory Hierarchy Today Storage technologies and trends Locality of reference

The Memory Hierarchy Today Storage technologies and trends Locality of reference

The Memory Hierarchy Today Storage technologies and trends Locality of reference Caching in the memory hierarchy Next time Cache memory Chris Riesbeck, Spring 2010 Original: Fabian Bustamante Saturday, October 29, 2011

849 views • 45 slides
Elastic Cooperative Caching: An Autonomous Dynamically Adaptive Memory Hierarchy for Chip

Elastic Cooperative Caching: An Autonomous Dynamically Adaptive Memory Hierarchy for Chip

ACM IEEE 37 th International Symposium on Computer Architecture Elastic Cooperative Caching: An Autonomous Dynamically Adaptive Memory Hierarchy for Chip Multiprocessors Enric Herrero, Jos Gonzlez, Ramon Canal Universitat

455 views • 19 slides
Memory Hierarchy &amp; Caching Use several levels of faster and faster memory to hide delay of

Memory Hierarchy &amp; Caching Use several levels of faster and faster memory to hide delay of

7a.1 7a.2 Memory Hierarchy &amp; Caching Use several levels of faster and faster memory to hide delay of upper levels EE 457 Unit 7a Unit of Transfer: Word, Half, or Byte (LW, LH, LB or SW, SH, SB) Registers L1 Cache ~ 1ns Cache and

492 views • 10 slides
Memory Hierarchy Chapter 6 1 Outline Storage technologies and

Memory Hierarchy Chapter 6 1 Outline Storage technologies and

The Memory Hierarchy Chapter 6 1 Outline Storage technologies and trends Locality of reference Caching in the memory hierarchy 2 Random-Access

1.17k views • 73 slides
IC220 Caching 2: Memory Hierarchy (more from Chapter 5 - specifically 5.7, 5.8) 1 Cache design

IC220 Caching 2: Memory Hierarchy (more from Chapter 5 - specifically 5.7, 5.8) 1 Cache design

IC220 Caching 2: Memory Hierarchy (more from Chapter 5 - specifically 5.7, 5.8) 1 Cache design overview ANY cache can be viewed as k-way associative. What are the pros and cons of each? Fully associative: k = N/B 4-way set

335 views • 21 slides
Final Exam Review CS 351: Systems Programing Michael Saelee &lt;lee@iit.edu&gt; Coverage -

Final Exam Review CS 351: Systems Programing Michael Saelee &lt;lee@iit.edu&gt; Coverage -

Final Exam Review CS 351: Systems Programing Michael Saelee &lt;lee@iit.edu&gt; Coverage - Memory hierarchy - Caching - Virtual Memory - Dynamic Memory Allocation - Garbage Collection - I/O Memory Hierarchy - types &amp; relative speeds

546 views • 9 slides
Memory Hierarchy Motivation, Definitions, Four Questions about Memory Hierarchy Soner Onder

Memory Hierarchy Motivation, Definitions, Four Questions about Memory Hierarchy Soner Onder

Memory Hierarchy Motivation, Definitions, Four Questions about Memory Hierarchy Soner Onder Michigan Technological University Randy Katz &amp; David A. Patterson University of California, Berkeley Levels in a memory hierarchy 2 Basic

524 views • 21 slides
1 5.1 Introduction A Typical Memory Hierarchy A Typical Memory Hierarchy Memory Technology

1 5.1 Introduction A Typical Memory Hierarchy A Typical Memory Hierarchy Memory Technology

Review: Major Components of a Computer Review: Major Components of a Computer Processor Devices Memory Memory Control Hierarchy Hierarchy Input Memory Datapath Output Original slides from: Computer Architecture A Quantitative

447 views • 10 slides
Memory Hierarchy Design Memory Hierarchy Design Chapter 5 and Appendix C 1 Overview

Memory Hierarchy Design Memory Hierarchy Design Chapter 5 and Appendix C 1 Overview

Memory Hierarchy Design Memory Hierarchy Design Chapter 5 and Appendix C 1 Overview Problem CPU vs Memory performance imbalance Solution Driven by temporal and spatial locality Memory hierarchies Memory hierarchies

733 views • 55 slides
What Is Memory Hierarchy A typical memory hierarchy today: Lecture 13: Cache Basics and Cache

What Is Memory Hierarchy A typical memory hierarchy today: Lecture 13: Cache Basics and Cache

What Is Memory Hierarchy A typical memory hierarchy today: Lecture 13: Cache Basics and Cache Performance Proc/Regs L1-Cache Bigger Faster L2-Cache Memory hierarchy concept, cache L3-Cache (optional) design fundamentals, set-associative

303 views • 4 slides
1 5.1 Introduction A Typical Memory Hierarchy Memory Technology q Take advantage of the

1 5.1 Introduction A Typical Memory Hierarchy Memory Technology q Take advantage of the

Review: Major Components of a Computer Processor Devices Memory Control Hierarchy Input Memory Datapath Output Original slides from: Computer Architecture A Quantitative Approach Hennessy, Patterson Memory Main Cache Secondary

388 views • 10 slides
Data Management Systems Storage Management The Memory hierarchy Memory hierarchy

Data Management Systems Storage Management The Memory hierarchy Memory hierarchy

Data Management Systems Storage Management The Memory hierarchy Memory hierarchy Capacity and latencies Segments and file storage Locality and replacement policies Database buffer cache Hardware evolution Storage

546 views • 18 slides
Virtual Memory 1 Memory Hierarchy Memory 4GB Cache 1M Registers 1K Question: What if

Virtual Memory 1 Memory Hierarchy Memory 4GB Cache 1M Registers 1K Question: What if

Virtual Memory 1 Memory Hierarchy Memory 4GB Cache 1M Registers 1K Question: What if we want to run a process that requires 10GB memory? 2 Memory Hierarchy Virtual Memory Memory Cache Registers Answer: Pretend we had something

737 views • 45 slides
Memory Hierarchy Design Issues Memory Hierarchy Design Issues in Many in Many-Core Processors

Memory Hierarchy Design Issues Memory Hierarchy Design Issues in Many in Many-Core Processors

Memory Hierarchy Design Issues Memory Hierarchy Design Issues in Many in Many-Core Processors -Core Processors Sangye Sangyeun Cho un Cho Dept. of Computer Scien Dept. of Com uter Science Uni Univer ersi sity o of Pi Pitt ttsb

563 views • 31 slides
Caching, Parallelism, Fault Tolerance Marco Serafini COMPSCI 532 Lectures 2-3 Memory Hierarchy

Caching, Parallelism, Fault Tolerance Marco Serafini COMPSCI 532 Lectures 2-3 Memory Hierarchy

Caching, Parallelism, Fault Tolerance Marco Serafini COMPSCI 532 Lectures 2-3 Memory Hierarchy Multi-Core Processors Processor (chip) Processor (chip) Processor (chip) core core core core core core core core core core core

1.04k views • 53 slides
Why memory hierarchy (3 rd Ed: p.468-487, 4 th Ed: p. 452-470) users want unlimited fast

Why memory hierarchy (3 rd Ed: p.468-487, 4 th Ed: p. 452-470) users want unlimited fast

Why memory hierarchy (3 rd Ed: p.468-487, 4 th Ed: p. 452-470) users want unlimited fast memory fast memory expensive, slow memory cheap cache: small, fast memory near CPU large, slow memory (main memory, disk, )

387 views • 23 slides

More recommend