As we have released our public testnet, COVA-Nyx, we wanted a dashboard to help us not only visualize the running nodes and jobs on our testnet, but also do a comparative analysis on why a TEE based distributed network can be more suitable for computations that are impossible to do on traditional blockchain solutions such as Ethereum.

In a nutshell, due to the way Ethereum VM is designed, the whole ETH network can run at most the number of computation a single modern computer can run. However, due to COVA’s protocol technology , we can achieve massive scaling without compromising the security and privacy guarantees of blockchain networks.

Dashboard Explained

First, let us explain COVA protocol dashboard (available on: https://covalent.ai/status), which benchmarks ETH and COVA real-time.

COVA Computing Power (1) and ETH (2) Computing Power

This shows a comparative view of how many operations (atomic tasks) can COVA vs ETH mainnet runs per second. The details of the benchmark are in the section below.

Total Compute Nodes (3)

The number of running compute nodes (mining nodes) right now

COVA vs Ethereum Computing power graph (4)

This graph shows COVA vs ETH computing power (from 1, 2) in the last 30 minute. Note that this is in log 10 scale (and easy to see that COVA is about 2 order of magnitude faster

COVA Cumulative Clock Speed (5)

This is the sum of clock speeds in all active compute nodes in the network (in GHz)

Total Running Jobs (6)

The number of Jobs running right now

Total Finished Jobs (7)

The number of jobs ran since the beginning of testnet release

COVA compute nodes world map (8)

This shows a simulation of the miners around the world. In future, the miners can choose to disclose their country location if they prefer (which will show up on the dash)

List of active comptue nodes (9)

This shows the unique ID, clock speed, and location of the running nodes

Active Jobs (10)

This is a list of all jobs running (with status)

COVA vs ETH: A Comparative Analysis

As we talk about blockchain scalability, TPS seems to be the name of the game. However, distributed computing network on a blockchain can be used for so many other interesting computational use cases (such as running machine learning models securely). Imagine a network with the security guarantees of Ethereum-like blockchain network and speed of normal centralized clouds. That’s why COVA has introduced a paradigm in verifiable computing — using COVA Protocol we can run the computations much faster than ETH.

As always, the devil is in the details: we ran a computation which computes moded factorials for some large number. Each atomic operation (or task) is multiplication of two large numbers and then modding them by a 10 digit prime. Here are our benchmark code samples:

Python Code:

import time MAX_INT_MOD = 1000000007

NUM = 2 * 10 ** 5 def mod_factorial(n = NUM, M = MAX_INT_MOD): now_time = time.time() num = 1 for i in xrange(1, n):

num = (num * i) % M print('Total Time : ' + str(time.time() - now_time))

Solidity code:

pragma solidity ^"0.4.24";

contract Factorial {

uint256 private state;

function f(uint256 n) public view returns(uint256) {

uint256 MOD = 1000000007;

uint256 ans = 1;

for (uint256 i = 1; i <= n; i++){

ans = (ans * i) % MOD;

}

return ans;

}

function f_test(uint256 n) public returns(bool) {

state = f(n);

return true;

}

function read_state() public view returns (uint256) {

return state;

}

}

We noticed that on average ETH can run 89,000 of these atomic tasks per block time. Whereas, depending on COVA testnet blocktime and CPU clock speed of single nodes, each compute node can run roughly 100,000 operations in that time. Now, we can scale this operation running the same job on various compute nodes and observe that we get almost 2 order of magnitude speedup in computation.

Further Scaling

You might have noticed that the number of operations per compute node is rather low for a modern computer. This is because CovaVM runs a simulation of python VM on python, which can be rather slow. We are working on a prototype that can speed the VM even further by about 2 order of magnitude. We hope to release that in our next version of testnet COVA-Alpine.