github.com/igggame/nebulas-go@v2.1.0+incompatible/net/stream_manager_test.go (about)

     1  package net
     2  
     3  import (
     4  	"bytes"
     5  	"fmt"
     6  	"math/rand"
     7  	"sort"
     8  	"strconv"
     9  	"testing"
    10  	"time"
    11  
    12  	peer "github.com/libp2p/go-libp2p-peer"
    13  	ma "github.com/multiformats/go-multiaddr"
    14  )
    15  
    16  const (
    17  	maxstreamnumber = 10
    18  	reservednumber  = 2
    19  )
    20  
    21  var (
    22  	// weight of each msg type
    23  	msgWeight = map[string]MessageWeight{
    24  		HELLO:      MessageWeightZero,
    25  		OK:         MessageWeightZero,
    26  		BYE:        MessageWeightZero,
    27  		SYNCROUTE:  MessageWeightZero,
    28  		ROUTETABLE: MessageWeightRouteTable,
    29  
    30  		ChunkHeadersRequest:  MessageWeightZero,
    31  		ChunkHeadersResponse: MessageWeightChainChunks,
    32  		ChunkDataRequest:     MessageWeightZero,
    33  		ChunkDataResponse:    MessageWeightChainChunkData,
    34  
    35  		"newblock": MessageWeightNewBlock,
    36  		"dlblock":  MessageWeightZero,
    37  		"dlreply":  MessageWeightZero,
    38  		"newtx":    MessageWeightZero,
    39  	}
    40  
    41  	MsgTypes []string
    42  )
    43  
    44  func TestAllMsg(t *testing.T) {
    45  	msgtypes := []string{HELLO, OK, BYE, SYNCROUTE, ROUTETABLE,
    46  		ChunkHeadersRequest, ChunkHeadersResponse, ChunkDataRequest, ChunkDataResponse,
    47  		"newblock", "dlblock", "dlreply", "newtx",
    48  	}
    49  
    50  	MsgTypes = append(MsgTypes, msgtypes...)
    51  	run()
    52  }
    53  
    54  func TestUnvaluedMsg(t *testing.T) {
    55  	msgtypes := []string{HELLO, OK, BYE, SYNCROUTE,
    56  		ChunkHeadersRequest, ChunkDataRequest,
    57  		"dlblock", "dlreply", "newtx",
    58  	}
    59  
    60  	MsgTypes = append(MsgTypes, msgtypes...)
    61  	run()
    62  }
    63  
    64  func run() {
    65  
    66  	cleanupTicker := time.NewTicker(CleanupInterval / 12)
    67  	stopTicker := time.NewTicker(CleanupInterval / 12)
    68  	times := 0
    69  	config := NewConfigFromDefaults()
    70  	for {
    71  		select {
    72  		case <-stopTicker.C:
    73  			cleanupTicker.Stop()
    74  			stopTicker.Stop()
    75  			return
    76  		case <-cleanupTicker.C:
    77  			times++
    78  			fmt.Printf("mock %d\n: max num = %d, reserved = %d\n", times, maxstreamnumber, reservednumber)
    79  			sm := NewStreamManager(config)
    80  			sm.fillMockStreams(maxstreamnumber)
    81  			cleanup(sm)
    82  		}
    83  	}
    84  }
    85  
    86  func cleanup(sm *StreamManager) {
    87  	if sm.activePeersCount < maxstreamnumber {
    88  		return
    89  	}
    90  
    91  	// total number of each msg type
    92  	msgTotal := make(map[string]int)
    93  
    94  	svs := make(StreamValueSlice, 0)
    95  	sm.allStreams.Range(func(key, value interface{}) bool {
    96  		stream := value.(*Stream)
    97  
    98  		// t type, c count
    99  		for t, c := range stream.msgCount {
   100  			msgTotal[t] += c
   101  		}
   102  
   103  		svs = append(svs, &StreamValue{
   104  			stream: stream,
   105  		})
   106  
   107  		return true
   108  	})
   109  
   110  	fmt.Println("total:")
   111  	fmt.Println(orderedString(&msgTotal))
   112  
   113  	for _, sv := range svs {
   114  		for t, c := range sv.stream.msgCount {
   115  			w, _ := msgWeight[t]
   116  			sv.value += float64(c) * float64(w) / float64(msgTotal[t])
   117  		}
   118  	}
   119  
   120  	sort.Sort(sort.Reverse(svs))
   121  
   122  	fmt.Println("sorted:")
   123  	for _, sv := range svs {
   124  		fmt.Println(strconv.FormatFloat(sv.value, 'f', 3, 64), orderedString(&sv.stream.msgCount))
   125  	}
   126  
   127  	fmt.Println("eliminated:")
   128  	eliminated := svs[maxstreamnumber-reservednumber:]
   129  	for _, sv := range eliminated {
   130  		fmt.Println(strconv.FormatFloat(sv.value, 'f', 3, 64), orderedString(&sv.stream.msgCount))
   131  	}
   132  	fmt.Println("")
   133  }
   134  
   135  func (sm *StreamManager) fillMockStreams(num int32) {
   136  	sm.activePeersCount = num
   137  	fmt.Println("details:")
   138  
   139  	addr, _ := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/9999")
   140  
   141  	for ; num > 0; num-- {
   142  		key := "s" + strconv.FormatInt(int64(num), 10)
   143  
   144  		rand.Seed(time.Now().UnixNano())
   145  		msgCount := make(map[string]int)
   146  		for _, t := range MsgTypes {
   147  			msgCount[t] = rand.Intn(50)
   148  		}
   149  
   150  		pid, _ := peer.IDFromString(key)
   151  		sm.allStreams.Store(key, &Stream{
   152  			pid:      pid,
   153  			addr:     addr,
   154  			msgCount: msgCount,
   155  		})
   156  
   157  		fmt.Println(key, orderedString(&msgCount))
   158  	}
   159  }
   160  
   161  func orderedString(mc *map[string]int) string {
   162  	var buffer bytes.Buffer
   163  	for _, t := range MsgTypes {
   164  		buffer.WriteString(t + ":" + strconv.Itoa((*mc)[t]) + " ")
   165  	}
   166  	return buffer.String()
   167  }