Here’s an article:
Ethereum: Synchronization Bitcoin Node with multiple nuclei
I synchronize my knot at 32 CPU, and it’s super slow.
Obviously, synchronization does not go parallel. I wonder if there is a fundamental obstacle to “division and conquering” ways to do so.
So let’s say I have a big blockchain for synchronization, such as 100 MB or more. If I used the traditional method of synchronization of all nodes at once, it would take a ridiculously long – perhaps even for days or weeks.
But what if I could divide that task into smaller pieces? For example, I could create more processes so that a few knots would quickly be synchronized, while others continue on their own.
This is exactly how some people have applied this approach by applying the “division and conquest” method. Here’s the outline of what it might look like:
- Get a piece of data : Take part of blockchain and synchronize it using one node.
- Make a new procedure
: Launch a new procedure that will work on synchronization of this smaller part of the data.
- Use more nuclei : use as many caraper as possible as possible to achieve progress in this new task.
3
This approach allows the nodes to remain synchronized by their own pace without having to wait for everyone else to catch. However, there are some fundamental obstacles that make this method challenging:
* Inter-project communication : Communication between the process can be ticklish, especially when deals with large amounts of data.
* Resources Management : Coordination of distribution and use of resources (eg cle core) is necessary, but it can be difficult to effectively manage.
* Global consensus : ensuring that all nodes agree on the latest data and the synchronization process requires a certain level of coordination, which is difficult to achieve.
Despite these challenges, some experienced developers experiment with this approach to “division and conquest”. For example:
* Binance smart chain
: Binance used a similar method, dividing blockchain into smaller pieces and parallel to process them.
* Polygon : Polygon is another project that implemented a strategy for synchronization of division and climb, using more processes to get some nodes quickly.
Although this approach may not be suitable for all cases of use, this is an interesting example of how people explore alternative ways to sync and scalable.
