RedisConf17 keynote presentation

1. #redisconf17
DOING MORE WITH REDIS
OFER BENGAL
YIFTACH SHOOLMAN
CO-FOUNDERS, REDIS LABS

2. #1 – Running Redise Flash
in a DBaaS Model

3. Redise Cloud Private
Fully managed, serverless scaling Redise service
in VPCs
on: AWS, MS Azure, GCP & IBM Softlayer

4. Redise Flash – Built for a Tiered Memory Architecture
Persistent Storage:
Entire Dataset
AOF, Snapshot
SSD:
Cold Values
DRAM:
Keys & Hot Values
Cluster Node

5. Flexible RAM : Flash Ratios

6. New Memory Technology is Evolving Fast

7. DRAM vs Flash : Performance vs Cost
$9
$0.4
$1
$2

8. Flash Memory - What Has Changed During Last Year
New NVMe based local SSD that can be attached to a Cloud Instance

9. Flash Memory - What Has Changed During Last Year
New NVMe based local SSD that can be attached to a Cloud Instance
New NVMe based SSD I3 Instances

10. I3 (NVMe) are x2.6 Faster and 80% Cheaper than I2 (SATA)
Single node @ <1msec latency

11. Flash Memory - What Has Changed During Last Year
New NVMe based local SSD that can be attached to a Cloud Instance
New NVMe based SSD I3 Instances
New Flash-GT card with multiple NVMes integrated

12. Flash Memory - What Has Changed During Last Year
New NVMe based local SSD that can be attached to a Cloud Instance
New NVMe based SSD I3 Instances
New Flash-GT card with multiple NVMes integrated
New 3D XPoint chipset on NVME Devices

13. Redise Flash + Intel® Optane™ SSD
2040
1380
590
728
142
64
0
500
1000
1500
2000
2500
95% 85% 50%
KOps/sec
RAM hit ratio
item size = 1000B; read/write = 50%/50%
Optane
P3700
Up to x9
Similar to what runs on:

14. DBaaS Price Comparison
$2,200,162/yr
$1,772,606/yr
$766,096/yr
$232,875/yr
$0/yr
$500,000/yr
$1,000,000/yr
$1,500,000/yr
$2,000,000/yr
$2,500,000/yr
Other Redis Provider RCP RAM Cloud-Based NoSQL RCP Flash
2TB Dataset with HA @ 100K ops/sec (on-demand pricing)
<1msec <1msec <10msec <1msec
Up to 89% saving!

15. #2 – Modules Are Gaining Momentum

16. Modules Status
• 50+ created
• C, C++, Go, Python supported
• Multi-threaded infrastructure

17. Why Multi-Threading is Crucial for Modules
100msec
(module)
0.1msec
(core)
0.1msec
(core)
0.1msec
(core)
A Single-Threaded
Module

18. Why Multi-Threading is Crucial for Modules
100msec
(module)
0.1msec
(core)
0.1msec
(core)
0.1msec
(core)
A Single-Threaded
Module
100.3msec 100.2msec 100.1msec 100msec
Average latency - 100.15msec
Module latency - 100msec
Average core latency - 100.2msec

19. Why Multi-Threading is Crucial for Modules
100msec
(module)
0.1msec
(core)
0.1msec
(core)
0.1msec
(core)
A Multi-Threaded
Module
0.3msec 0.2msec 0.1msec 100msec
Average latency - 25.15msec
Module latency - 100msec
Average core latency - 0.2msec
100msec
(module)
0.1msec
(core)
0.1msec
(core)
0.1msec
(core)
A Single-Threaded
Module
100.3msec 100.2msec 100.1msec 100msec
Average latency - 100.15msec
Module latency - 100msec
Average core latency - 100.2msec

20. 4 Useful Modules
RediSearch
ReJSON
Redis-ML
Redis-Graph

21. 4 Useful Modules
RediSearch
ReJSON
Redis-ML
Redis-Graph

22. Friends, Friends of Friends and Visited Countries

23. Query: Friends Who’ve Visited Places I’ve Been To
MATCH (:person {name:“Roi Lipman”})-
[:visited]->(c:country)<-[:visited]-
(f:person)<-[:friend]-
(:person {name:“Roi Lipman”})
RETURN f, c

