Ethereum’s primary limitation is transactions per second [TPS] performance, which can be increased through what is known as sharding. With its current processing power [theoretical TPS value of ~25], 100 sharding chains could achieve 2,500 TPS, but this also decreases transaction safety and credibility. For example, a single chain previously backed by 50,000 nodes is now only backed by 500 nodes [1% of the original value]. It is therefore important to increase the TPS performance of a single chain or node to maintain safety and credibility for transactions. In the previous example, if the TPS of a single chain is increased to 1,000 TPS, 10 sharding chains will be able to reach 10,000 TPS while still backed by 5,000 nodes.
TPS scaling relies on upgrading the CPU [Central Processing Unit] method of executing transactions. Currently, only single-threaded transactions can be executed, and parallel transaction execution is needed to improve performance. The difficulty with parallel execution in blockchain contracts is that we cannot predict contract dependence relationships.
As a result, there are concurrent race conditions in Ethereum that may exist in access to accounts, storage, and EVM code. With these race conditions, it is unrealistic to have users recognize and flag address ranges that contain potential conflicts but that also does not mean parallel execution of blockchain contracts is not feasible.
Khipu breaks through the plateau of Blockchain 2.0
Khipu takes the lead in engineering solutions to this problem and more. They have developed an implementation scheme that enables parallel execution, taking transactions from the world state of the previous block. After the parallel execution phase ends, the merge phase begins. At the beginning of the merge phase, the parallel world states are merged in succession. When merging a transaction, the system will determine whether any race conflicts exist with the previously merged state.
If not, the transactions are merged directly. If the system does detect a conflict, it will execute the transaction again, starting from the previously merged world state. The merged world state will perform a final check using the hash of the block as a final defense. If an error is detected, the previous parallel scheme will be abandoned and the transaction will be re-executed in serial. Khipu has introduced a parallelism metric to measure this process, and according to real-world testing, an average of 80% of transactions can be executed in parallel without further execution.
If computing tasks can be made parallel completely, the theoretical scalability of a single chain is infinite, meaning you can simply add more CPU cores to increase parallel execution. If not all computing tasks can be executed in parallel, the maximum theoretical rate is limited by Amdahl’s law: the extent in which you can speed up a system depends on the reciprocal of the tasks that cannot be made parallel. For example, if 99% of tasks can be executed in parallel, performance can be increased by 100 times.
If you can only make 95% of tasks parallel, then performance can be increased by only 20 times. In the case of Ethereum, 80% parallelization provides a 5 times performance boost since the reciprocal of 20% is 5. That means that Khipu is able to achieve a 5 times performance gain for Ethereum through parallel execution of transactions.
Another limitation of Ethereum is that a single node stores the access frequency of the previous level’s trial node. This vulnerability led to the Ethereum DDoS attack in 2016. After analyzing the current vulnerability of the storage engine and the characteristic of blockchain data, Khipu developed Kesque, a storage engine designed specifically for KV [Key Value] data. The test results of the new engine demonstrate that for a scale of 100 million Ethereum KV data records, there is only a 0.1% chance that a collision will occur, meaning that in 99% of cases, the disk I/O will load the accurate record in at most one cycle. As such, Khipu’s Kesque has a significantly higher random loading capacity than LevelDB.
These developments enable Khipu to achieve impressive processing capacity. When batch processing 6,184 blocks of 6.4+ million numbers on an Intel® Xeon® E3-1231 v3 @ 3.40GHz 4 core CPU machine with 32G memory and a SATA SSD hard disk, Khipu can process 4.11 blocks per second, achieving 348 TPS and 80% parallelism. This processing speed is twice as fast as Parity 2.1.5 developed in Rust, making Khipu the world’s fastest Ethereum implementation to date.
With the innovations described, Khipu has established itself as a lead innovator for the future beyond Ethereum and blockchain 2.0.
For more information, follow BitMax on: