以太坊原始碼分析(31)eth-downloader-peer原始碼分析

尹成發表於2018-05-14
原始碼
peer模組包含了downloader使用的peer節點，封裝了吞吐量，是否空閒，並記錄了之前失敗的資訊。


## peer
    
    // peerConnection represents an active peer from which hashes and blocks are retrieved.
    type peerConnection struct {
        id string // Unique identifier of the peer
    
        headerIdle int32 // Current header activity state of the peer (idle = 0, active = 1) 當前的header獲取的工作狀態。
        blockIdle int32 // Current block activity state of the peer (idle = 0, active = 1)    當前的區塊獲取的工作狀態
        receiptIdle int32 // Current receipt activity state of the peer (idle = 0, active = 1) 當前的收據獲取的工作狀態
        stateIdle int32 // Current node data activity state of the peer (idle = 0, active = 1) 當前節點狀態的工作狀態
    
        headerThroughput float64 // Number of headers measured to be retrievable per second    //記錄每秒能夠接收多少個區塊頭的度量值
        blockThroughput float64 // Number of blocks (bodies) measured to be retrievable per second //記錄每秒能夠接收多少個區塊的度量值
        receiptThroughput float64 // Number of receipts measured to be retrievable per second 記錄每秒能夠接收多少個收據的度量值
        stateThroughput float64 // Number of node data pieces measured to be retrievable per second 記錄每秒能夠接收多少個賬戶狀態的度量值
    
        rtt time.Duration // Request round trip time to track responsiveness (QoS) 請求迴應時間
    
        headerStarted time.Time // Time instance when the last header fetch was started    記錄最後一個header fetch的請求時間
        blockStarted time.Time // Time instance when the last block (body) fetch was started
        receiptStarted time.Time // Time instance when the last receipt fetch was started
        stateStarted time.Time // Time instance when the last node data fetch was started
        
        lacking map[common.Hash]struct{} // Set of hashes not to request (didn't have previously) 記錄的Hash值不會去請求，一般是因為之前的請求失敗
    
        peer Peer           // eth的peer
    
        version int // Eth protocol version number to switch strategies
        log log.Logger // Contextual logger to add extra infos to peer logs
        lock sync.RWMutex
    }



FetchXXX
FetchHeaders FetchBodies等函式 主要呼叫了eth.peer的功能來進行傳送資料請求。

    // FetchHeaders sends a header retrieval request to the remote peer.
    func (p *peerConnection) FetchHeaders(from uint64, count int) error {
        // Sanity check the protocol version
        if p.version < 62 {
            panic(fmt.Sprintf("header fetch [eth/62+] requested on eth/%d", p.version))
        }
        // Short circuit if the peer is already fetching
        if !atomic.CompareAndSwapInt32(&p.headerIdle, 0, 1) {
            return errAlreadyFetching
        }
        p.headerStarted = time.Now()
    
        // Issue the header retrieval request (absolut upwards without gaps)
        go p.peer.RequestHeadersByNumber(from, count, 0, false)
    
        return nil
    }

SetXXXIdle函式
SetHeadersIdle, SetBlocksIdle 等函式 設定peer的狀態為空閒狀態，允許它執行新的請求。 同時還會通過本次傳輸的資料的多少來重新評估鏈路的吞吐量。
    
    // SetHeadersIdle sets the peer to idle, allowing it to execute new header retrieval
    // requests. Its estimated header retrieval throughput is updated with that measured
    // just now.
    func (p *peerConnection) SetHeadersIdle(delivered int) {
        p.setIdle(p.headerStarted, delivered, &p.headerThroughput, &p.headerIdle)
    }

