The Random Access Machine

EECS 214, Fall 2015

Some definitions

// Java
  
class Posn { int x, y; }
/* C, C++ */
struct PosnStruct { int x, y; }
typedef struct PosnStruct* Posn
# Ruby
Posn = Struct.new('Posn', :x, :y)
# Python
from collections import namedtuple
Posn = namedtuple('Posn', 'x y')

0x08000x08300x08600x0890
+0032 Posn.class0x0860
+0432 30x0000
+08 40x0870
+0c0x0860  0x0870
+100x0000int[].classPosn.class 
+140x084055 
+180x0888112 
+1c 4  
+20 9  
+24 16  
+28 49Posn[].class 
+2c  4 
0x08000x08300x08600x0890
+00int a32 Posn.class0x0860
+04long b32 30x0000
+08 40x0870
+0cPosn c0x0860  0x0870
+10Posn d0x0000int[].classPosn.class 
+14int[] e0x084055 
+18Posn[] f0x0888112 
+1c 4  
+20 9  
+24 16  
+28 49Posn[].class 
+2c  4 
0x08000x08300x08600x0890
+00int a32 Posn.class0x0860
+04long b32 30x0000
+08 40x0870
+0cPosn c0x0860  0x0870
+10Posn d0x0000int[].classPosn.class 
+14int[] e0x084055 
+18Posn[] f0x0888112 
+1c 4  
+20 9  
+24 16  
+28 49Posn[].class 
+2c  4 
d = new Posn(-12, 78);
0x08000x08300x08600x0890
+00int a320x08a0Posn.class0x0860
+04long b321630x0000
+08 40x0870
+0cPosn c0x0860  0x0870
+10Posn d0x0000int[].classPosn.class0x0000
+14int[] e0x08405532
+18Posn[] f0x0888112 
+1c 4  
+20 90x0830 
+24 168 
+28 49Posn[].class 
+2cfreeList0x0880 4 
d = new Posn(-12, 78);
0x08000x08300x08600x0890
+00int a32Posn.classPosn.class0x0860
+04long b321230x0000
+08-7840x0870
+0cPosn c0x0860  0x0870
+10Posn d0x0000int[].classPosn.class0x0000
+14int[] e0x08405532
+18Posn[] f0x0888112 
+1c 4  
+20 90x08a0 
+24 168 
+28 49Posn[].class 
+2cfreeList0x0880 4 
d = new Posn(-12, 78);
0x08000x08300x08600x0890
+00int a32Posn.classPosn.class0x0860
+04long b321230x0000
+08-7840x0870
+0cPosn c0x0860  0x0870
+10Posn d0x0830int[].classPosn.class0x0000
+14int[] e0x08405532
+18Posn[] f0x0888112 
+1c 4  
+20 90x08a0 
+24 168 
+28 49Posn[].class 
+2cfreeList0x0880 4 
d = new Posn(-12, 78);

More definitions

// Java
class Cons { int hd; Cons tl; }
/* C, C++ */
struct Node { int hd; Node* tl; }
typedef struct Node* Cons
# Ruby
Cons = Struct.new('Cons', :hd, :tl)
# Python
from collections import namedtuple
Cons = namedtuple('Cons', 'hd tl')
0x8000
+00 
+04 
+08 
+0c 
+10 
+14 
+18 
+1c 
0x20000x20200x2040
   
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))
0x8000
+00 
+04 
+08 
+0c 
+10 
+14 
+18 
+1c 
0x20000x20200x2040
   
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08 
+0c 
+10 
+14 
+18 
+1c 
0x20000x20200x2040
   
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10 
+14 
+18 
+1c 
0x20000x20200x2040
   
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14int n1
+18 
+1c 
0x20000x20200x2040
   
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14int n1
+18Cons(0,•)0x12a0
+1cint n0
0x20000x20200x2040
   
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14int n1
+18Cons(0,•)0x12a0
+1cint n0
0x20000x20200x2040
None  
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14int n1
+18Cons(0,•)0x12a0
+1cresult0x2000
0x20000x20200x2040
None  
   
   
   
   
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14int n1
+18Cons(0,•)0x12a0
+1cresult0x2000
0x20000x20200x2040
None  
   
Cons  
0  
0x2000  
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14result0x2008
+18
+1c
0x20000x20200x2040
None  
   
Cons  
0  
0x2000  
   
   
   
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cint n2
+10Cons(1,•)0x12a0
+14result0x2008
+18
+1c
0x20000x20200x2040
None0x2008 
   
Cons  
0  
0x2000  
   
Cons  
1  
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cresult0x2018
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
Cons  
0  
0x2000  
   
Cons  
1  
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04int n3
+08Cons(2,•)0x12a0
+0cresult0x2018
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst=•0x1128
+04result0x2028
+08
+0c
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst0x2028
+04
+08
+0c
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def iotaR(n):
  if n < 1: return None
  else:     return Cons(n - 1, iotaR(n - 1))

lst = iotaR(3)
0x8000
+00lst0x2028
+04
+08
+0c
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0c
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal2
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2018
+0ctotal2
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2018
+0ctotal3
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2008
+0ctotal3
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2008
+0ctotal3
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total
0x8000
+00lst0x2028
+04RA
+08lst0x2000
+0ctotal3
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
def sum(lst):
  total = 0
  while lst != None:
    (total, lst) = (total + lst.hd, lst tl)
  return total

Lies!

