block bw measurements

cmd/lazyledger_measurements_1/main.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+    "fmt"
+    "crypto/rand"
+
+    "github.com/musalbas/lazyledger-prototype"
+)
+
+const namespaceSize = 8
+
+func main() {
+    txAmounts := []int{128, 2048}
+    txSize := 128
+    for _, txes := range txAmounts {
+        sb := generateSimpleBlock(txes, 128)
+        sbBandwidth := len(sb.PrevHash()) + len(sb.MessagesRoot()) + txSize * txes
+
+        pb := generateProbabilisticBlock(txes, 128)
+        req, _ := pb.RequestSamples(10)
+        res := pb.RespondSamples(req)
+        pbBandwidth := 0
+        for _, root := range pb.RowRoots() {
+            pbBandwidth += len(root)
+        }
+        for _, root := range pb.ColumnRoots() {
+            pbBandwidth += len(root)
+        }
+        for _, proof := range res.Proofs {
+            for _, hash := range proof {
+                pbBandwidth += len(hash)
+            }
+        }
+
+        fmt.Println(txes, sbBandwidth, pbBandwidth)
+    }
+}
+
+func generateSimpleBlock(txes int, txSize int) *lazyledger.SimpleBlock {
+    txSize -= namespaceSize
+    sb := lazyledger.NewSimpleBlock([]byte{0})
+
+    for i := 0; i < txes; i++ {
+        messageData := make([]byte, txSize)
+        rand.Read(messageData)
+        sb.AddMessage(*lazyledger.NewMessage([namespaceSize]byte{0}, messageData))
+    }
+
+    return sb.(*lazyledger.SimpleBlock)
+}
+
+func generateProbabilisticBlock(txes int, txSize int) *lazyledger.ProbabilisticBlock {
+    txSize -= namespaceSize + 2
+    pb := lazyledger.NewProbabilisticBlock([]byte{0}, 128)
+
+    for i := 0; i < txes; i++ {
+        messageData := make([]byte, txSize)
+        rand.Read(messageData)
+        pb.AddMessage(*lazyledger.NewMessage([namespaceSize]byte{0}, messageData))
+    }
+
+    return pb.(*lazyledger.ProbabilisticBlock)
+}

simpleblock.go

@@ -45,26 +45,30 @@ func ImportSimpleBlock(prevHash []byte, messages []Message) Block {
 func (sb *SimpleBlock) AddMessage(message Message) {
     sb.messages = append(sb.messages, message)
 
-    // Recompute the messagesRoot
-    ndf := NewNamespaceDummyFlagger()
-    fh := NewFlagHasher(ndf, sha256.New())
-    tree := merkletree.New(fh)
-    for _, message := range sb.messages {
-        tree.Push(message.Marshal())
-    }
-    sb.messagesRoot = tree.Root()
+    // Force recompututation of messagesRoot
+    sb.messagesRoot = nil
 }
 
 // MessagesRoot returns the Merkle root of the messages in the block.
 func (sb *SimpleBlock) MessagesRoot() []byte {
+    if sb.messagesRoot == nil {
+        ndf := NewNamespaceDummyFlagger()
+        fh := NewFlagHasher(ndf, sha256.New())
+        tree := merkletree.New(fh)
+        for _, message := range sb.messages {
+            tree.Push(message.Marshal())
+        }
+        sb.messagesRoot = tree.Root()
+    }
+
     return sb.messagesRoot
 }
 
 // Digest computes the hash of the block.
 func (sb *SimpleBlock) Digest() []byte {
     hasher := sha256.New()
     hasher.Write(sb.prevHash)
-    hasher.Write(sb.messagesRoot)
+    hasher.Write(sb.MessagesRoot())
     return hasher.Sum(nil)
 }
 
@@ -81,7 +85,7 @@ func (sb *SimpleBlock) Valid() bool {
     for _, message := range sb.messages {
         tree.Push(message.Marshal())
     }
-    if bytes.Compare(tree.Root(), sb.messagesRoot) == 0 {
+    if bytes.Compare(tree.Root(), sb.MessagesRoot()) == 0 {
         return true
     }
     return false
@@ -166,7 +170,7 @@ func (sb *SimpleBlock) VerifyApplicationProof(namespace [namespaceSize]byte, pro
     } else {
         lh = NewHashLeafHasher(hashes)
     }
-    result, err := merkletree.VerifyRangeProof(lh, fh, proofStart, proofEnd, proof, sb.messagesRoot)
+    result, err := merkletree.VerifyRangeProof(lh, fh, proofStart, proofEnd, proof, sb.MessagesRoot())
     if !result || err != nil {
         return false
     }
@@ -219,7 +223,7 @@ func (sb *SimpleBlock) VerifyDependency(index int, hash []byte, proof [][]byte)
     ndf := NewNamespaceDummyFlagger()
     fh := NewFlagHasher(ndf, sha256.New())
     lh := NewHashLeafHasher([][]byte{hash})
-    result, err := merkletree.VerifyRangeProof(lh, fh, index, index + 1, proof, sb.messagesRoot)
+    result, err := merkletree.VerifyRangeProof(lh, fh, index, index + 1, proof, sb.MessagesRoot())
     if result && err == nil {
         sb.provenDependencies[string(hash)] = true
         return true