1.
Kevin
Ballard
SFpython.org
2014-­‐03-­‐12

2.
kevin@
tellapart.com
Introductions

3.
Taba
• Distributed event aggregation service
import taba
...
taba.RecordValue(‘winning_bid_price’, wincpm)
...
$ taba-cli aggregate winning_bid_price
{“name”: “winning_bid_price”,
“10m”: {“count”: 14709, “total”: 5836.4},
“percentiles”: [0.07 0.16 0.32 0.84 1.33 8.03]}

4.
Taba
+10,000,000
events/sec
+50,000
metrics
+1,000
clients
+100
processors

5.
GET THE DATA MODEL RIGHT
Lesson #1

6.
Data Model

7.
Data Model
Event:
(‘bid_cpm’,
‘Counter’,
time(),
0.233)
State:
Aggregate:
{“10m”:
43.9,
“1h”:
592.22}

8.
Data Model

9.
Data Model

10.
Data Model

11.
STATE IS HARD
Lesson #2

12.
Centralizing State

13.
GENERATORS + GREENLETS =
AWESOME
Lesson #3

14.
Asynchronous Iterator
• JIT processing
• Automatically switches through I/O

15.
CPYTHON SUFFERS FROM MEMORY
FRAGMENTATION
Lesson #4

16.
Fragmentation
• Fragmentation is when a process’s heap is
inefficiently used.
• The GC may report a low memory
footprint, but the OS reports a much larger
RSS.

17.
Fragmentation

18.
Fragmentation

19.
Fragmentation

20.
Fragmentation

21.
Fragmentation

22.
Hybrid Memory Management
• Use Cython to allocate page-sized blocks of
pointers into incoming chunk
• Hand-off the whole thing to the CPython
memory manager
• Whole thing gets deallocated at once

23.
Hybrid Memory Management

24.
Hybrid Memory Management

25.
Hybrid Memory Management

26.
Ratcheting
• Ratcheting is a pathological case of Fragmentation,
caused by the fact that the heap must be contiguous*:
• It’s a limitation of CPython that it cannot compact
memory (mostly due to extensions).

27.
Ratcheting
• Ratcheting is a pathological case of Fragmentation,
caused by the fact that the heap must be contiguous*:
• It’s a limitation of CPython that it cannot compact
memory (mostly due to extensions).

28.
Ratcheting
• Ratcheting is a pathological case of Fragmentation,
caused by the fact that the heap must be contiguous*:
• It’s a limitation of CPython that it cannot compact
memory (mostly due to extensions).

29.
Ratcheting
• Ratcheting is a pathological case of Fragmentation,
caused by the fact that the heap must be contiguous*:
• It’s a limitation of CPython that it cannot compact
memory (mostly due to extensions).

30.
Ratcheting
• Avoid persistent objects
• Sockets are common offenders
• Anything that has to be persistent should
be created at application startup, before
processing data
• Avoid letting the heap grow in the first
place

31.
fin.
github.com/tellapart/taba
kevin@tellapart.com
|
@misterkgb
We’re
Hiring!
tellapart.com/careers