24. Result: Friends Who’ve Visited Places I’ve Been To

25. Query: Who’s Gone on a Business Trip
MATCH (p:person)-
[v:visited {purpose:business}]->(c:country)
RETURN p, v, c

26. Result: Who’s Gone on a Business Trip

27. Benchmarks
Per shard
• 150K inserts / sec
• 15K queries / sec

28. A Deep Dive on Redis-Graph:
Salon 12 @ 2:30 pm

29. 4 Useful Modules
RediSearch
ReJSON
Redis-ML
Redis-Graph

30. The Machine / Deep Learning (ML/DL) World
(1) Training (2) Creating a model (3) Serving the model

31. (1) Training (2) Creating a model (3) Serving the model
Homegrown
The Machine / Deep Learning (ML/DL) World

32. Challenge #1 - Model Accuracy

33. Challenge #1 - Model Accuracy
Just avoid…

34. Real World Example
• Ads serving company
• Need to serve 20,000 ads/sec @ 50msec data-center latency
• Runs 1k campaigns

35. Real World Example
• Runs 1k campaigns  1K random forest
• Each forest has 15K trees
• On average each tree has 7 levels (depth)
20K x 1K x 15K x 3.5 = 1.05 trillion ops/sec

36. Challenge #2 - Accurate Models are Expensive to Serve!
Item Calculation Total
Max ops/sec on the
strongest AWS
instance vcore
2.6Ghz x
0.9 (OS overhead) x
0.1 (10 lines of code per ops) x
0.1 (Java overhead)
23.4 million
# of vcores needed 1.05 trillion / 23.4 million 44,872
# of c4.8xlarge
instances needed
44,872 / 36 1,247
Total cost
reserved instances
1,247 x 9213 ~$11.5M/yr

37. Ads Serving Use-Case w/ and w/o Redise + ML
Homegrown
1,247 x c4.8xlarge 35 x c4.8xlarge
Cut computing infrastructure by
97%

38. How ML/DL Should be Severed
(1) Training (2) Creating a model (3) Serving the model

39. A Deep Dive on Redis-ML:
Salon 8 @ 1:45 pm

40. 4 Useful Modules
RediSearch
ReJSON
Redis-ML
Redis-Graph

41. Jeff Atwood's Law (Stack Overflow, Stack Exchange) :
"any application that can be written in
JavaScript, will eventually be written in
JavaScript"

42. This Leads To:
"...any database will eventually store
[some data in] JSON"

43. What We Found

44. ReJSON (= Redis + JSON) in 5 Words
• Intuitive
• Integrated
• Any client
• Fast

45. Performance: 39491 bytes, 3 nesting levels
ReJSON
Raw JSON & Lua
MessagePack & Lua

46. 4 Useful Modules
RediSearch
ReJSON
Redis-ML
Redis-Graph

47. The Fastest Search in Town
x5 - x10 Faster

48. The Feature List is Long
1. Full-Text indexing of multiple fields in documents
2. Incremental indexing without performance loss
3. Document ranking (provided manually by the user at
index time)
4. Complex Boolean queries with AND, OR, NOT operators
between sub-queries
5. Optional query clauses
6. Prefix based searches
7. Field weights
8. Auto-complete suggestions (with fuzzy prefix
suggestions)
9. Exact Phrase Search, Slop based search
10. Stemming based query expansion in many
languages (using Snowball)
11. Support for custom functions for query expansion
and scoring (see Extensions)
12. Limiting searches to specific document fields (up
to 8 fields supported)
13. Numeric filters and ranges
14. Geo filtering using Redis' own Geo-commands
15. Supports any utf-8 encoded text
16. Retrieve full document content or just ids
17. Automatically index existing HASH keys as
documents
18. Document deletion and updating with index garbage
collection.

49. RediSearch Shard
Redis Search Engine Coordinator
+ + =
RediSearch Shard

50. RediSearch Cluster
Node 1
Node 2
Node 3

51. RediSearch Cluster
Node 1
Node 2
Node 3
ClientFT.SEARCH idx “foo”

