Quelle est la meilleure façon de comparer le débit de transactions de Sui ?

Question

Je fais des recherches sur les performances de Sui et je souhaite comparer le débit des transactions sur Testnet. Quels outils et méthodologies dois-je utiliser ? *

Owen · Answer

To benchmark Sui’s transaction throughput, use the Sui SDK to submit a high volume of transactions with varying object dependencies. Focus on independent, owned-object operations to maximize parallel execution. Use programmable transaction blocks (PTBs) to batch multiple operations and measure transactions per second (TPS) over a fixed duration. Monitor results via sui_getTransactionBlocks and analyze end-to-end latency. Ensure your workload avoids shared object contention, which limits parallelism. For accuracy, run tests against a dedicated testnet RPC endpoint and aggregate data across multiple runs.

Ashford · Answer

To benchmark Sui’s transaction throughput effectively and validate its performance claims, there are several tools, techniques, and methodologies you can use. Testing on Sui Testnet can help you measure how well the network handles various types of transactions, and ensure that the system behaves as expected under load. Heres a structured approach to benchmark Sui’s transaction throughput: 1. Define Key Metrics to Measure Before you start, define what specific metrics you want to measure. Common benchmarks for transaction throughput include: Transactions per second (TPS): This is the primary metric to measure the throughput of the network. Latency (transaction confirmation time): The time it takes for a transaction to be processed and confirmed by the network. Gas consumption: Measure the gas cost per transaction and how that varies with different transaction types. 2. Use Sui’s Built-in Benchmarking Tools Sui provides a few ways to benchmark and measure performance: a) Sui Client CLI The Sui CLI (sui client) can be used to interact with the Testnet and can also be used to simulate transactions. By using the simulate-transaction command, you can gauge the expected gas cost and latency of transactions. Example: sui client simulate-transaction --gas-budget 10000 --transaction This will give you an estimate of gas and help you measure the time it takes to simulate transactions on the Testnet. b) Sui Benchmarking Scripts (Custom Scripts) You can write benchmarking scripts using Suis SDK (in TypeScript, Python, or other supported languages). These scripts can simulate and send transactions at a specified rate to the Testnet, allowing you to measure throughput. Example: const { SuiClient, TransactionBlock } = require(@mysten/sui.js); const client = new SuiClient({ rpcUrl: https://testnet.sui.io/rpc }); async function benchmarkTransactions(numTransactions: number) { const startTime = Date.now(); for (let i = 0; i < numTransactions; i++) { const txn = new TransactionBlock(); // Add the move call or transaction logic await client.submitTransaction(txn); } const endTime = Date.now(); console.log(Processed ${numTransactions} transactions in ${endTime - startTime}ms); } benchmarkTransactions(1000); // Benchmark 1000 transactions This script would help you track how many transactions can be processed within a given timeframe and calculate the TPS. 3. Use Stress Test Tools For more extensive testing and to simulate high loads, you can use stress testing tools to push large volumes of transactions to the Testnet: a) Artillery or JMeter These are load testing tools that can be configured to send a high volume of transactions (or requests) to Sui’s Testnet. With Artillery, for example, you can create scenarios that mimic real-world user behavior and send large amounts of API requests to your Sui RPC endpoint to measure response times and throughput. Example with Artillery: config: target: https://testnet.sui.io/rpc phases: duration: 60 arrivalRate: 100 # 100 requests per second scenarios: flow: post: url: /submit_transaction json: transaction: your_transaction_data_here This setup will simulate 100 requests per second to the Sui Testnet for 60 seconds and measure the TPS and latency. b) Locust Locust is another load testing tool that is highly configurable. You can create load test scenarios by defining the behavior of simulated users, specifying the rate of requests, and measuring throughput. Example with Locust: from locust import HttpUser, task, between class SuiTestUser(HttpUser): wait_time = between(1, 2) @task def send_transaction(self): self.client.post(/submit_transaction, json={transaction: your_transaction_data_here}) This can simulate a large number of concurrent users and help you measure the performance under load. 4. Monitor Node Performance and Resource Usage CPU, Memory, Disk: Measure how much CPU, memory, and disk are being used on the nodes during heavy transaction loads. Network Latency: Monitor network latency, especially between validator nodes and RPC endpoints, as high latency can affect throughput. Suis Built-in Metrics: Monitor Suis built-in metrics like the number of successful transactions, failed transactions, and gas usage using prometheus or similar monitoring tools. 5. Benchmark with Multiple Fee Tiers Sui supports multiple fee tiers. Its important to benchmark transactions across different fee tiers to see how fee structures affect throughput. Test transactions across low, medium, and high fee tiers to see if the gas fee influences transaction processing speed. Experiment with different gas budgets to optimize for performance while keeping gas costs reasonable. 6. Check for Latency and Block Times Another metric to measure is latency and block times for transactions. High throughput doesn’t necessarily mean low latency, so monitor: Time to finality: How long does it take for a transaction to be fully confirmed and added to the ledger? Block time consistency: Is block production consistent, or do delays occur under high load? 7. Use Sui Explorer for Monitoring Sui Explorer and other blockchain explorers can help you see the throughput in terms of transactions per block and provide insight into transaction confirmation times. 8. Analyzing Results and Benchmark Comparisons After conducting the tests: Analyze the throughput (TPS): Compare how Sui performs under different loads. Look for patterns or bottlenecks where throughput drops significantly. Measure the latencies: See how long it takes for transactions to get processed and confirmed. Network/Node Impact: Ensure that performance is not being hindered by network congestion or node performance issues. Summary of Methodology: Use the Sui CLI to simulate transactions and gather gas estimates. Stress test with tools like Artillery, JMeter, or Locust to measure TPS and latency. Monitor resource usage on nodes during testing (CPU, memory, disk, network). Test across multiple fee tiers to understand how gas structures affect throughput. Use Sui Explorer and other monitoring tools to gather real-time data on throughput and performance. Benchmark different gas budgets to optimize for speed and cost. By combining these tools and methodologies, you can get a clear understanding of Sui’s transaction throughput on the Testnet and evaluate its performance under various loads and configurations.

Arnold · Answer

Use Sui Benchmark Tools (sui-benchmark) or custom scripts to stress-test TPS. 1. Quick Test (CLI) Install sui-benchmark cargo install --git https://github.com/MystenLabs/sui sui-benchmark Run load test (adjust --tx-count) sui-benchmark --testbed testnet --workload transfer-object --tx-count 1000 2. Custom TS Script import { SuiClient } from @mysten/sui.js/client; const client = new SuiClient({ url: https://fullnode.testnet.sui.io }); // Send parallel TXs const txs = Array(100).fill(0).map(() => client.transferObject(...)); await Promise.all(txs); // Measure time vs success rate Key Metrics TPS: Transactions per second (count committed TXs). Latency: Time to finality. Error Rate: Failed TXs.

Paul · Answer

To benchmark Suis transaction throughput on the Testnet and assess its performance claims, you need to carefully design your testing approach and use the right tools to simulate realistic transaction loads. Below is a detailed methodology and recommended tools for benchmarking Suis performance: 1. Define Benchmarking Objectives Transaction Throughput: Measure how many transactions per second (TPS) Sui can handle under various conditions. Latency: Measure the time it takes for a transaction to be processed and confirmed. Scalability: Test how Sui’s performance scales as the number of nodes, validators, and transaction volume increases. 2. Tools to Use Here are some tools and methodologies for benchmarking transaction throughput: Sui Client & RPC Sui CLI: Use the official Sui CLI to submit transactions, query block states, and measure transaction performance. sui client can help measure the time taken to execute a transaction, which can help you assess the transaction throughput under different load conditions. Load Testing Tools Locust (or other load-testing tools like Artillery, Gatling): These tools are excellent for simulating high loads and generating traffic to your Testnet. Locust allows you to define custom transaction scenarios and simulate multiple users sending transactions simultaneously. You can write a Locust script that connects to the Sui Testnet RPC endpoint and sends transactions (e.g., creating or transferring objects) while measuring the time taken to process them. Example Locust script to benchmark: from locust import HttpUser, task, between class SuiBenchmark(HttpUser): wait_time = between(1, 3) # Simulate user wait time between actions @task def send_transaction(self): response = self.client.post(/sui/transaction, json={ Your transaction payload here }) assert response.status_code == 200 Custom Transaction Load Create a custom script to send Sui transactions in bulk through the RPC API. This can be a basic Python or Node.js script that interacts with the Sui Testnet and measures: The time taken to send a batch of transactions. The average latency and throughput as a function of load. Example using Python and the requests library: import time import requests def send_transaction(): url = https://rpc.sui.io headers = {Content-Type: application/json} data = { method: sui_executeTransaction, params: [transaction_data], # Your transaction data here } response = requests.post(url, json=data, headers=headers) return response.status_code def benchmark_transactions(n): start_time = time.time() for _ in range(n): send_transaction() end_time = time.time() print(fProcessed {n} transactions in {end_time - start_time} seconds) benchmark_transactions(1000) # Benchmark 1000 transactions Benchmarking Tools Specific to Sui Sui Explorer: You can also use the Sui Explorer to manually monitor transactions, check block heights, and track transaction speeds during your benchmarking period. Sui Metrics: Sui may expose some metrics endpoints to monitor validator performance and system health. You can use these to measure the actual system throughput from the network’s perspective (e.g., average TPS over a period). External Benchmarking Services If you need to benchmark against other blockchains or even compare Sui with other networks, services like Chainlink’s VRF (for randomness) or Lighthouse can provide cross-chain benchmarks. You can use DeFiLlama for comparative analysis between Sui and other blockchain projects if they publish performance data. 3. Benchmarking Methodology Single-Transaction Throughput Test the time it takes for a single transaction to go through the entire network and be confirmed. Measure the latency and compare it across different transaction types (e.g., object creation vs. object transfer). Batch Throughput (Multiple Transactions) To stress-test the network, send a batch of transactions in quick succession, and track the throughput (TPS). This will give you an idea of how Sui handles high-volume operations. Concurrency and Load Testing Test how well Sui performs under varying loads by simulating multiple users or bots interacting with the network. Gradually increase the load and measure: TPS as load increases. Latency for individual transactions under load. Simulate Real-World Transactions Benchmark with realistic transactions such as creating NFTs, transferring coins, and executing smart contract logic. This reflects the true performance of the network under diverse conditions. Stress Test Test for extreme conditions (e.g., sending thousands of transactions in a short time) to see how Sui scales and identify any bottlenecks. 4. Key Metrics to Measure Transactions per Second (TPS): The number of successful transactions that the system processes per second. Latency: The time it takes for a transaction to be confirmed after submission. Measure both average and peak latency. Gas Usage: Track how much gas is used per transaction to understand how much it costs to execute different transaction types. Block Times: Measure the time it takes for blocks to be produced and transactions to be included in the block. 5. Analyzing and Interpreting Results After running your tests: Plot TPS vs. Load: This helps visualize how Sui performs under increasing transaction loads. Latencies: Look for spikes in latency as the system is stressed. A sudden increase in latency could indicate a bottleneck in processing. Scaling Behavior: Evaluate if throughput improves as more resources (nodes/validators) are added to the network. 6. Other Considerations Network Latency: Ensure you’re testing from a server that is geographically close to the Sui Testnet to avoid external network latency. Validators: Consider how many active validators are participating in your test to assess how well the network scales with increasing nodes. 7. Common Pitfalls to Avoid Overloading RPC: Be mindful of rate limiting on the Testnet RPC. Avoid sending too many requests too quickly, as this could artificially affect your results. Testnet Instability: Keep in mind that Testnets are not always as stable as Mainnets, so any test results may be influenced by temporary network conditions. Conclusion To benchmark Suis transaction throughput effectively, you need to simulate realistic loads using transaction batching, load testing tools, and the Sui RPC API. Measure key metrics like TPS, latency, and gas usage, and ensure to test under concurrent loads and stress conditions. The results will give you insights into Sui’s scalability, latency, and how it performs in different scenarios, allowing you to assess its true capabilities.

Evgeniy CRYPTOCOIN · Answer

To benchmark Sui’s TPS (transactions per second): Use Sui’s Benchmarking Tools – sui-benchmark for controlled load tests. Deploy Custom Workloads – Simulate real-world transactions (transfers, smart contracts). Monitor with Metrics – Track TPS, latency, and success rate via Prometheus/Grafana. Testnet vs Local – Compare public Testnet vs a private local network for baseline. Check Validator Load – High TPS depends on validator performance. Tip: Review Sui’s docs for latest tools like sui-tps.

Alya · Answer

Use Suis sui-benchmark tool with custom workloads on Testnet for accurate TPS measurement. Focus on parallelizable transactions and adjust submission rate to find saturation point.

Bekky · Answer

Best Way to Benchmark Sui’s Transaction Throughput (Testnet/Mainnet) 1. Tools for Benchmarking Sui CLI + Scripts (Basic) Generate 1000 simple transfer TXs for i in {1..1000}; do sui client transfer-sui --to 0xRECEIVER --amount 1 --gas-budget 5000000 & done TypeScript Load Tester (Advanced) import { SuiClient, TransactionBlock } from @mysten/sui.js; const client = new SuiClient({ url: https://fullnode.testnet.sui.io }); const SENDER = 0xYOUR_WALLET; const RECEIVER = 0xTARGET; async function sendBatch(txCount: number) { const startTime = Date.now(); const promises = Array(txCount).fill(0).map(() => { const tx = new TransactionBlock(); tx.transferObjects([tx.gas], RECEIVER); return client.signAndExecuteTransactionBlock({ transactionBlock: tx, signer: SENDER_KEY }); }); await Promise.all(promises); const tps = txCount / ((Date.now() - startTime) / 1000); console.log(TPS: ${tps}); } Sui Benchmarking Kit (SBK) (Official) git clone https://github.com/MystenLabs/sui-benchmark cd sui-benchmark cargo run -- --test-tps --tx-count 10000 --num-workers 16 2. Key Metrics to Track | Metric | How to Measure | Target (Testnet) | |--------|--------------|------------------| | TPS | (Successful TXs) / (Total Time) | 1K–5K (depends on gas) | | Latency | Finality Time (P50/P99) | < 1s (no shared objects) | | Gas Efficiency | Gas Used / TX | ~50K–500K per TX |

BigSneh · Answer

Use the sui-benchmark tool, which is included in the Sui GitHub repo. It allows you to simulate thousands of transactions per second using multiple workers. Clone the repo and run cargo run --release --bin sui-benchmark -- --help to explore benchmarking options like TPS rate, target objects, and thread count. Spin up your own Sui local cluster (sui-test-validator) for controlled tests, or benchmark on Testnet, noting that public networks have variable load. Choose what type of transaction to test: transfer_object, coin_split, or custom Move module functions. Each has a different gas profile and object handling complexity. Generate a large batch of objects (or shared objects) and pre-fund test accounts to remove bottlenecks from coin availability. Use --num-workers, --num-threads, and --target-tps flags to scale your test while tracking latency and throughput stats. Enable metrics collection via Prometheus and Grafana to observe latency, success rate, and gas usage over time. Run tests under different network and node conditions to understand the ceiling — localnet will show higher TPS than Testnet due to validator latency. For comparison, benchmark simple versus complex transactions (e.g., basic transfers vs shared-object mutating calls) to see how transaction type impacts throughput. Document gas consumption, error rates, and confirmed TPS (vs submitted TPS) to produce a comprehensive performance profile.

SuiLover · Answer

To benchmark Sui’s transaction throughput on Testnet, start by setting up a local validator or use the official Testnet with a controlled transaction environment. Use the sui-benchmark tool from the Sui GitHub repo, which is designed for simulating high-volume transactions with configurable parameters. You can also script transactions using the TypeScript or Rust SDKs to send batches of transactions in parallel and measure end-to-end performance. Monitor metrics like TPS (transactions per second), latency, and success rate using Prometheus and Grafana dashboards if youre running your own node. For more granular control, simulate realistic workloads like NFT mints, asset transfers, or dApp-specific calls. Make sure you isolate variables by disabling non-essential logging, syncing, and background processes during benchmarking. Use --num-workers and --num-transactions flags in the benchmark CLI to test various load scenarios. You should also compare throughput with shared objects versus owned object transactions, as shared object execution can be more complex. Capture logs and error rates to detect bottlenecks, especially around gas usage and consensus latency. Repeat the test under different network conditions to assess stability and consistency.

Thorfin · Answer

To benchmark Sui’s throughput on Testnet: Tools: Sui Benchmarker: Official tool in the Sui GitHub repo (sui-benchmark). Custom scripts: Use sui-sdk or CLI to send batched txs. Third-party load testers: Tools like Chainhammer (if adapted to Sui). Method: Use multiple accounts and send parallel transactions. Track TPS (tx/sec) and latency. Vary tx types (e.g. coin transfers vs. Move calls). Run tests at different times to avoid RPC throttling. Use local fullnodes or dedicated RPCs for accurate, uncontested results.

theking · Answer

You should begin by setting up a Testnet environment using sui start --testnet or switch your CLI to Testnet to ensure you’re testing in the correct network context. Once ready, use a stress-testing methodology by generating and sending many independent transactions in parallel, especially those that involve owned object operations—this leverages Sui’s parallel execution model and avoids shared-object contention bottlenecks. You can employ the Sui CLI with sui client batch to submit a file of preconstructed transactions at high concurrency, or write a custom script using the JavaScript SDK to fire many signAndExecuteTransactionBlock calls concurrently. Always monitor throughput metrics like transactions per second (TPS), latency, and conflict rates using CLI feedback or logs—you can script repeated dry-runs to establish baseline costs before actual deployment. To get realistic performance, ensure your workload avoids shared-object hotspots, and measure under high-load scenarios where parallelism shines. After each test, analyze metrics, check for ConflictTransaction errors, and reflect on bottlenecks—then adjust your object and call patterns and test again. Building this in iterations gives you a step-by-step understanding of throughput ceilings under realistic conditions. Read more here: https://docs.sui.io/build/parallel-execution

Métrique	Comment mesurer	Cible (Testnet)
TPS	`(Successful TXs) / (Total Time)`	1K-5K (selon le gaz)
Latence	`Finality Time (P50/P99)`	< 1s (aucun objet partagé)
Efficacité gazeuse		`Gas Used / TX`~50 K—500 K par TX

Publication

Partagez vos connaissances.

Quelle est la meilleure façon de comparer le débit de transactions de Sui ?

Réponses

1.Définissez les indicateurs clés à mesurer

a)Interface utilisateur CLI

b)Scripts d'analyse comparative Sui (scripts personnalisés)

3.Utilisez des outils de test de résistance

a)ArtillerieouJMeter

b)Criquet

Résumé de la méthodologie :

1.Définir les objectifs de l'analyse comparative

3.Méthodologie d'analyse comparative

Conclusion

Connaissez-vous la réponse ?

Gagne ta part de 1000 Sui