This article compares RabbitMQ, RocketMQ, and Kafka on throughput, latency, scalability, and reliability, outlining each system's core features and recommending suitable scenarios such as reliable messaging, high‑performance streaming, and large‑scale real‑time data processing.
This article analytically compares UDP and TCP, detailing UDP’s minimalist design, low‑latency advantages, lack of congestion control and broadcast capabilities, while also explaining TCP’s reliability, congestion‑aware throughput and suitability for large or critical data, helping readers choose the optimal protocol for specific scenarios.
A low‑traffic B2B service struggled to meet a 500 req/s demand, achieving only 50 req/s with high CPU usage; through systematic profiling, lock analysis, async refactoring, thread‑pool tuning, and eliminating costly Spring bean creation, the team dramatically improved response times and throughput, revealing deeper CPU‑usage mysteries.
This article explains how Kafka’s sequential disk writes, zero‑copy data path, partition‑based parallelism, and configurable broker and partition settings enable linear‑scale throughput that can reach millions of transactions per second in large‑scale streaming systems.
This guide explains how to dramatically increase Kafka producer throughput by using batch sending, selecting appropriate compression algorithms, fine‑tuning producer configurations, employing asynchronous and concurrent sends, and optimizing client placement and network settings.
After discovering that only a few vLLM settings truly impact performance, this guide details how adjusting gpu_memory_utilization, max_num_batched_tokens, and enabling chunked prefill can raise Qwen2.5‑72B‑Instruct throughput from ~1800 to over 2500 tokens/s, improve latency, and provides comprehensive deployment, monitoring, and troubleshooting instructions.
This guide explains what constitutes high concurrency for Kafka, presents throughput benchmarks, and provides detailed broker‑level configuration tips—including partition planning, producer batching, storage optimization, and zero‑copy settings—to achieve scalable, low‑latency message processing.
In this detailed case study, the author walks through diagnosing and fixing severe throughput bottlenecks in a Java Spring‑based B2B service, covering lock contention, slow SQL, excessive logging, thread‑pool tuning, JVM memory adjustments, and the impact of bean creation on performance, ultimately achieving nearly a ten‑fold increase in requests per second.
This guide explains how to install fio on Ubuntu 20.04, configure test environments, run IOPS and latency benchmarks with specific parameters, and interpret key metrics such as bandwidth, IOPS, slat, and clat to evaluate storage performance under high‑load and single‑request scenarios.
This article details the cost and speed challenges of embedding vectors in large‑scale log scenarios, analyzes inference framework choices, describes GPU utilization, priority queuing, and pipeline redesigns, and reports a 16‑fold throughput increase and dramatically lower per‑request costs.
This article examines why many applications set overly large database connection pools, proposes a standard of ten connections per instance based on load‑testing results, and validates the recommendation through single‑interface and link‑level performance experiments that show no throughput degradation at lower connection counts.
A detailed benchmark comparing MySQL 9.0 and PostgreSQL 17.0 evaluates ingestion latency, throughput, saturation, and connection‑pool behavior, revealing that PostgreSQL consistently delivers lower write latency, higher QPS, better CPU and memory efficiency, and superior disk storage efficiency across both write and read workloads.
A ToB Java service that initially expected 500 requests per second fell to only 50 RPS under load, prompting a step‑by‑step investigation of CPU usage, lock contention, slow SQL, excessive logging, prototype‑scoped beans, and thread‑pool configuration, ultimately revealing how bean creation and async execution affect throughput.
This article provides a concise technical overview of AI chip key metrics—accuracy, throughput, latency, and energy consumption—explains their impact on hardware design, discusses critical design points such as MAC reduction and processing element optimization, and summarizes practical takeaways for evaluating AI accelerator solutions.
This article explains how packet loss in TCP/IP networks triggers retransmissions that dramatically increase HTTP latency, reduce throughput, and cause cascading failures, then details an experiment using ChaosMesh to quantify these effects across different payload sizes and loss rates, and offers practical testing guidelines.
The benchmark comparing MySQL 9.0 and PostgreSQL 17.0 shows PostgreSQL consistently achieving lower insertion latency, roughly double the throughput (≈19 k QPS vs 10 k QPS), using less CPU, memory and disk I/O, while both hit an 80‑connection pool limit and PostgreSQL maintains stable read latency as MySQL’s performance degrades beyond ~5.5 k QPS.
This article explains the key performance metrics TPS (transactions per second) and QPS (queries per second), provides formulas for calculating them, and demonstrates practical calculations for multi-node deployments, illustrating how request latency, thread pools, and instance count affect overall system concurrency and throughput.
This article provides a technical breakdown of AI chip key performance indicators—accuracy, throughput, latency, and energy consumption—explains how MAC and processing‑element design affect these metrics, and outlines design strategies for maximizing throughput while minimizing latency and power use.
Performance testing involves monitoring various metrics to assess system behavior under different conditions, including response time, throughput, CPU usage, memory utilization, and error rates.
This article details the design and implementation of a passive weak‑network diagnosis framework for a mobile app, covering background, overall architecture, data collection of HttpRTT and throughput, filtering strategies, weighted median calculations, caching, interface design, threshold definitions, performance metrics, and practical application scenarios.
The article explains the four essential network performance indicators—bandwidth, latency, jitter, and packet loss—defining each term, describing how they are measured, illustrating their impact with examples, and clarifying related concepts such as bits versus bytes, processing, queueing, transmission, and propagation delays.
Although a 1 GbE (1000 Mbps) link theoretically transfers 125 MB per second, real‑world speeds are lower due to protocol overhead, Ethernet framing, and MTU limits; understanding binary prefixes, frame structure, and employing jumbo frames can significantly improve effective throughput.
This article presents a comprehensive overview of large language model inference, describing the prefill and decoding stages, key performance metrics such as throughput, latency and QPS, and detailing a series of system-level optimizations—including pipeline parallelism, dynamic batching, KV‑cache quantization, and hardware considerations—to significantly improve inference efficiency on modern GPUs.
This article presents a comprehensive overview of large language model inference, detailing the prefill and decoding stages, key performance metrics such as throughput, latency and QPS, and a series of system-level optimizations—including pipeline parallelism, dynamic batching, specialized attention kernels, virtual memory allocation, KV‑cache quantization, and mixed‑precision strategies—to improve GPU utilization and overall inference efficiency.
This article documents a performance benchmark of AngusTester on a single node, demonstrating over 600,000 transactions per second against an Nginx HTTP server, and details the test purpose, environment, configuration, execution steps, and result analysis.
The article details a step‑by‑step investigation of a Spring Boot service that failed to meet a 500 requests/second target, analyzes slow SQL, thread‑pool misconfiguration, excessive logging, and high CPU usage, and presents concrete optimizations that roughly doubled throughput.
Faced with a client demanding 500 requests per second, I discovered my Java backend only handled 50 /s due to slow SQL, excessive logging, thread‑pool misconfiguration, and costly Spring bean creation; by adding latency alerts, async execution, reducing thread counts, and fixing Redis bean scope, throughput nearly doubled.
A Java‑based ToB service struggled to meet a 500 requests‑per‑second target, revealing hidden bottlenecks such as slow SQL, excessive prototype bean creation, logging overhead, and misconfigured thread pools, which were systematically identified and resolved to boost throughput and reduce latency.
The article details a step‑by‑step performance investigation and optimization of a Spring‑based ToB system, covering slow SQL, thread‑pool tuning, JVM memory adjustments, excessive logging, and bean‑creation overhead, ultimately improving throughput from 50 req/s to nearly the required 500 req/s.
This article documents a step‑by‑step investigation of a Java Spring backend that initially achieved only 50 requests per second under load, detailing how slow SQL, excessive logging, thread‑pool misconfiguration, bean‑creation overhead and CPU‑bound operations were identified and mitigated to roughly double the throughput while reducing response latency.
The article explains how organizations can boost software delivery stability and throughput by adopting continuous delivery, establishing consistent metrics, reducing manual testing, automating configuration and deployment, and applying incremental, value‑stream‑focused improvements to both technical and cultural processes.
This article explains how to diagnose low network throughput by examining sender, receiver, and intermediate bottlenecks, understanding TCP flow and congestion windows (rwnd and cwnd), using Linux ss commands, and interpreting Wireshark visualizations to pinpoint the root cause.
This article explains the definitions and differences of QPS and TPS, describes concurrency and throughput concepts, introduces related metrics such as PV, UV, DAU, MAU, and outlines key considerations for system performance testing and capacity planning.
This article explains system performance concepts such as throughput and latency, describes how to design and run performance tests, outlines methods for locating bottlenecks at the OS, code, network, and database levels, and presents practical optimization techniques ranging from algorithmic improvements to I/O and TCP tuning.
The article explains the core performance metrics QPS, TPS, response time (RT), concurrency, and throughput, provides formulas to relate them, demonstrates practical calculations for capacity planning, and discusses how to determine the optimal number of threads for a backend system.
This article explains the key performance metrics of backend systems—including QPS, TPS, response time, concurrency, and throughput—provides their definitions, relationships, practical calculation examples, and guidance on optimal thread counts for achieving balanced performance.
This article explains why network throughput may fall short of the link capacity, describes the three typical bottlenecks (sender, receiver, and intermediate network), and provides practical methods to examine TCP window sizes, congestion control variables, and Wireshark visualizations for pinpointing the root cause.
System performance examines the interplay of hardware and software components, focusing on latency, throughput, and cost reduction, while exploring essential concepts, measurement techniques, trade‑offs, optimization layers, ROI considerations, and practical guidelines for effective performance analysis across diverse computing environments.
This comprehensive guide explains Linux kernel performance profiling—both on‑CPU and off‑CPU—by stressing the need to target the critical 3 % of code, covering throughput, latency and power metrics, scalability laws, flame‑graph visualizations, perf and eBPF tools, lock‑contention analysis, and further reading recommendations.
This article compares Kafka and RabbitMQ across six real‑world scenarios—message ordering, routing, timeout handling, persistence, error handling, and throughput—to help engineers decide which message queue best fits their system requirements.
The article introduces a new R&D efficiency metric—throughput standard deviation—explains its statistical basis, shows how it was derived from annual reports, illustrates its application across multiple teams, and discusses practical insights and limitations for software development operations.
The article presents a new data‑refurbishing technique and the Revamper loading system that cut CPU‑heavy data‑augmentation costs while preserving model generalization, showing up to significant throughput gains for ResNet‑50 on ImageNet without sacrificing accuracy.
This article compares RabbitMQ and Kafka by explaining their architectures, queue consumption and production mechanisms, highlighting the master‑mirror design of RabbitMQ versus Kafka's partitioned approach, and summarizing their throughput characteristics to help engineers choose the appropriate messaging middleware for their needs.
This article compares the architectures of RabbitMQ and Kafka, explaining their queue models, master‑mirror and partition mechanisms, performance trade‑offs, and provides guidance on choosing between them based on throughput requirements and system design considerations.
This article explains QPS and TPS concepts, their differences, how they relate to concurrency, throughput, and key performance metrics such as PV, UV, DAU, and provides practical guidance for evaluating and testing system capacity.
This article explains the definitions of QPS and TPS, compares their meanings, explores related metrics such as concurrency, throughput, PV, UV, and DAU, and outlines key performance testing concepts and evaluation methods for system capacity and user experience.
Throughput measures the rate at which an application processes tasks, distinct from concurrency, and can be improved by reducing task latency, increasing parallelism, and optimizing lock usage through finer granularity, lower cost, and techniques like buffering, merging, and batch processing to mitigate contention and enhance scalability.
This article clarifies core web‑service metrics—QPS, TPS, PV, UV, DAU, MAU—explains their differences, shows how concurrency and throughput relate, and outlines key performance‑testing concepts and evaluation methods for modern system capacity planning.
This article explains core web performance metrics such as QPS, TPS, PV, UV, DAU, MAU, concurrency, and throughput, clarifies their differences, and outlines how to evaluate system capacity and performance from user, administrator, and developer perspectives.
This article traces the history of computer networking from early batch processing and time‑sharing systems through the emergence of LAN, WAN, TCP/IP, OSI model, and modern protocols, while explaining key concepts such as packet switching, routing, delay types, and physical media.
This article examines the challenges of existing stream‑processing benchmarks, introduces the open‑source Nexmark framework designed for reproducible, comprehensive performance testing, describes its metrics, query set, workload configurability, and presents experimental results on Flink, highlighting its role in advancing big‑data stream benchmarking.
This article explains the definitions and differences of QPS and TPS, how they relate to concurrency and system throughput, and introduces related metrics such as PV, UV, DAU, response time, and practical considerations for performance testing and capacity planning.
JMeter’s reported throughput can be misleading because it includes local processing time, especially when response validation such as regex extraction adds overhead, leading to significant underestimation of actual server load; the article demonstrates this with experiments and suggests micro‑benchmark corrections to obtain accurate results.
The article outlines seven essential performance metrics—response time and throughput, average load, error rate, GC pause time, business indicators, uptime, and log size—explaining their significance for application health and recommending popular monitoring tools for each metric.
This article explains what software performance means, how to measure it with metrics such as response time and throughput, how to diagnose problems, visualize time and space contributions, and apply optimization principles, capacity planning, and testing to keep systems performant.
This article explains core performance metrics such as Queries Per Second (QPS) and Transactions Per Second (TPS), distinguishes their differences, introduces related concepts like concurrency, PV, UV, and DAU, and outlines how to evaluate system throughput and conduct basic performance testing.
The article reveals that JMeter often reports inflated throughput because it includes client‑side processing time—such as regex extraction and post‑processors—in its calculations, leading to misleading performance metrics unless corrected with micro‑benchmark adjustments.
This article explains how reducing the size of a database connection pool can dramatically lower request latency and improve throughput, using HikariCP performance experiments, a simple sizing formula, and practical guidelines for configuring pools on modern hardware.
This article explains the definitions and differences of QPS and TPS, clarifies concurrency and throughput concepts, introduces related metrics such as PV, UV, DAU, and MAU, and outlines key performance testing considerations for system design and capacity planning.
This report presents a comprehensive performance‑testing plan for a Kafka cluster, detailing objectives, test scope, JVM and broker tuning, producer and consumer parameter experiments, extensive benchmark results, and practical recommendations for achieving high throughput and stability in large‑scale message processing.
High concurrency refers to a short period where a system receives a massive number of requests, such as ticket‑booking spikes, and is measured by metrics like response time, throughput, QPS, and concurrent users, while multithreading is merely one programming technique to handle such load, not synonymous with high concurrency.
The article uses a simple bank workflow with ten employees to illustrate how BIO, NIO, and asynchronous processing differ in task allocation and throughput, showing that dividing work among specialized roles dramatically increases the number of customers served per hour.
This article explains how to determine the optimal Kafka partition count by balancing throughput gains, key‑based ordering requirements, file descriptor limits, and availability impacts, offering practical guidelines such as testing hardware limits and using broker‑count multiples for scalable deployments.
This article evaluates the server‑side performance of three popular message middleware platforms—Kafka, RabbitMQ, and RocketMQ—by measuring throughput and latency when sending small 124‑byte messages, revealing that Kafka leads, followed by RocketMQ and then RabbitMQ.
This article provides a comprehensive overview of performance testing, explaining its definition, key metrics such as throughput, response time and concurrent users, the relationship between these indicators, optimal testing timing, a step‑by‑step workflow from requirement analysis to reporting, and practical tips for effective load testing and system optimization.
This article explains fundamental performance concepts—defining response time and throughput, using axiomatic methods, analyzing bottlenecks with sequence diagrams and profiling, applying Amdahl’s Law, and guiding capacity planning to build reliable, high‑performance applications.
The study benchmarks Apache Flink against Apache Storm on a shared cluster, showing Flink delivering three‑to‑five times higher throughput and roughly half the latency across simple, sleep‑induced, and windowed workloads, with modest throughput loss for exactly‑once semantics, leading to a recommendation of Flink for high‑performance, stateful real‑time stream processing.
The article summarizes the management novel “The Goal”, explaining how its Theory of Constraints concepts—throughput, inventory, operational expense, bottlenecks, and practical improvement steps—can be applied to manufacturing and DevOps to increase profitability and efficiency.
This article explains key website performance metrics such as response time, concurrency, and throughput, presents typical values for various operations, and outlines practical optimization strategies for front‑end, application‑server, and storage layers, including caching, CDN, reverse proxy, clustering, and code improvements.
This article explains what constitutes a database performance problem, outlines essential metrics such as response time, throughput, baseline and bottleneck identification, and presents practical tuning methods—including workload reduction, resource configuration, and optimization balance—to help engineers systematically improve database efficiency.
This article explains the end‑to‑end storage I/O path, analyzes how each node contributes to overall latency, compares IOPS and throughput, and provides practical guidance on configuring storage for Microsoft SQL Server workloads.
This article explains key performance testing concepts such as system throughput, QPS/TPS, concurrency, response time, and their interrelationships, provides practical calculation examples, shows how daily PV relates to TPS for different platforms, and outlines essential metrics and formulas for evaluating software performance.
A detailed benchmark compares Redis 3.0.7 and Hazelcast 3.6.1 on a four‑node HP ProLiant cluster, showing Redis excels with few clients while Hazelcast scales better under high concurrency, highlighting trade‑offs for developers and architects.
This article presents a comprehensive Kafka benchmark using six machines to evaluate producer and consumer throughput, replication effects, message size impact, and end‑to‑end latency, providing detailed results, analysis, and reproducible test commands.
This article explains the core concepts of system performance, defines throughput and latency, describes how to measure them, and provides detailed, code‑level techniques for locating and eliminating common performance bottlenecks across operating systems, networks, databases, and application code.
This article explains essential software performance testing concepts—including QPS/TPS, concurrency, response time, throughput calculations, think time, and how to estimate daily traffic using real‑world examples from e‑commerce platforms—providing formulas and practical guidance for engineers, administrators, and developers to assess and optimize system capacity.
This article provides a conceptual summary of SQL Server performance tuning, explaining the goals of optimizing response time and throughput, the importance of baselines and costs, factors influencing performance, and a step‑by‑step DETECT methodology for systematic optimization.
This article explains core performance testing concepts—including QPS, concurrency, response time, and throughput calculations—illustrates how to estimate system capacity, relate traffic metrics to daily PV, and outlines the perspectives of users, administrators, developers, and test engineers for evaluating software performance.
