Immutable, and More

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Immutable Data Structure, and More
Chase Zhang
August 4, 2017

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Table of Contents
Immutable Data Structure
Introduction
Immutable Stack & Tree
Example: Git
Lock-free Data Structure
Introduction
Atomic and Immutable
Log-Structured Merge Tree
Introduction
Basic Ideas
Summary

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
▶ Python’s String, Tuple
▶ ImmutableJS
▶ Scala & Clojure
▶ Docker images
▶ Functional programming!

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
▶ Easily undo
▶ Eliminates side effect
▶ Suitable for concurrency
▶ Better comparation performance (React)

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
How to implement immutable data structure?
▶ A naive method is to make a copy every time. Like Python’s string
▶ It will be too costly in both time and space, can we do better?
▶ We want less memory cost
▶ We can afford a little worse in time cost, but not such costly as make a copy

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Let’s see two simple examples.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Question
How to implement immutable stack?
▶ Support push and remove on the top
▶ Every operation will return a history id
▶ At anytime, we can retrieve a snapshot of the stack with a specific history id

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
nil
Head-0
Figure: Immutable Stack: Initial

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
nil
Head-1 Head-0
Figure: Immutable Stack: Push

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
nil
Head-2Head-1 Head-0
Figure: Immutable Stack: Pop

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
nil
Head-2Head-1
Head-3
Head-0
Figure: Immutable Stack: Push Again

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
▶ Keep the pointer of head after each operation
▶ With any one of them, we can easily restore the corresponding snapshot of the stack.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Question
How to implement immutable tree?
▶ We have a tree like hierarchy structure which we can insert, change or remove a node
▶ We’d like to implement undo operation upon this data structure, that is, after a
series of operations, we can revert the whole tree to some previous status easily

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Directory
File
Figure: An example of tree

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Change This
Figure: An example of tree

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
▶ Instead of modifying a node in place, we’ll copy the path from it to the root and then
change the copied nodes.
▶ By doing this, the modified tree will share most nodes with the origin and thus will
save a lot of memory.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Example: Git
Let’s have a look at how Git makes use of these two algorithms

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Example: Git
Git’s internal objects are all located under .git/objects folder
.git
├── HEAD
├── objects
│   ├── 0c
│   ├── 0d
│   ├── info
│   └── pack
├── refs
│   ├── heads
│ └── tags

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Example: Git
Git’s objects are compressed with zlib, we can use the following program to decompress it
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import zlib
def main(fname):
with open(fname) as f:
print zlib.decompress(f.read())
if __name__ == "__main__":
main(sys.argv[1])

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Example: Git
A better way is to use the build-in command
git cat-file -p 5b67fd90081

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Example: Git
DEMO TIME!

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Change This
Commit 0 Commit 0 Commit 1
Figure: Git Objects Model

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Example: Git
Conclusion
Git’s internal objects are just organized by the two simple immutable data structures
introduced before!
If the whole Git’s market worth 5 billion dollars, these two algorithms can just make up a
portion of 2.5 billion !

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Yet, one more thing...

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
Lock-free data structure are a wide range of data structures which allow safe concurrent
access without lock.
A single lock-free data structure may only worth only 10% of 2.5 billion, but its value will
double every 18 months.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Lock-free is way too big a topic to discuss here, here we’ll only consider a small portion of it
which has some relationship with immutable data structures.
▶ We have atomic operation which is a faster alternative to lock for data safety in
concurrent environment
▶ Different processes can modify an immutable data structure in parallel and won’t
interfere each other
▶ Combining the two, we can implement mutable lock-free data structure easily.
Let’s take immutable tree as an example...

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
AtomicReference: root
Figure: Lock-free tree: initial

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
XFigure: Lock-free tree: transit

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Will be recycled by GC
Figure: Lock-free tree: finish

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
As the reference is changed atomically, there is no need to lock the data structure when
accessing it in parallel.
What if two processes modified the same part simutaneously and thus caused a conflict?
We have while statement and CompareAndSet. At least one process will execute
successfully and eventually every process will finish their work.1
1
Yes, while statement may never exit in some cases for lock-free data structure. There exists a collection
of data structures which is said to be wait-free.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
The basic idea of lock-free data structure is that:
▶ we suppress the commitment of multiple consecutive operations into one single
operation that can be done atomically.
▶ This transaction of operations can only be regarded as success when the atomic
operation is done successfully, or all operations will fail and left no side effects.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Let’s MAKE A BIG THING!

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
▶ Immutable data structures make use of internal sharing memory to reduce time and
space cost
▶ Lock-free data structures make use of atomic operation to tackle concurrency
problem and achieve transactional like interface
▶ We’ll combine the two to get an awesome data structure: LSMT2
2
LSMT is much more complex than what we have talked here, but our discussion should be good enough
to give an impression of the basic idea

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
Question
Design a storage solution for a big data warehouse:
1. Support basic database operations (CRUD) and variable field length
2. Support high performance parallell access with transactional-like interface. That
means, a series of operations can either success as a whole or fail as a whole. Never in
the middle
3. Extremely stable, even cut off electricity in the middle of writting disk can not
disturb the validity of data

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
Why is it so hard?
▶ We have variable length fields, If we put rows adjacent to each other:
▶ how can we expand the space if user update one of them to a longer value?
▶ Once some values of a field has been deleted, there will be empty holes in the space,
how can we recycle them and reduce wasting.
▶ We want high performance for writing and reading, also the data should be persisted
successfully
▶ Concurrent access caused a huge complexity in implementation
▶ Data have to be written to sequential storage devices like hard disk, which is slow for
random access
▶ We want to be extremely stable, even a single write operation may not solid enough:
▶ Writing large log entry may be interrupted in the middle
▶ Undo and rollback a transaction can be interrupted in the middle

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
Log-Structured Merge Tree to rescue.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
▶ All data entries are organized as a tree (ex. B+ Tree)
▶ Draw ideas from immutable tree, every write operation can be transformed into
append operation by just writing new nodes to the end of file
▶ The root of the tree has been pointed by an on disk file upon which an update
operation can be regarded as atomical3
3
We can use append instead of overwrite so that even an append operation fails in the middle, we can
still recover former status

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
root
Append Only
Figure: Framework of LSMT

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
Figure: Only append copied nodes onto LSMT

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
root
Figure: File structure after appended new modification

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
root
X
Figure: Change the pointer of root to new place

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
root
Out of date
Figure: Root pointer has been changed atomically

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
Delete
Compress
Figure: Cleaning garbage blocks

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Basic Ideas
The following projects are making use of LSMT:
▶ Bigtable (from Google)
▶ MongoDB
▶ SQLite 4
▶ Apache Cassandra
▶ InfluxDB
LSMT might be yet another example of billion worth algorithms.

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Summary
Thank you!

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Summary
One more word...
Algorithm skills is not for finding jobs.
It makes the difference between good and the best.

Immutable, and More

Recomendados

Recomendados

Más contenido relacionado

Similar a Immutable, and More

Similar a Immutable, and More (20)

Último

Último (20)

Immutable, and More