52. RediSearch Cluster Fully-Connected Fan-Out/In
Node 1 Node 3
“foo” {3}
“foo” {4}
“foo” {5}
“foo” {6}
“foo” {2}
“foo” {1}
ClientFT.SEARCH idx “foo”
Node 2

53. When RediSearch Cluster Becomes Larger
Node 1
Node 2
Node 3

54. RediSearch Cluster Tree-Based Fan-Out/In
Node 1
Node 2
Node 3
“foo” {5},{6},{7},{8} “foo” {9},{10},{11},{12}
ClientFT.SEARCH idx “foo”

55. RediSearch Cluster Tree-Based Fan-Out/In
Node 1
Node 2
Node 3
“foo” {5},{6},{7},{8} “foo” {9},{10},{11},{12}
ClientFT.SEARCH idx “foo”
“foo” {5}
“foo” {7}
“foo” {6}
“foo” {8}
“foo” {1}
“foo” {3}
“foo” {2}
“foo” {4}
“foo” {9}
“foo” {11}
“foo” {10}
“foo” {12}

56. Let’s See it in Action…
Preview

57. #3 – Redis for IoT

60. IoT Architecture
Devices

61. IoT Architecture
Devices
Edge

62. IoT Architecture
Devices
Cloud
Edge

63. The Evolution of an IoT Device
Simple Sensor

64. The Evolution of an IoT Device
Simple Sensor
Complex Device
More
Features

65. The Evolution of an IoT Device
Simple Sensor
Complex Device Complex Device
with Memory
More
Features
Online/
Offline
Memory

66. Redis-Based IoT Device
• Runs on Raspberry Pi
• Single OSS Redis instance
(3MB footprint)
• Redis Stream client
• Persistence
• Low cost

67. IoT Edge Challenges
Small Form Factor Cluster
(Per node: 4 cores, 1-2GB DRAM, 50GB Flash)

68. IoT Edge Challenges
Small Form Factor Cluster
(Per node: 4 cores, 1-2GB DRAM, 50GB Flash)
Thousands of Devices
(20K+ devices, 10 updates/sec/device
200K+ updates/sec)

69. IoT Edge Challenges
Small Form Factor Cluster
(Per node: 4 cores, 1-2GB DRAM, 50GB Flash)
Thousands of Devices
(20K+ devices, 10 updates/sec/device
200K+ updates/sec)
Varied Functionality
(Time series, Search, Graph, ML, Geo)

70. IoT Edge Challenges
Simple & Reliable
(Integrated, short failover time)
Small Form Factor Cluster
(Per node: 4 cores, 1-2GB DRAM, 50GB Flash)
Thousands of Devices
(20K+ devices, 10 updates/sec/device
200K+ updates/sec)
Varied Functionality
(Time series, Search, Graph, ML, Geo)

71. Redise Cluster for the Edge
• Redise Cluster on RPI/x86
• Redise Flash
• Persistent & HA
• Redis Streams Server + Client
• Module options:
Search, JSON, Graph,
Time-Series, ML, Neural, RQL,
Enhanced GEO
Stream API Streams Data-Structure Multi-Function
1 2 3
Time-series
JSON
ML
Graph
Search
GEO
RQL

72. Redise Blueprint for IoT
Devices
• Raspberry Pi support
• A single OSS Redis instance
(3MB footprint)
• Persistent
• Redis Streams Client
• RPi/x86 nodes
(4 cores/2GB RAM /50GB SSD)
• Redise cluster
• Persistent & HA
• Redise on Flash
• Redis Streams Server & Client
• Modules:
‒ Search, JSON, Graph, Time-Series,
ML, Nueral, RQL, Enhanced GEO
Edge
• Large Redise cluster(s)
• Multi-cloud/DBaaS/Self-managed
• Multi-master geo-replication
• Persistent & HA (multi-az)
• Redise on Flash
• Redis Streams Server
• Modules:
‒ Search, JSON, Graph, Time-Series,
ML, RQL, Enhanced GEO
Cloud

73. #4 – Multi-Master Geo-Distributed Redis

74. Multi-Master Geo-Distributed Workloads
BIDDING/POLLING/LEADERBOARD
₤
$
$
₱
€
PROFILES/SESSION MANAGEMENT