setIdle

    // setIdle sets the peer to idle, allowing it to execute new retrieval requests.
    // Its estimated retrieval throughput is updated with that measured just now.
    func (p *peerConnection) setIdle(started time.Time, delivered int, throughput *float64, idle *int32) {
        // Irrelevant of the scaling, make sure the peer ends up idle
        defer atomic.StoreInt32(idle, 0)
    
        p.lock.Lock()
        defer p.lock.Unlock()
    
        // If nothing was delivered (hard timeout / unavailable data), reduce throughput to minimum
        if delivered == 0 {
            *throughput = 0
            return
        }
        // Otherwise update the throughput with a new measurement
        elapsed := time.Since(started) + 1 // +1 (ns) to ensure non-zero divisor
        measured := float64(delivered) / (float64(elapsed) / float64(time.Second))
        
        // measurementImpact = 0.1 , 新的吞吐量=老的吞吐量*0.9 + 這次的吞吐量*0.1
        *throughput = (1-measurementImpact)*(*throughput) + measurementImpact*measured  
        // 更新RTT
        p.rtt = time.Duration((1-measurementImpact)*float64(p.rtt) + measurementImpact*float64(elapsed))
    
        p.log.Trace("Peer throughput measurements updated",
            "hps", p.headerThroughput, "bps", p.blockThroughput,
            "rps", p.receiptThroughput, "sps", p.stateThroughput,
            "miss", len(p.lacking), "rtt", p.rtt)
    }


XXXCapacity函式，用來返回當前的連結允許的吞吐量。

    // HeaderCapacity retrieves the peers header download allowance based on its
    // previously discovered throughput.
    func (p *peerConnection) HeaderCapacity(targetRTT time.Duration) int {
        p.lock.RLock()
        defer p.lock.RUnlock()
        // 這裡有點奇怪，targetRTT越大，請求的數量就越多。
        return int(math.Min(1+math.Max(1, p.headerThroughput*float64(targetRTT)/float64(time.Second)), float64(MaxHeaderFetch)))
    }


Lacks 用來標記上次是否失敗，以便下次同樣的請求不通過這個peer
        
        // MarkLacking appends a new entity to the set of items (blocks, receipts, states)
        // that a peer is known not to have (i.e. have been requested before). If the
        // set reaches its maximum allowed capacity, items are randomly dropped off.
        func (p *peerConnection) MarkLacking(hash common.Hash) {
            p.lock.Lock()
            defer p.lock.Unlock()
        
            for len(p.lacking) >= maxLackingHashes {
                for drop := range p.lacking {
                    delete(p.lacking, drop)
                    break
                }
            }
            p.lacking[hash] = struct{}{}
        }
        
        // Lacks retrieves whether the hash of a blockchain item is on the peers lacking
        // list (i.e. whether we know that the peer does not have it).
        func (p *peerConnection) Lacks(hash common.Hash) bool {
            p.lock.RLock()
            defer p.lock.RUnlock()
        
            _, ok := p.lacking[hash]
            return ok
        }


## peerSet

    // peerSet represents the collection of active peer participating in the chain
    // download procedure.
    type peerSet struct {
        peers map[string]*peerConnection
        newPeerFeed event.Feed
        peerDropFeed event.Feed
        lock sync.RWMutex
    }


Register 和 UnRegister

    // Register injects a new peer into the working set, or returns an error if the
    // peer is already known.
    //
    // The method also sets the starting throughput values of the new peer to the
    // average of all existing peers, to give it a realistic chance of being used
    // for data retrievals.
    func (ps *peerSet) Register(p *peerConnection) error {
        // Retrieve the current median RTT as a sane default
        p.rtt = ps.medianRTT()
    
        // Register the new peer with some meaningful defaults
        ps.lock.Lock()
        if _, ok := ps.peers[p.id]; ok {
            ps.lock.Unlock()
            return errAlreadyRegistered
        }
        if len(ps.peers) > 0 {
            p.headerThroughput, p.blockThroughput, p.receiptThroughput, p.stateThroughput = 0, 0, 0, 0
    
            for _, peer := range ps.peers {
                peer.lock.RLock()
                p.headerThroughput += peer.headerThroughput
                p.blockThroughput += peer.blockThroughput
                p.receiptThroughput += peer.receiptThroughput
                p.stateThroughput += peer.stateThroughput
                peer.lock.RUnlock()
            }
            p.headerThroughput /= float64(len(ps.peers))
            p.blockThroughput /= float64(len(ps.peers))
            p.receiptThroughput /= float64(len(ps.peers))
            p.stateThroughput /= float64(len(ps.peers))
        }
        ps.peers[p.id] = p
        ps.lock.Unlock()
    
        ps.newPeerFeed.Send(p)
        return nil
    }
    
    // Unregister removes a remote peer from the active set, disabling any further
    // actions to/from that particular entity.
    func (ps *peerSet) Unregister(id string) error {
        ps.lock.Lock()
        p, ok := ps.peers[id]
        if !ok {
            defer ps.lock.Unlock()
            return errNotRegistered
        }
        delete(ps.peers, id)
        ps.lock.Unlock()
    
        ps.peerDropFeed.Send(p)
        return nil
    }

