Recently, there has been increased interest in running analytics and machine learning workloads on top of serverless frameworks in the cloud. The serverless execution model provides fine-grained scaling and unburdens users from having to manage servers, but also adds substantial performance overheads due to the fact that all data and intermediate state of compute task is stored on remote shared storage.
In this talk I first provide a detailed performance breakdown from a machine learning workload using Spark on AWS Lambda. I show how the intermediate state of tasks — such as model updates or broadcast messages — is exchanged using remote storage and what the performance overheads are. Later, I illustrate how the same workload performs on-premise using Apache Spark and Apache Crail deployed on a high-performance cluster (100Gbps network, NVMe Flash, etc.). Serverless computing simplifies the deployment of machine learning applications. The talk shows that performance does not need to be sacrificed.
Serverless Machine Learning on Modern Hardware Using Apache Spark with Patrick Stuedi
1. Patrick Stuedi, Michael Kaufmann, Adrian Schuepbach
IBM Research
Serverless Machine
Learning on Modern
Hardware
#Res6SAIS
2. Serverless Computing
●
No need to setup/manage a
cluster
●
Automatic, dynamic and fine-
grained scaling
●
Sub-second billing
●
Many frameworks: AWS
Lambda, Google Cloud
Functions, Azure Functions,
Databricks Serverless, etc.
3. Challenge: Performance
AWS Lambda Spark Serverless Spark Cloud On-Premise On-Premise
0
100
200
300
400
500
Increasing flexibility
Increasing performance
Example:
Sorting 100GB
AWS λ Databricks Databricks Spark Spark
Serverless Standard On-premise On-premise++
Spark/On-Premise++: Running Apache Spark on a High-Performance Cluster using RDMA and NVMe Flash, Spark Summit’17
Runtime[seconds]
5. Challenge: Performance
AWS Lambda Spark Serverless Spark Cloud On-Premise On-Premise
0
100
200
300
400
500
Increasing flexibility
Increasing performance
Example:
Sorting 100GBserverless cluster
with autoscaling
min machines: 1
max machines: 864 lambda
workers
AWS λ Databricks Databricks Spark Spark
Serverless Standard On-premise On-premise++
Spark/On-Premise++: Running Apache Spark on a High-Performance Cluster using RDMA and NVMe Flash, Spark Summit’17
Runtime[seconds]
6. Challenge: Performance
AWS Lambda Spark Serverless Spark Cloud On-Premise On-Premise
0
100
200
300
400
500
Increasing flexibility
Increasing performance
Example:
Sorting 100GBserverless cluster
with autoscaling
min machines: 1
max machines: 864 lambda
workers standard cluster
no autoscaling
8 machines
AWS λ Databricks Databricks Spark Spark
Serverless Standard On-premise On-premise++
Spark/On-Premise++: Running Apache Spark on a High-Performance Cluster using RDMA and NVMe Flash, Spark Summit’17
Runtime[seconds]
7. Challenge: Performance
AWS Lambda Spark Serverless Spark Cloud On-Premise On-Premise
0
100
200
300
400
500
Increasing flexibility
Increasing performance
Example:
Sorting 100GBserverless cluster
with autoscaling
min machines: 1
max machines: 864 lambda
workers standard cluster
no autoscaling
8 machines
100Gb/s
Ethernet
AWS λ Databricks Databricks Spark Spark
Serverless Standard On-premise On-premise++
Spark/On-Premise++: Running Apache Spark on a High-Performance Cluster using RDMA and NVMe Flash, Spark Summit’17
Runtime[seconds]
8. Challenge: Performance
AWS Lambda Spark Serverless Spark Cloud On-Premise On-Premise
0
100
200
300
400
500
Increasing flexibility
Increasing performance
Example:
Sorting 100GBserverless cluster
with autoscaling
min machines: 1
max machines: 864 lambda
workers standard cluster
no autoscaling
8 machines
100Gb/s
Ethernet
AWS λ Databricks Databricks Spark Spark
Serverless Standard On-premise On-premise++
RDMA,
NVMe flash,
NVMeF
Spark/On-Premise++: Running Apache Spark on a High-Performance Cluster using RDMA and NVMe Flash, Spark Summit’17
Runtime[seconds]
9. put your #assignedhashtag here by setting the footer in view-header/footer●
Scheduler: when to best add/remove resources?
●
Container startup: may have to dynamically spin up containers
●
Storage: input data needs to be fetched from remote storage
(e.g., S3)
– As opposed to compute-local storage such as HDFS
●
Data sharing: intermediate needs to be temporarily stored on
remote storage (S3, Redis)
– Affects operations like shuffle, broadcast, etc.,
Why is it so hard?
10. put your #assignedhashtag here by setting the footer in view-header/footer●
Scheduler: when to best add/remove resources?
●
Container startup: may have to dynamically spin up containers
●
Storage: input data needs to be fetched from remote storage
(e.g., S3)
– As opposed to compute-local storage such as HDFS
●
Data sharing: intermediate needs to be temporarily stored on
remote storage (S3, Redis)
– Affects operations like shuffle, broadcast, etc.,
Why is it so hard?
14. What about other workloads?
Example: SQL, Query 77 / TPC-DS benchmark
15. What about other workloads?
Example: SQL, Query 77 / TPC-DS benchmark
Shuffle/Broadcast
(needs to be stored remotely)
16. What about other workloads?
W W PS W W
could be co-located
with worker nodes
*) read training data
*) fetch model params
*) compute
*) update model
*) use cached data
*) fetch model params
*) compute
*) update model
Example: Iterative ML (e.g., linear regression)
17. What about other workloads?
Example: Iterative ML (e.g., linear regression)
W W PS W W
could be co-located
with worker nodes
*) read training data
*) fetch model params
*) compute
*) update model
*) use cached data
*) fetch model params
*) compute
*) update model
18. What about other workloads?
Example: Iterative ML (e.g., linear regression)
W W PS W W
could be co-located
with worker nodes
Needs to be
remote
W
*) read training data
*) fetch model params
*) compute
*) update model
*) use cached data
*) fetch model params
*) compute
*) update model
read remote data
scale
out
19. What about other workloads?
Example: Iterative ML (e.g., linear regression)
W W PS W W
could be co-located
with worker nodes
Needs to be
remote
W
*) read training data
*) fetch model params
*) compute
*) update model
*) use cached data
*) fetch model params
*) compute
*) update model
read remote data
scale
out
barrier, need to wait
20. Can we..
●
..use Spark to run such workloads in a serverless
fashion?
– Dynamic scaling of compute nodes while jobs are running
– No cluster configuration
– No startup time overhead
●
..eliminate the performance overheads?
– Workloads should run as fast as on a dedicated cluster
21. put your #assignedhashtag here by setting the footer in view-header/footer
●
Scheduling:
– Use serverless framework to schedule executors
– Use serverless framework to schedule tasks
– Enable sharing of executors among different applications
●
Intermediate data:
– Executors cooperate with scheduler to flush data remotely
– Consequently store all intermediate state remotely
Design Options
1
2
3
1
2
22. put your #assignedhashtag here by setting the footer in view-header/footer
●
Scheduling:
– Use serverless framework to schedule executors
– Use serverless framework to schedule tasks
– Enable sharing of executors among different applications
●
Intermediate data:
– Executors cooperate with scheduler to flush data remotely
– Consequently store all intermediate state remotely
Design Options
High startup
Latency!
1
2
3
1
2
23. put your #assignedhashtag here by setting the footer in view-header/footer
●
Scheduling:
– Use serverless framework to schedule executors
– Use serverless framework to schedule tasks
– Enable sharing of executors among different applications
●
Intermediate data:
– Executors cooperate with scheduler to flush data remotely
– Consequently store all intermediate state remotely
Design Options
Slow!
High startup
Latency!
1
2
3
1
2
24. put your #assignedhashtag here by setting the footer in view-header/footer
●
Scheduling:
– Use serverless framework to schedule executors
– Use serverless framework to schedule tasks
– Enable sharing of executors among different applications
●
Intermediate data:
– Executors cooperate with scheduler to flush data remotely
– Consequently store all intermediate state remotely
Design Options
Slow!
High startup
Latency!
1
2
3
1
2
25. put your #assignedhashtag here by setting the footer in view-header/footer
●
Scheduling:
– Use serverless framework to schedule executors
– Use serverless framework to schedule tasks
– Enable sharing of executors among different applications
●
Intermediate data:
– Executors cooperate with scheduler to flush data remotely
– Consequently store all intermediate state remotely
Design Options
Slow!
High startup
Latency!
Complex!
1
2
3
1
2
26. put your #assignedhashtag here by setting the footer in view-header/footer
●
Scheduling:
– Use serverless framework to schedule executors
– Use serverless framework to schedule tasks
– Enable sharing of executors among different applications
●
Intermediate data:
– Executors cooperate with scheduler to flush data remotely
– Consequently store all intermediate state remotely
Design Options
Slow!
High startup
Latency!
Complex!
1
2
3
1
2
35. HCS Scheduler
Executor
Resource
Manager
“Oracle”
Scheduler
Driver
REST API REST API
request resource
assign resource
determines
resource set
(executors)
for a given
schedule
computes task
schedule
Uses ML to
predict task
runtimes
based on
previous runs
“The HCl Scheduler:
Going all-in on Heterogeneity”,
Michael Kaufmann et al., HotCloud’17
36. Video: Putting things together
Application 1:
GridSearch
Application 2:
SQL TPC-DS
Application 3:
SQL TPC-DS
HCL
Scheduler
Resource view:
fraction of resources
each app consumes
Executor view:
Which app an executor
currently runs
38. put your #assignedhashtag here by setting the footer in view-header/footer●
Compute cluster size: 8 nodes: IBM Power8 Minsky
●
Storage cluster size: 8 nodes, IBM Power8 Minsky
●
Cluster hardware:
– DRAM: 512 GB
– Storage: 4x 1.2 TB NVMe SSD
– Network: 10Gb/s Ethernert, 100Gb/s RoCE
– GPU: NVIDIA P100, NVLink
●
Workloads
– ML: Logistic Regression using the CoCoa framework
– SQL: TCP-DS
Let’s look at performance...
39. ML: Logistic Regression
Vanilla Cluster HCS/CRAIL/TCP HCS/CRAIL/100Gb/s HCS/CRAIL/RDMA
0
0.5
1
1.5
2
2.5
Input
Reduce
Broadcast
Compute
KDDA data set
6.5 GB
Runtime[seconds]
Vanilla
Cluster,100Gb/s
Vanilla
Serverless
HCS/Crail
TCP,100Gb/s
HCS/Crail
RDMA,100Gb/s
Using HCS/Crail we can store intermediate data remotely and reduce the runtime for ML
40. TPC-DS: Query #87
Spark Cluster Simple Serverless HCS/CRAIL/TCP HCS/CRAIL/RDMA
0
2
4
6
8
10
12
14
Runtime[seconds]
Vanilla
Cluster
HCS/Crail
TCP,10Gb/s
HCS/Crail
TCP,100Gb/s
HCS/Crail
RDMA,100Gb/s
We need a fast network and an optimized software stack to eliminate storage overheads
42. put your #assignedhashtag here by setting the footer in view-header/footer●
Efficient serverless computing is challenging
– Local state (e.g. shuffle, cached input, network state) is lost as compute cloud scales up/down
●
This talk: turning Spark into a serverless framework by
– Implementing HCS, a new serverless scheduler
– Consequently storing compute state remotely using Apache Crail
●
Supports arbitrary Spark workloads with almost no performance overhead
– MapReduce, SQL, Iterative Machine Learning
●
Implicit support for fast network and storage hardware
– e.g, RDMA, NVMe, NVMf
Conclusion
43. put your #assignedhashtag here by setting the footer in view-header/footer
●
Containerize the platform
●
Add support for dynamic re-partitioning on scale
events
●
Add support for automatic caching
●
Add more sophisticated scheduling policies
Future Work
44. put your #assignedhashtag here by setting the footer in view-header/footer
●
Running Apache Spark on a High-Performance
Cluster Using RDMA and NVMe Flash, Spark
Summit’17, https://tinyurl.com/yd453uzq
●
Apache Crail, http://crail.apache.org
●
HCS Scheduler, github.com/zrlio/hcs
●
Spark-HCS, github.com/zrlio/spark-hcs
●
Spark-IO, github.com/zrlio/spark-io
Links
45. Thanks to
Michael Kaufmann, Adrian Schuepbach, Jonas Pfefferle,
Animesh Trivedi, Bernard Metzler, Ana Klimovic, Yawen
Wang