Rust is fast (super fast)

In a previous article, I posted on LinkedIn (see here), I wrote about a highly available and scalable IoT solution based on bare metals servers (for those that feel Kubernetes/OpenShift or AWS serverless) is an overkill.

I based the testing on some old raspberry pi3s as I wanted to prove that you could get decent throughput with off-the-shelf cheap hardware.

I wanted to now do a comparison with the solution I built (using Golang) against a Rust implementation of the services. I found a Rust load balancer here, downloaded and cross-compiled it to the "armv7-unknown-linux-gnueabihf" target. I converted my microservices to rust using "actix, serde and json" crates to read and save the JSON payload.

I used the same layout as in the article I mentioned (see diagram)

I set up keepalive as shown and just replaced the load balancers and microservices with the arm rust versions. I then configured the load balancer "toml" file, and finally verified that the services were all ok using the /stats endpoint of the load balancer

{
? "total_connections": 0,
? "current_connections": 0,
? "total_bytes_tx": 0,
? "total_bytes_rx": 0,
? "backends": {
? ? "tcp3000_out": {
? ? ? "total_connections": 0,
? ? ? "current_connections": 0,
? ? ? "bytes_tx": 0,
? ? ? "bytes_rx": 0,
? ? ? "servers": {
? ? ? ? "192.168.0.24:8080": true,
? ? ? ? "192.168.0.27:8080": true,
? ? ? ? "192.168.0.26:8080": true,
? ? ? ? "192.168.0.25:8080": true
? ? ? }
? ? }
? },
? "frontends": {
? ? "tcp_3000": {
? ? ? "total_connections": 0,
? ? ? "current_connections": 0,
? ? ? "bytes_tx": 0,
? ? ? "bytes_rx": 0
? ? }
? }
}        

The next step was to set up the load tester, I found a Rust version here, downloaded and compiled it for x86_64 (as I was executing this from my Fedora laptop). I tried keeping the same concurrent settings (10) and set the requests to 2100, the load testing tool doesn't consider the requests as with the go-bench load tester version i.e for the go-bench it uses concurrent connections multiplied by the requests to give a rough throughput of 2100 requests.

I was amazed at the initial results, I got 2900 requests per second. I then experimented to see what were the limits, I found the optimal at 2100 requests with 40 concurrent connections

base: 'https://192.168.0.15:3000
iterations: 2100
concurrency: 40
rampup: 2

plan:

? - name: POST JSON
? ? request:
? ? ? url: /streamdata
? ? ? method: POST
? ? ? body: '{
? ?     "name":"iot-paas",
? ?     "deviceId":"id123444",
? ?     "patientId":"pid3423423",
? ?     "data":[
? ? ?     {
? ? ? ? ?   "hr":80,
? ? ? ? ?   "bps":120,
? ? ? ? ?   "bpd":80,
? ? ? ? ?   "spo2":96,
? ? ? ? ?   "custom":{
? ? ? ? ? ?   "tp":34.7,
? ? ? ? ? ?   "rr":20,
? ? ? ? ? ?   "etc":"123"
? ? ? ? ?   },
? ? ? ? ?   "date":"17-03-2023"
? ? ?     }
? ?     ]
      }'
    ? headers:
    ? ? Content-Type: 'application/json''        

Here is the output from the load tester stats view

6091 requests per second WOW, that's one massive improvement compared to the Golang version where I got 2100 requests per second. As I mentioned that this is running on 7-year-old architecture. The pi3s were released in?February 2016?with a 1.2 GHz 64-bit quad-core ARM Cortex-A53 and 1G RAM.

I am absolutely amazed at Rust, I would imagine that due to the fact that there is no garbage collection, the optimized compiled binary, the actix web framework (and more), all add to making it performant. I haven't looked at optimizing the microservices even further (i.e avoid JSON marshalling - using pure string buffers etc), but I don't need to I'm more than blown away by its performance !!!.

So I can say now without any bias "I'm officially a big Rust fan-boy" !!!