XXXIdlePeers

    // HeaderIdlePeers retrieves a flat list of all the currently header-idle peers
    // within the active peer set, ordered by their reputation.
    func (ps *peerSet) HeaderIdlePeers() ([]*peerConnection, int) {
        idle := func(p *peerConnection) bool {
            return atomic.LoadInt32(&p.headerIdle) == 0
        }
        throughput := func(p *peerConnection) float64 {
            p.lock.RLock()
            defer p.lock.RUnlock()
            return p.headerThroughput
        }
        return ps.idlePeers(62, 64, idle, throughput)
    }

    // idlePeers retrieves a flat list of all currently idle peers satisfying the
    // protocol version constraints, using the provided function to check idleness.
    // The resulting set of peers are sorted by their measure throughput.
    func (ps *peerSet) idlePeers(minProtocol, maxProtocol int, idleCheck func(*peerConnection) bool, throughput func(*peerConnection) float64) ([]*peerConnection, int) {
        ps.lock.RLock()
        defer ps.lock.RUnlock()
    
        idle, total := make([]*peerConnection, 0, len(ps.peers)), 0
        for _, p := range ps.peers { //首先抽取idle的peer
            if p.version >= minProtocol && p.version <= maxProtocol {
                if idleCheck(p) {
                    idle = append(idle, p)
                }
                total++
            }
        }
        for i := 0; i < len(idle); i++ { // 氣泡排序， 從吞吐量大到吞吐量小。
            for j := i + 1; j < len(idle); j++ {
                if throughput(idle[i]) < throughput(idle[j]) {
                    idle[i], idle[j] = idle[j], idle[i]
                }
            }
        }
        return idle, total
    }

medianRTT,求得peerset的RTT的中位數，
    
    // medianRTT returns the median RTT of te peerset, considering only the tuning
    // peers if there are more peers available.
    func (ps *peerSet) medianRTT() time.Duration {
        // Gather all the currnetly measured round trip times
        ps.lock.RLock()
        defer ps.lock.RUnlock()
    
        rtts := make([]float64, 0, len(ps.peers))
        for _, p := range ps.peers {
            p.lock.RLock()
            rtts = append(rtts, float64(p.rtt))
            p.lock.RUnlock()
        }
        sort.Float64s(rtts)
    
        median := rttMaxEstimate
        if qosTuningPeers <= len(rtts) {
            median = time.Duration(rtts[qosTuningPeers/2]) // Median of our tuning peers
        } else if len(rtts) > 0 {
            median = time.Duration(rtts[len(rtts)/2]) // Median of our connected peers (maintain even like this some baseline qos)
        }
        // Restrict the RTT into some QoS defaults, irrelevant of true RTT
        if median < rttMinEstimate {
            median = rttMinEstimate
        }
        if median > rttMaxEstimate {
            median = rttMaxEstimate
        }
        return median
    }




網址：http://www.qukuailianxueyuan.io/



欲領取造幣技術與全套虛擬機器資料

區塊鏈技術交流QQ群：756146052  備註：CSDN

尹成學院微信：備註：CSDN



相關文章