Jae Kwon
10 years ago
7 changed files with 879 additions and 174 deletions
Split View
Diff Options
-
+380 -150blocks/block_manager.go
-
+4 -4common/heap.go
-
+10 -0db/level_db.go
-
+3 -0db/mem_db.go
-
+59 -15p2p/connection.go
-
+12 -5p2p/peer.go
-
+411 -0sim/bench.go
+ 380
- 150
blocks/block_manager.go
View File
+ 4
- 4
common/heap.go
View File
+ 10
- 0
db/level_db.go
View File
+ 3
- 0
db/mem_db.go
View File
+ 59
- 15
p2p/connection.go
View File
+ 12
- 5
p2p/peer.go
View File
+ 411
- 0
sim/bench.go
View File
| @ -0,0 +1,411 @@ | |||
| package main | |||
| import ( | |||
| "container/heap" | |||
| "fmt" | |||
| "math/rand" | |||
| ) | |||
| const seed = 0 | |||
| const numNodes = 50000 // Total number of nodes to simulate | |||
| const minNumPeers = 10 // Each node should be connected to at least this many peers | |||
| const maxNumPeers = 15 // ... and at most this many | |||
| const latencyMS = int32(500) // One way packet latency | |||
| const partTxMS = int32(10) // Transmission time per peer of 4KB of data. | |||
| const sendQueueCapacity = 100 // Amount of messages to queue between peers. | |||
| func init() { | |||
| rand.Seed(seed) | |||
| } | |||
| //----------------------------------------------------------------------------- | |||
| type Peer struct { | |||
| node *Node // Pointer to node | |||
| sent int32 // Time of last packet send, including transmit time. | |||
| remote int // SomeNode.peers[x].node.peers[remote].node is SomeNode for all x. | |||
| parts []byte // [32]byte{} bitarray of received block pieces. | |||
| } | |||
| // Send a data event to the peer, or return false if queue is "full". | |||
| // Depending on how many event packets are "queued" for peer, | |||
| // the actual recvTime may be adjusted to be later. | |||
| func (p *Peer) sendEventData(event EventData) bool { | |||
| desiredRecvTime := event.RecvTime() | |||
| minRecvTime := p.sent + partTxMS + latencyMS | |||
| if desiredRecvTime >= minRecvTime { | |||
| p.node.sendEvent(event) | |||
| p.sent += partTxMS | |||
| return true | |||
| } else { | |||
| if (minRecvTime-desiredRecvTime)/partTxMS > sendQueueCapacity { | |||
| return false | |||
| } else { | |||
| event.SetRecvTime(minRecvTime) // Adjust recvTime | |||
| p.node.sendEvent(event) | |||
| p.sent += partTxMS | |||
| return true | |||
| } | |||
| } | |||
| } | |||
| // Since EventPart events are much smaller, we don't consider the transmit time, | |||
| // and assume that the sendQueue is always free. | |||
| func (p *Peer) sendEventParts(event EventParts) { | |||
| p.node.sendEvent(event) | |||
| } | |||
| // Does the peer's .parts (as received by an EventParts event) contain part? | |||
| func (p *Peer) knownToHave(part uint8) bool { | |||
| return p.parts[part/8]&(1<<(part%8)) > 0 | |||
| } | |||
| //----------------------------------------------------------------------------- | |||
| type Node struct { | |||
| index int | |||
| peers []*Peer | |||
| parts []byte | |||
| events *Heap | |||
| } | |||
| func (n *Node) sendEvent(event Event) { | |||
| n.events.Push(event, event.RecvTime()) | |||
| } | |||
| func (n *Node) recvEvent() Event { | |||
| return n.events.Pop().(Event) | |||
| } | |||
| func (n *Node) receive(part uint8) bool { | |||
| x := n.parts[part/8] | |||
| nx := x | (1 << (part % 8)) | |||
| if x == nx { | |||
| return false | |||
| } else { | |||
| n.parts[part/8] = nx | |||
| return true | |||
| } | |||
| } | |||
| // returns false if already connected, or remote node has too many connections. | |||
| func (n *Node) canConnectTo(node *Node) bool { | |||
| if len(n.peers) > maxNumPeers { | |||
| return false | |||
| } | |||
| for _, peer := range n.peers { | |||
| if peer.node == node { | |||
| return false | |||
| } | |||
| } | |||
| return true | |||
| } | |||
| func (n *Node) isFull() bool { | |||
| for _, part := range n.parts { | |||
| if part != byte(0xff) { | |||
| return false | |||
| } | |||
| } | |||
| return true | |||
| } | |||
| func (n *Node) String() string { | |||
| return fmt.Sprintf("{N:%d}", n.index) | |||
| } | |||
| //----------------------------------------------------------------------------- | |||
| type Event interface { | |||
| RecvTime() int32 | |||
| SetRecvTime(int32) | |||
| } | |||
| type EventData struct { | |||
| time int32 // time of receipt. | |||
| part uint8 | |||
| } | |||
| func (e EventData) RecvTime() int32 { | |||
| return e.time | |||
| } | |||
| func (e EventData) SetRecvTime(time int32) { | |||
| e.time = time | |||
| } | |||
| func (e EventData) String() string { | |||
| return fmt.Sprintf("[%d:%d]", e.time, e.part) | |||
| } | |||
| type EventParts struct { | |||
| time int32 // time of receipt. | |||
| src int // src node's peer index on destination node. | |||
| parts []byte | |||
| } | |||
| func (e EventParts) RecvTime() int32 { | |||
| return e.time | |||
| } | |||
| func (e EventParts) SetRecvTime(time int32) { | |||
| e.time = time | |||
| } | |||
| func (e EventParts) String() string { | |||
| return fmt.Sprintf("[%d:%d:%d]", e.time, e.src, e.parts) | |||
| } | |||
| //----------------------------------------------------------------------------- | |||
| func createNetwork() []*Node { | |||
| nodes := make([]*Node, numNodes) | |||
| for i := 0; i < numNodes; i++ { | |||
| n := &Node{ | |||
| index: i, | |||
| peers: []*Peer{}, | |||
| parts: make([]byte, 32), | |||
| events: NewHeap(), | |||
| } | |||
| nodes[i] = n | |||
| } | |||
| for i := 0; i < numNodes; i++ { | |||
| n := nodes[i] | |||
| for j := 0; j < minNumPeers; j++ { | |||
| if len(n.peers) > j { | |||
| // Already set, continue | |||
| continue | |||
| } | |||
| pidx := rand.Intn(numNodes) | |||
| for !n.canConnectTo(nodes[pidx]) { | |||
| pidx = rand.Intn(numNodes) | |||
| } | |||
| // connect to nodes[pidx] | |||
| remote := nodes[pidx] | |||
| remote_j := len(remote.peers) | |||
| n.peers = append(n.peers, &Peer{node: remote, remote: remote_j, parts: make([]byte, 32)}) | |||
| remote.peers = append(remote.peers, &Peer{node: n, remote: j, parts: make([]byte, 32)}) | |||
| } | |||
| } | |||
| return nodes | |||
| } | |||
| func printNodes(nodes []*Node) { | |||
| for _, node := range nodes { | |||
| peerStr := "" | |||
| for _, peer := range node.peers { | |||
| peerStr += fmt.Sprintf(" %v", peer.node.index) | |||
| } | |||
| fmt.Printf("[%v] peers: %v\n", node.index, peerStr) | |||
| } | |||
| } | |||
| func countFull(nodes []*Node) (fullCount int) { | |||
| for _, node := range nodes { | |||
| if node.isFull() { | |||
| fullCount += 1 | |||
| } | |||
| } | |||
| return fullCount | |||
| } | |||
| func main() { | |||
| // Global vars | |||
| nodes := createNetwork() | |||
| timeMS := int32(0) | |||
| proposer := nodes[0] | |||
| for i := 0; i < 32; i++ { | |||
| proposer.parts[i] = byte(0xff) | |||
| } | |||
| //printNodes(nodes[:]) | |||
| // The proposer sends parts to all of its peers. | |||
| for i := 0; i < len(proposer.peers); i++ { | |||
| timeMS := int32(0) // scoped | |||
| peer := proposer.peers[i] | |||
| for j := 0; j < 256; j++ { | |||
| // Send each part to a peer, but each peer starts at a different offset. | |||
| part := uint8((j + i*25) % 256) | |||
| recvTime := timeMS + latencyMS + partTxMS | |||
| event := EventData{ | |||
| time: recvTime, | |||
| part: part, | |||
| } | |||
| peer.sendEventData(event) | |||
| timeMS += partTxMS | |||
| } | |||
| } | |||
| // Run simulation | |||
| for { | |||
| // Lets run the simulation for each user until endTimeMS | |||
| // We use latencyMS/2 since causality has at least this much lag. | |||
| endTimeMS := timeMS + latencyMS/2 | |||
| fmt.Printf("simulating until %v\n", endTimeMS) | |||
| // Print out the network for debugging | |||
| if true { | |||
| for i := 40000; i < 40050; i++ { | |||
| node := nodes[i] | |||
| fmt.Printf("[%v] parts: %X\n", node.index, node.parts) | |||
| } | |||
| } | |||
| for _, node := range nodes { | |||
| // Iterate over the events of this node until event.time >= endTimeMS | |||
| for { | |||
| _event, ok := node.events.Peek().(Event) | |||
| if !ok || _event.RecvTime() >= endTimeMS { | |||
| break | |||
| } else { | |||
| node.events.Pop() | |||
| } | |||
| switch _event.(type) { | |||
| case EventData: | |||
| event := _event.(EventData) | |||
| // Process this event | |||
| if !node.receive(event.part) { | |||
| // Already has this part, ignore this event. | |||
| continue | |||
| } | |||
| // Let's iterate over peers & see which needs this piece. | |||
| recvTime := event.time + latencyMS + partTxMS | |||
| for _, peer := range node.peers { | |||
| if peer.knownToHave(event.part) { | |||
| continue | |||
| } | |||
| peer.sendEventData(EventData{ | |||
| time: recvTime, | |||
| part: event.part, | |||
| }) | |||
| } | |||
| case EventParts: | |||
| event := _event.(EventParts) | |||
| node.peers[event.src].parts = event.parts | |||
| } | |||
| } | |||
| } | |||
| // If network is full, quit. | |||
| if countFull(nodes) == numNodes { | |||
| fmt.Printf("Done! took %v ms", timeMS) | |||
| break | |||
| } | |||
| // Lets increment the timeMS now | |||
| timeMS += latencyMS / 2 | |||
| // Send EventParts rather frequently. It's cheap. | |||
| for _, node := range nodes { | |||
| for _, peer := range node.peers { | |||
| peer.sendEventParts(EventParts{ | |||
| time: timeMS + latencyMS, | |||
| src: peer.remote, | |||
| parts: node.parts, | |||
| }) | |||
| } | |||
| newParts := make([]byte, 32) | |||
| copy(newParts, node.parts) | |||
| node.parts = newParts | |||
| } | |||
| } | |||
| } | |||
| // ---------------------------------------------------------------------------- | |||
| type Heap struct { | |||
| pq priorityQueue | |||
| } | |||
| func NewHeap() *Heap { | |||
| return &Heap{pq: make([]*pqItem, 0)} | |||
| } | |||
| func (h *Heap) Len() int { | |||
| return len(h.pq) | |||
| } | |||
| func (h *Heap) Peek() interface{} { | |||
| if len(h.pq) == 0 { | |||
| return nil | |||
| } | |||
| return h.pq[0].value | |||
| } | |||
| func (h *Heap) Push(value interface{}, priority int32) { | |||
| heap.Push(&h.pq, &pqItem{value: value, priority: priority}) | |||
| } | |||
| func (h *Heap) Pop() interface{} { | |||
| item := heap.Pop(&h.pq).(*pqItem) | |||
| return item.value | |||
| } | |||
| /* | |||
| func main() { | |||
| h := NewHeap() | |||
| h.Push(String("msg1"), 1) | |||
| h.Push(String("msg3"), 3) | |||
| h.Push(String("msg2"), 2) | |||
| fmt.Println(h.Pop()) | |||
| fmt.Println(h.Pop()) | |||
| fmt.Println(h.Pop()) | |||
| } | |||
| */ | |||
| /////////////////////// | |||
| // From: http://golang.org/pkg/container/heap/#example__priorityQueue | |||
| type pqItem struct { | |||
| value interface{} | |||
| priority int32 | |||
| index int | |||
| } | |||
| type priorityQueue []*pqItem | |||
| func (pq priorityQueue) Len() int { return len(pq) } | |||
| func (pq priorityQueue) Less(i, j int) bool { | |||
| return pq[i].priority < pq[j].priority | |||
| } | |||
| func (pq priorityQueue) Swap(i, j int) { | |||
| pq[i], pq[j] = pq[j], pq[i] | |||
| pq[i].index = i | |||
| pq[j].index = j | |||
| } | |||
| func (pq *priorityQueue) Push(x interface{}) { | |||
| n := len(*pq) | |||
| item := x.(*pqItem) | |||
| item.index = n | |||
| *pq = append(*pq, item) | |||
| } | |||
| func (pq *priorityQueue) Pop() interface{} { | |||
| old := *pq | |||
| n := len(old) | |||
| item := old[n-1] | |||
| item.index = -1 // for safety | |||
| *pq = old[0 : n-1] | |||
| return item | |||
| } | |||
| func (pq *priorityQueue) Update(item *pqItem, value interface{}, priority int32) { | |||
| heap.Remove(pq, item.index) | |||
| item.value = value | |||
| item.priority = priority | |||
| heap.Push(pq, item) | |||
| } | |||