goroutine get signers

contracts/utils.go

@@ -295,38 +295,57 @@ func GetRewardForCheckpoint(chain consensus.ChainReader, blockSignerAddr common.
 	masternodes := XDPoS.GetMasternodesFromCheckpointHeader(prevHeaderCheckpoint)
 
 	if len(masternodes) > 0 {
-		for i := startBlockNumber; i <= endBlockNumber; i++ {
-			block := chain.GetHeaderByNumber(i)
-			addrs, err := GetSignersFromContract(blockSignerAddr, client, block.Hash())
-			if err != nil {
-				log.Error("Fail to get signers from smartcontract.", "error", err, "blockNumber", i)
-				return nil, err
-			}
-			// Filter duplicate address.
-			if len(addrs) > 0 {
-				addrSigners := make(map[common.Address]bool)
-				for _, masternode := range masternodes {
-					for _, addr := range addrs {
-						if addr == masternode {
-							if _, ok := addrSigners[addr]; !ok {
-								addrSigners[addr] = true
-							}
-							break
-						}
-					}
-				}
 
-				for addr := range addrSigners {
+        var wg sync.WaitGroup
-					_, exist := signers[addr]
+        squeue := make(chan []common.Address, 1)
-					if exist {
+        wg.Add(900)
-						signers[addr].Sign++
+
-					} else {
+		for i := startBlockNumber; i <= endBlockNumber; i++ {
-						signers[addr] = &rewardLog{1, new(big.Int)}
+            go func(i uint64) {
-					}
+                block := chain.GetHeaderByNumber(i)
-					*totalSigner++
+                addrs, err := GetSignersFromContract(blockSignerAddr, client, block.Hash())
-				}
+                if err != nil {
-			}
+                    log.Crit("Fail to get signers from smartcontract.", "error", err, "blockNumber", i)
-		}
+                    // return nil, err
+                }
+                squeue <- addrs
+            }(i)
+        }
+
+        fsigner := func() {
+            for addrs := range squeue {
+                // Filter duplicate address.
+                if len(addrs) > 0 {
+                    addrSigners := make(map[common.Address]bool)
+                    for _, masternode := range masternodes {
+                        for _, addr := range addrs {
+                            if addr == masternode {
+                                if _, ok := addrSigners[addr]; !ok {
+                                    addrSigners[addr] = true
+                                }
+                                break
+                            }
+                        }
+                    }
+
+                    for addr := range addrSigners {
+                        _, exist := signers[addr]
+                        if exist {
+                            signers[addr].Sign++
+                        } else {
+                            signers[addr] = &rewardLog{1, new(big.Int)}
+                        }
+                        *totalSigner++
+                    }
+                }
+                wg.Done()
+            }
+        }
+
+        go fsigner()
+
+        wg.Wait()
+        fmt.Println("totalSigner", *totalSigner)
 	}
 
 	log.Info("Calculate reward at checkpoint", "startBlock", startBlockNumber, "endBlock", endBlockNumber)

eth/backend.go

@@ -38,7 +38,7 @@ import (
 	"github.com/ethereum/go-ethereum/consensus/ethash"
 	"github.com/ethereum/go-ethereum/consensus/XDPoS"
 	"github.com/ethereum/go-ethereum/contracts"
-	// "github.com/ethereum/go-ethereum/contracts/validator/contract"
+	"github.com/ethereum/go-ethereum/contracts/validator/contract"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/bloombits"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -313,6 +313,7 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
 
 				totalSigner := new(uint64)
 				signers, err := contracts.GetRewardForCheckpoint(chain, addr, number, rCheckpoint, client, totalSigner)
+				fmt.Println("Time Get Signers", "block", header.Number.Uint64(), "time", common.PrettyDuration(time.Since(start)))
 				if err != nil {
 					log.Error("Fail to get signers for reward checkpoint", "error", err)
 					return err, nil
@@ -324,7 +325,7 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
 					return err, nil
 				}
 				// Get validator.
-				// validator, err := contract.NewXDCValidator(common.HexToAddress(common.MasternodeVotingSMC), client)
+				validator, err := contract.NewXDCValidator(common.HexToAddress(common.MasternodeVotingSMC), client)
 				if err != nil {
 					log.Error("Fail get instance of XDC Validator", "error", err)
 					return err, nil
@@ -332,10 +333,10 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
 				// Add reward for coin holders.
 				voterResults := make(map[common.Address]interface{})
 				if len(signers) > 0 {
-					vmenv := core.NewRuntimeEVM(state)
+					// vmenv := core.NewRuntimeEVM(state)
 					for signer, calcReward := range rewardSigners {
-						// err, rewards := contracts.CalculateRewardForHolders(foudationWalletAddr, validator, state, signer, calcReward)
+						 err, rewards := contracts.CalculateRewardForHolders(foudationWalletAddr, validator, state, signer, calcReward)
-						err, rewards := contracts.CalculateRewardForHolders2(foudationWalletAddr, vmenv, state, signer, calcReward)
+						// err, rewards := contracts.CalculateRewardForHolders2(foudationWalletAddr, vmenv, state, signer, calcReward)
 						if err != nil {
 							log.Error("Fail to calculate reward for holders.", "error", err)
 							return err, nil