75. Challenge #1 – Geo-Distributed Latency
Redis is fast!: > 1,000,000 ops/sec, < 1msec latency
Light is slower > 20msec RTT
Network is even slower > 70msec RTT

76. Consistency  Consensus  Slowness
App
App
App
~100msec for a ‘write’ operation

77. Challenge #2 – Conflict Resolution for Complex Data-Types
• Application level solution  too complex to write
• LWW (Last Write Wins)  doesn’t work for many of the Redis use cases, e.g.:
• Counters
• Sets
• Sorted Sets
• Lists
• Modules’ new datatypes

78. Hello CRDT
Conflict-free Replicated Data Type

79. CRDT
• Years of academic research
• Based on consensus free protocol
• Strong eventual consistency
• Built to resolve conflicts with complex data types

80. Consensus Free with Strong Eventual Consistency
App
App
App
Write Locally

81. Consensus Free with Strong Eventual Consistency
App
App
App
Write Locally, Converge Asynchronously

82. Solving Conflicts – Counters
Replica A:
C = 500
Replica B:
C = 500
Replica C:
C = 500

83. Solving Conflicts – Counters
Replica A:
C = 500
INCRBY 200
Replica B:
C = 500
Replica C:
C = 500

84. Solving Conflicts – Counters
Replica A:
C = 500
INCRBY 200
Replica B:
C = 500
DECRBY 300
Replica C:
C = 500

85. Solving Conflicts – Counters
Replica A:
C = 500
INCRBY 200
Replica B:
C = 500
DECRBY 300
Replica C:
C = 500
INCRBY 1000

86. Solving Conflicts – Counters
Replica A:
C = 500
INCRBY 200
Replica B:
C = 500
DECRBY 300
Replica C:
C = 500
INCRBY 1000
Convergence Function (commutative):
500 + ΣC(i) =
= 500 +200 -300 +1000
= 1400

87. Solving Conflicts – Sets
Replica A:
S = {A, B, C}
Replica B:
S = {A, B, C}
Replica C:
S = {A, B, C}

88. Solving Conflicts – Sets
Replica A:
S = {A, B, C}
SADD D
Replica B:
S = {A, B, C}
Replica C:
S = {A, B, C}

89. Solving Conflicts – Sets
Replica A:
S = {A, B, C}
SADD D
Replica B:
S = {A, B, C}
SADD A
Replica C:
S = {A, B, C}

90. Solving Conflicts – Sets
Replica A:
S = {A, B, C}
SADD D
Replica B:
S = {A, B, C}
SADD A
Replica C:
S = {A, B, C}
SREM A

91. Solving Conflicts – Sets
Replica A:
S = {A, B, C}
SADD D
Replica B:
S = {A, B, C}
SADD A
Replica C:
S = {A, B, C}
SREM A
Convergence Function (associative):
• S = S + D + A - A =
{A, B, C, D}
• Observed Removed + Add wins

92. Solving Conflicts – Sorted Sets
Replica A:
SS =
{A:35, B:23, C:4}
Replica B:
SS =
{A:35, B:23, C:4}
Replica C:
SS =
{A:35, B:23, C:4}

93. Solving Conflicts – Sorted Sets
Replica A:
SS =
{A:35, B:23, C:4}
Replica B:
SS =
{A:35, B:23, C:4}
Replica C:
SS =
{A:35, B:23, C:4}
Convergence Function
(associative & commutative):
Counters + Sets

94. Solving Conflicts – Lists
Replica A:
L= ABC
Replica B:
L= ABC
Replica C:
L= ABC

95. Solving Conflicts – Lists
Replica A:
L= ABC
Replica B:
L= ABC
Replica C:
L= ABC
Convergence Function:
Based on Directed Acyclic
Graphs (DAG)
Too complex to explain!!!

96. Multi-Master Redis is Here
Preview

97. What’s Unique About Redis-CRDT
• Based on a Redis module (CRDB)
• Support bi-direction replication
• Multiple topologies
• Solves a new set of problems
• Counters deletion
• Expiry
• Cluster configuration
• Etc.
RingFully-Connected

98. A Deep Dive on Multi-Master:
Salon 8 @ 3:15 pm

99. Thank You