TemporalX vs Go-IPFS Official Node Benchmarks
Significant performance boosts are seen with many requests per session. Making a single request per session performance boosts are usually 2x-3x faster. However, if many requests per session, the performance boosts are on the order of 10x.
What is a session? A session is when you (the gRPC client) dials the gRPC server, initiates the handshake, and successfully authenticates with the server. Due to the session establishment overhead, re-establishing the session every time you want to make a request adds some overhead.
How do you leave a session established? Not closing the network connection once you have dialed the server is enough.
When will TemporalX be the same, or slower? Let’s say you have your desktop running go-ipfs and TemporalX and are uploading a movie to your node. In cases like these generally, the speed will be equal or go-ipfs will be slightly faster. However, if your go-ipfs node starts pinning hundreds of thousands of objects, performance will start to shift towards being favourable to TemporalX. The more objects you start pinning on go-ipfs, the faster TemporalX will become.
Each of these benchmarks is meant to demonstrate the same functionality replicated from go-ipfs and TemporalX. We attempted to recreate the same environment for TemporalX and go-ipfs as much as possible; however, there were some things we could not. These include using reference counting as opposed to pinning, modifications to the blockstore, and multi-datastores. The same datastore type (badger) was used on both the go-ipfs and TemporalX nodes.
The benchmarks were run from a 2vcpu, 7.5gb RAM virtual machine within Google cloud against a TemporalX and go-ipfs node running in our data centre. These are specs of the data centre server on which TemporalX and go-ipfs were installed: 16 core Xeon, 72GB DDR3 4TB RAID5.
Pinning vs Reference Counting Benchmarks:
Here we have a 60s benchmark against a TemporalX node with 5.25million objects stored, and a go-ipfs node with 32,793 objects stored:
As you can see, based on this benchmark the performance of TemporalX with a fresh initialized datastore, vs an extremely large datastore is roughly the same. There is no hit to the performance based on the increased number of objects you’re storing outside of that, which is natural for whatever key-value store you are using.
However, with go-ipfs, not only do you have the performance impacts from your key-value store based on the number of objects you’re storing, but you also have to deal with the performance hits from pinning, which the more objects you have stored (pinned), the slower your node is.
Now let’s contrast the benchmarks against a go-ipfs node with roughly 3.2million objects being stored, and TemporalX still storing 5.25million objects:
As you can see, TemporalX gives you performance that scales with your increasing data consumption and does so in a dependable way. Whether you’re storing 1000 objects or 15 million TemporalX will give you the performance you need, and expect.
Why does the benchmark not suffer from the performance hit? Well, that's because by default it does not pin.
Let us run the benchmark with DagPut pin enabled this time still with roughly 3.2million objects being stored on IPFS, and TemporalX still storing 5.25million objects:
TemporalX will consistently provide you the same performance benefits, whereas IPFS is highly dependent on the number of objects you are storing.
One Request Per Session Benchmark:
The following benchmarks are going with a 1 request per session model. That is, the gRPC connection is re-established every test. Note that as we mentioned at the beginning of this post, performance boosts drop down to a 2x-3x increase, which is still a huge plus.
Remote Benchmarks (TemporalX vs Fresh Go-IPFS):
These are benchmarks ran from a stand-alone benchmarking server hosted in the cloud, targeting remote IPFS and TemporalX installations.
Go-ipfs freshly initialized with 0 objects pinned, and the TemporalX node with 120,000 objects stored. You can see the performance with go-ipfs is in part heavily dependent on the number of objects you are currently pinning, whereas with TemporalX the performance is roughly the same.
v0.0.26 60s Benchmark
Benchmark, with each test, lasts on average 60 seconds.
Remote Benchmarks (Fresh TemporalX vs Full Go-IPFS):
These are benchmarks ran from a stand-alone bench marking server hosted in the cloud, targeting remote IPFS, and TemporalX installations. The go-ipfs node has about 4.5 million objects pinned
If you would like take TemporalX for a spin, reach out to request a test drive.