wip

Author: julienrbrt

apps/testapp/kv/bench/main.go

@@ -17,6 +17,7 @@ import (
 )
 
 type serverStats struct {
+	InjectedTxs    uint64 `json:"injected_txs"`
 	ExecutedTxs    uint64 `json:"executed_txs"`
 	BlocksProduced uint64 `json:"blocks_produced"`
 }
@@ -73,24 +74,26 @@ func main() {
 	ticker := time.NewTicker(time.Second)
 	defer ticker.Stop()
 
-	var lastTxs uint64
-	var peakTPS uint64
+	var lastExecTxs uint64
+	var peakTPS float64
 
 loop:
 	for {
 		select {
 		case <-ctx.Done():
 			break loop
 		case <-ticker.C:
-			cur := totalTxs.Load()
-			tps := cur - lastTxs
-			lastTxs = cur
+			stats := fetchStats(*addr)
+			curExec := stats.ExecutedTxs - before.ExecutedTxs
+			delta := curExec - lastExecTxs
+			lastExecTxs = curExec
+			tps := float64(delta)
 			if tps > peakTPS {
 				peakTPS = tps
 			}
 			elapsed := time.Since(start).Truncate(time.Second)
-			fmt.Printf("\r[%6s] Total txs: %12d | Success: %12d | Fail: %8d | TPS: %12d   ",
-				elapsed, cur, success.Load(), failures.Load(), tps)
+			fmt.Printf("\r[%6s] Executed txs: %12d | Success: %12d | Fail: %8d | TPS: %12.0f   ",
+				elapsed, curExec, success.Load(), failures.Load(), tps)
 		}
 	}
 
@@ -102,12 +105,14 @@ loop:
 
 	after := fetchStats(*addr)
 
-	total := totalTxs.Load()
-	avgTPS := float64(total) / elapsed.Seconds()
-
-	var txsPerBlock float64
 	deltaBlocks := after.BlocksProduced - before.BlocksProduced
+	deltaInjected := after.InjectedTxs - before.InjectedTxs
 	deltaTxs := after.ExecutedTxs - before.ExecutedTxs
+
+	avgTPS := float64(deltaTxs) / elapsed.Seconds()
+	avgInjectedTPS := float64(deltaInjected) / elapsed.Seconds()
+
+	var txsPerBlock float64
 	if deltaBlocks > 0 {
 		txsPerBlock = float64(deltaTxs) / float64(deltaBlocks)
 	}
@@ -116,8 +121,8 @@ loop:
 
 	fmt.Println()
 	fmt.Println()
-	printResults(elapsed, uint64(*workers), uint64(*batchSize), total, success.Load(), failures.Load(),
-		avgTPS, float64(peakTPS), deltaBlocks, deltaTxs, txsPerBlock, reached, *targetRPS)
+	printResults(elapsed, uint64(*workers), uint64(*batchSize), totalTxs.Load(), success.Load(), failures.Load(),
+		avgTPS, avgInjectedTPS, peakTPS, deltaBlocks, deltaInjected, deltaTxs, txsPerBlock, reached, *targetRPS)
 }
 
 func singleWorker(ctx context.Context, addr string, success, failures, totalTxs *atomic.Uint64, done chan struct{}) {
@@ -293,8 +298,8 @@ func formatNum(n uint64) string {
 	return result.String()
 }
 
-func printResults(elapsed time.Duration, workers, batchSize, total, success, failures uint64,
-	avgTPS, peakTPS float64, blocks, executedTxs uint64, txsPerBlock float64, reached bool, targetRPS uint64) {
+func printResults(elapsed time.Duration, workers, batchSize, sentTxs, batches, failures uint64,
+	avgExecTPS, avgInjectedTPS, peakTPS float64, blocks, injectedTxs, executedTxs uint64, txsPerBlock float64, reached bool, targetRPS uint64) {
 
 	goalLabel := fmt.Sprintf("Goal (%s tx/s)", formatNum(targetRPS))
 	sep := "+----------------------------------------+----------------------------------------+"
@@ -307,15 +312,17 @@ func printResults(elapsed time.Duration, workers, batchSize, total, success, fai
 	fmt.Printf(rowFmt+"\n", "Workers", fmt.Sprintf("%d", workers))
 	fmt.Printf(rowFmt+"\n", "Batch Size", fmt.Sprintf("%d txs/request", batchSize))
 	fmt.Println(sep)
-	fmt.Printf(rowFmt+"\n", "Total Transactions", formatNum(total))
-	fmt.Printf(rowFmt+"\n", "Successful Requests", formatNum(success))
-	fmt.Printf(rowFmt+"\n", "Failed Requests", formatNum(failures))
+	fmt.Printf(rowFmt+"\n", "Client Txs Sent", formatNum(sentTxs))
+	fmt.Printf(rowFmt+"\n", "Successful Batches", formatNum(batches))
+	fmt.Printf(rowFmt+"\n", "Failed Batches", formatNum(failures))
 	fmt.Println(sep)
-	fmt.Printf(rowFmt+"\n", "Avg tx/s", formatFloat(avgTPS))
-	fmt.Printf(rowFmt+"\n", "Peak tx/s (1s window)", formatFloat(peakTPS))
+	fmt.Printf(rowFmt+"\n", "Avg Injected tx/s", formatFloat(avgInjectedTPS))
+	fmt.Printf(rowFmt+"\n", "Avg Executed tx/s", formatFloat(avgExecTPS))
+	fmt.Printf(rowFmt+"\n", "Peak Executed tx/s (1s)", formatFloat(peakTPS))
 	fmt.Println(sep)
-	fmt.Printf(rowFmt+"\n", "Server Blocks Produced", formatNum(blocks))
+	fmt.Printf(rowFmt+"\n", "Server Txs Injected", formatNum(injectedTxs))
 	fmt.Printf(rowFmt+"\n", "Server Txs Executed", formatNum(executedTxs))
+	fmt.Printf(rowFmt+"\n", "Server Blocks Produced", formatNum(blocks))
 	fmt.Printf(rowFmt+"\n", "Avg Txs per Block", fmt.Sprintf("%.2f", txsPerBlock))
 	fmt.Println(sep)
 
@@ -329,8 +336,12 @@ func printResults(elapsed time.Duration, workers, batchSize, total, success, fai
 	} else {
 		fmt.Printf(rowFmt+"\n", goalLabel, "NOT REACHED")
 		fmt.Println(sep)
-		fmt.Printf("\n  Achieved %.2f%% of target (%.1fx away)\n",
-			avgTPS/float64(targetRPS)*100, float64(targetRPS)/avgTPS)
+		if avgExecTPS > 0 {
+			fmt.Printf("\n  Achieved %.2f%% of target (%.1fx away)\n",
+				avgExecTPS/float64(targetRPS)*100, float64(targetRPS)/avgExecTPS)
+		} else {
+			fmt.Printf("\n  No transactions executed during the test.\n")
+		}
 	}
 }