Danny Lewin, 14 May 1970 - 11 September 2001 Internet Caching Lookup Tables Hash Tables Consistent Hashing

1. Class 9:
Consistent
Hashing
cs1120 Fall 2011
David Evans
12 September 2011

2. Charlottesville Airport, 23 December 2001

3. Daniel Lewin

4. Internet Circa 1998
Client Router
Client Router
Router
Yahoo.com
Client
Router
Router
Client
Router

5. google.com, November 1998 from archive.org

7. Caching the Internet
Cache
Client Router
Client Router
Router
Yahoo.com
Client Cache
Router
A Cache stores previous results.
If the result is already known
Router from the same request recently,
Client
Router it returns that result.
Problem: how do Clients and Routers know which cache to try?

8. Lookup Table
Key Value
“University of Virginia” “Wahoos”
“Virginia Tech” “Turkeys”
“University of Michigan” “Wolverines”
“MIT” “Beavers”
… …
Each entry is a (Key . Value) pair. To look up the Value associated
with a given Key, search the Keys in order until you find one that
matches, and then the value is the associated Value.

9. Examples
(define schools
(list (cons "University of Virginia" "Wahoos")
(cons "Virginia Tech" "Turkeys")
(cons "MIT" "Beavers")
(cons "UC Santa Cruz" "Banana Slugs")))
> (table-lookup schools "University of Virginia")
"Wahoos"
> (table-lookup schools "MIT")
"Beavers"
> (table-lookup schools "UC Irvine")
#f

10. Simple Lookup Table
Define a procedure, table-lookup, that takes as inputs a table and a
key. If the table contains an entry (key . value), the output is value.
If there is no entry whose first part matches key, the output is false.
1. Be very optimistic! Since lists are defined
recursively, most problems involving lists can
be solved with recursive procedures.
2. Think of the simplest input, something you can
already solve. This is the base case. For lists, it
is often when the list is null.
3. Consider how you would solve the problem
using the result for a slightly smaller version of
the problem. For lists, the smaller version of
the problem is usually the cdr of the list.

11. Simple Lookup Table
Define a procedure, table-lookup, that takes as inputs a table and a
key. If the table contains an entry (key . value), the output is value.
If there is no entry whose first part matches key, the output is false.

12. Simple Lookup Table
Define a procedure, table-lookup, that takes as inputs a table and a
key. If the table contains an entry (key . value), the output is value.
If there is no entry whose first part matches key, the output is false.
(define (table-lookup table key)
(if (null? table)
false
(if (equal? (car (car table)) key)
(cdr (car table))
(table-lookup (cdr table) key))))
This works…but if the table is big (or there are many caches) it is very slow!

13. Regular Hash Table
Index Key Value
compute-hash:
0
Key, Size Number
1
Maps a key (which could be any 2
value) and a table size to a
number between 0 and Size – 1. 3
This is the position in the table 4
where the Key should be stored. 5
6
> (compute-hash “University of Virginia” 12)
8 7
> (compute-hash “Virginia Tech” 12) 8 “University of Virginia” “Wahoos”
9
…. 9 “Virginia Tech” “Turkeys”
10
11

14. Typical compute-hash Function
Convert input to a string
(format “~a” x) converts any value x to a string
> (format "~a" 23)
"23"
> (format "~a" "University of Virginia")
"University of Virginia"
> (format "~a" (cons 1 (cons 2 null)))
"(1 2)"

15. Typical compute-hash Function
Convert input to a string
(format “~a” x) converts any value x to a string
Convert each character in the string to a number
(char->integer c) converts any character to a
number. > (char->integer #A)
65
> (char->integer #U)
85
> (char->integer #space)
32

16. Typical compute-hash Function
Convert input to a string
(format “~a” x) converts any value x to a string
Convert each character in the string to a number
(char->integer c) converts any character to a
number.
Compute the sum of all the numbers, modulo the
size of the table.

17. Defining compute-hash
(define (compute-hash key size)
(modulo
(sum-chars
(string->list (format "~a" key)))
size))

18. Defining sum-chars
Define a procedure, sum-chars, that takes as input a list of
characters, and outputs the sum of all the character values
(as converted by char->integer) in the list.
1. Be very optimistic! Since lists are
defined recursively, most problems
involving lists can be solved with
recursive procedures.
2. Think of the simplest input, something
you can already solve. This is the base
case. For lists, it is often when the list
is null.
3. Consider how you would solve the
problem using the result for a slightly
smaller version of the problem. For
lists, the smaller version of the
problem is usually the cdr of the list.

19. Defining sum-chars
Define a procedure, sum-chars, that takes as input a list of
characters, and outputs the sum of all the character values
(as converted by char->integer) in the list.
(define (sum-chars p)
(if (null? p)
0
(+(char->integer (car p))
(sum-chars (cdr p)))))

20. (define (sum-chars p)
(apply + (map char->integer p)))

21. Use of Hash Table in PS2
Note: this uses several things
(define (memoize f) you haven’t seen yet. I won’t
try to explain them all now.
(let ((ht (make-hash)))
(lambda (s1 s2)
(let ((key (format "~a#~a" s1 s2)))
(hash-ref ht key Look up the value of key in the
(lambda () hash table, ht. If it has a value,
that is the value. If it has no
(let ((res (f s1 s2))) value yet, apply this procedure
which finds the value by
(hash-set! ht key res) applying (f s1 s2) and stores it
in the table at the location
res))))))) associated with this key.

22. Problem with Regular Hashing
Index Key Value
0
> (compute-hash “University of Virginia” 12)
1
8
2
> (compute-hash “Virginia Tech” 12)
3
9
4
….
5
> (compute-hash “Virginia Tech” 13)
10 6
7
To work, everyone needs to have 8 “University of Virginia” “Wahoos”
exactly the same table! This is
9 “Virginia Tech” “Turkeys”
really hard on the Internet, where
nodes leave and join all the time. 10
11

23. Cache
Client Router
Client Router
Router
Yahoo.com
Client Cache
Router
Router
Client
Router
(find-cache caches url)
=> evaluates to address of the cache likely to have request cached.

24. 29th ACM Symposium on Theory of Computing, 1997

26. Consistent Hashing
0
1
½

27. Akamai
Akamai Headquarters, Cambridge, MA

29. Charge
Enjoy Today’s Fast Internet and
remember Danny Lewin’s
contribution (see today’s class
post for links to articles)
PS2 Due Wednesday
Upcoming Help
Today, noon-1:30pm (Kristina, Rice 1st)
Today, 1:15-2:00pm (Dave, Rice 507)
Tuesday, 11am-noon (Dave, Rice 507) Daniel Lewin
Tuesday, 5-6:30pm (Valerie, Rice 1st) 14 May 1970 –
Tuesday, 6:30-8pm (Jonathan, Rice 1st) 11 September 2001