R0R1R2R3
    
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010   
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010&total0x800c  
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total0  
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total0&xs0x8008 
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total0xs0x2028 
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total0xs0x2028&xs.hd0x202c
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total0xs0x2028xs.hd2
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total2xs0x2028xs.hd2
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total2&xs.tl0x2030xs.hd2
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total2xs.tl0x2018xs.hd2
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total2xs0x20182
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total2xs0x2018&xs.hd0x201c
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total2xs0x2018xs.hd1
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x2018xs.hd1
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3&xs.tl0x2020xs.hd1
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs.tl0x2008xs.hd1
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x20081
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x2008&xs.hd0x200c
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x2008xs.hd0
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x2008xs.hd0
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3&xs.tl0x2010xs.hd0
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs.tl0x2000xs.hd0
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x20000
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal0
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
R0R1R2R3
SP0x8010total3xs0x20000
the register file
0x8000
+00lst0x2028
+04RA
+08lst0x2028
+0ctotal3
+10
+14
+18
+1c
0x20000x20200x2040
None0x2008 
   
ConsCons 
02 
0x20000x2018 
   
Cons  
1  
the stackthe heap
ArithmeticMemory
No. of instructions128
ArithmeticMemory
No. of instructions128
Cycles per operation1?
The cycle time (period) is the reciprocal of the clock speed (frequency). For a 2.5 GHz CPU, for example, the cycle time is \(1 / (2.5 \times 10^9) = 0.4\mathop{\mathrm{ns}} = 0.0000000004\mathop{\mathrm{s}}.\)
ArithmeticMemory
No. of instructions128
Cycles per operation1100
The cycle time (period) is the reciprocal of the clock speed (frequency). For a 2.5 GHz CPU, for example, the cycle time is \(1 / (2.5 \times 10^9) = 0.4\mathop{\mathrm{ns}} = 0.0000000004\mathop{\mathrm{s}}.\)
ArithmeticMemory
No. of instructions128
Cycles per operation× 1× 100
Total CPU cycles12800
ArithmeticMemory
No. of instructions128
Cycles per operation× 1× 100
Total CPU cycles12800
Percent of time1.5%98.5%
ArithmeticRegistersMemoryDRAM
No. of instructions128
Cycles per operation× 1× 100
Total CPU cycles12800
Percent of time1.5%98.5%

The memory hierarchy

Cache
RegistersDRAM
Latency (cycles)1100
Latency (ns)0.440

The memory hierarchy

Cache
RegistersCacheDRAM
Latency (cycles)110100
Latency (ns)0.4440

The memory hierarchy

Cache
RegistersCacheDRAM
Latency (cycles)110100
Latency (ns)0.4440

Average length of load or
store (in clock cycles)

Without cache:
100
With cache (assuming 90% hit rate):
\(.9 × 10 + .1 × 100 = 19\)

The memory hierarchy

Cache
RegistersCacheDRAM
Latency (cycles)110100
Latency (ns)0.4440

Average length of load or
store (in clock cycles)

Without cache:
100
With cache (assuming 90% hit rate):
\(.9 × 10 + .1 × 100 = 19\)

The memory hierarchy

Cache
RegistersCacheDRAM
Latency (cycles)110100
Latency (ns)0.4440
Price (US$/GiB)priceless?$50

The memory hierarchy

Cache
RegistersL1DRAM
Latency (cycles)12100
Latency (ns)0.40.840
Price (US$/GiB)pricelessn.f.s.$50

The memory hierarchy

Cache
RegistersL1L2DRAM
Latency (cycles)1210100
Latency (ns)0.40.8440
Price (US$/GiB)pricelessn.f.s.n.f.s.$50

The memory hierarchy

Cache
RegistersL1L2L3DRAM
Latency (cycles)121040100
Latency (ns)0.40.841640
Price (US$/GiB)pricelessn.f.s.n.f.s.$2500$50

The memory hierarchy

Cache
RegistersL1L2L3DRAM
Latency (cycles)121040100
Latency (ns)0.40.841640
Price (US$/GiB)pricelessn.f.s.n.f.s.$2500$50
Typical size128 B128 KiB1 MiB6 MiB16 GiB

The memory hierarchy

Cache
RegistersL1L2L3DRAM
Latency (cycles)121040100
Latency (ns)0.40.841640
Price (US$/GiB)pricelessn.f.s.n.f.s.$2500$50
Typical size128 B128 KiB1 MiB6 MiB16 GiB
\(2^k\) bytes\(7\)\(17\)\(20\)\(22.6\)\(34\)

The memory hierarchy

Cache
RegistersL1L2L3DRAMDisk
Latency (cycles)1210401002500
Latency (ns)0.40.8416401000
Price (US$/GiB)pricelessn.f.s.n.f.s.$2500$50$0.10
Typical size128 B128 KiB1 MiB6 MiB16 GiB1 TiB
\(2^k\) bytes\(7\)\(17\)\(20\)\(22.6\)\(34\)40

How to win big

Don’t take cache misses.

How to win big

Don’t take cache misses.

Okay, but how?

Locality!

Memory locality

Time locality:

You are likely to access things you’ve accessed recently.

Space locality:

You are likely to access things near things you’ve accessed recently.

Caching takes advantage of both:

Memory locality

Time locality:

You are likely to access things you’ve accessed recently.

Space locality:

You are likely to access things near things you’ve accessed recently.

Caching takes advantage of both:

Data structure strategies

  1. Chunking

  2. Cache obliviousness

  3. Don’t worry, be happy

Our analyses will usually ignore cache

Data structure strategies

  1. Chunking

  2. Cache obliviousness

  3. Don’t worry, be happy

Our analyses will usually ignore cache

Data structure strategies

  1. Chunking

  2. Cache obliviousness

  3. Don’t worry, be happy

Our analyses will usually ignore cache