speed up valiate tx

[bytom/vapor.git] / protocol / validation / tx.go

diff --git a/protocol/validation/tx.go b/protocol/validation/tx.go
index 0768d88..1baf6c8 100644 (file)
--- a/protocol/validation/tx.go
+++ b/protocol/validation/tx.go
@@ -3,17 +3,20 @@ package validation
 import (
        "fmt"
        "math"
+       "sync"
 
        "github.com/vapor/config"
        "github.com/vapor/consensus"
-       "github.com/vapor/consensus/segwit"
        "github.com/vapor/errors"
        "github.com/vapor/math/checked"
        "github.com/vapor/protocol/bc"
        "github.com/vapor/protocol/vm"
 )
 
-const ruleAA = 142500
+const (
+       validateWorkerNum = 32
+       ruleAA            = 142500
+)
 
 // validate transaction error
 var (
@@ -251,8 +254,9 @@ func checkValid(vs *validationState, e bc.Entry) (err error) {
                // check assetID
                assetID := e.AssetDefinition.ComputeAssetID()
                if *e.Value.AssetId != *consensus.BTMAssetID && *e.Value.AssetId != assetID {
-                       return errors.New("incorrect asset_id while check CrossChainInput")
+                       return errors.New("incorrect asset_id while checking CrossChainInput")
                }
+
                code := config.FederationProgrom(config.CommonConfig)
                prog := &bc.Program{
                        VmVersion: e.ControlProgram.VmVersion,
@@ -524,37 +528,12 @@ func checkValidDest(vs *validationState, vd *bc.ValueDestination) error {
        return nil
 }
 
-func checkStandardTx(tx *bc.Tx, blockHeight uint64) error {
+func checkInputID(tx *bc.Tx, blockHeight uint64) error {
        for _, id := range tx.InputIDs {
                if blockHeight >= ruleAA && id.IsZero() {
                        return ErrEmptyInputIDs
                }
        }
-
-       for _, id := range tx.GasInputIDs {
-               spend, err := tx.Spend(id)
-               if err != nil {
-                       continue
-               }
-
-               code := []byte{}
-               outputEntry, err := tx.Entry(*spend.SpentOutputId)
-               if err != nil {
-                       return err
-               }
-               switch output := outputEntry.(type) {
-               case *bc.IntraChainOutput:
-                       code = output.ControlProgram.Code
-               case *bc.VoteOutput:
-                       code = output.ControlProgram.Code
-               default:
-                       return errors.Wrapf(bc.ErrEntryType, "entry %x has unexpected type %T", id.Bytes(), outputEntry)
-               }
-
-               if !segwit.IsP2WScript(code) {
-                       return ErrNotStandardTx
-               }
-       }
        return nil
 }
 
@@ -582,7 +561,7 @@ func ValidateTx(tx *bc.Tx, block *bc.Block) (*GasState, error) {
        if err := checkTimeRange(tx, block); err != nil {
                return gasStatus, err
        }
-       if err := checkStandardTx(tx, block.Height); err != nil {
+       if err := checkInputID(tx, block.Height); err != nil {
                return gasStatus, err
        }
 
@@ -595,3 +574,59 @@ func ValidateTx(tx *bc.Tx, block *bc.Block) (*GasState, error) {
        }
        return vs.gasStatus, checkValid(vs, tx.TxHeader)
 }
+
+type validateTxWork struct {
+       i     int
+       tx    *bc.Tx
+       block *bc.Block
+}
+
+type validateTxResult struct {
+       i         int
+       gasStatus *GasState
+       err       error
+}
+
+func validateTxWorker(workCh chan *validateTxWork, resultCh chan *validateTxResult, closeCh chan struct{}, wg *sync.WaitGroup) {
+       for {
+               select {
+               case work := <-workCh:
+                       gasStatus, err := ValidateTx(work.tx, work.block)
+                       resultCh <- &validateTxResult{i: work.i, gasStatus: gasStatus, err: err}
+               case <-closeCh:
+                       wg.Done()
+                       return
+               }
+       }
+}
+
+func ValidateTxs(txs []*bc.Tx, block *bc.Block) []*validateTxResult {
+       txSize := len(txs)
+       //init the goroutine validate worker
+       var wg sync.WaitGroup
+       workCh := make(chan *validateTxWork, txSize)
+       resultCh := make(chan *validateTxResult, txSize)
+       closeCh := make(chan struct{})
+       for i := 0; i <= validateWorkerNum && i < txSize; i++ {
+               wg.Add(1)
+               go validateTxWorker(workCh, resultCh, closeCh, &wg)
+       }
+
+       //sent the works
+       for i, tx := range txs {
+               workCh <- &validateTxWork{i: i, tx: tx, block: block}
+       }
+
+       //collect validate results
+       results := make([]*validateTxResult, txSize)
+       for i := 0; i < txSize; i++ {
+               result := <-resultCh
+               results[result.i] = result
+       }
+
+       close(closeCh)
+       wg.Wait()
+       close(workCh)
+       close(resultCh)
+       return results
+}