IO Measurement

From VoIPmonitor.org
Jump to navigation Jump to search


This guide explains how to use standard Linux tools to benchmark and measure the performance of your server's storage subsystem. Understanding your disk's I/O capabilities is critical for ensuring a stable, high-performance VoIPmonitor installation, especially when recording calls.

Why Disk Performance Matters

A VoIPmonitor sensor that records call audio (PCAP files) can generate a very high number of small, random write operations. If your storage cannot keep up, you may experience:

  • Packet loss, as memory buffers on the sensor fill up.
  • Incomplete or corrupted call recordings.
  • General system instability.

The two most important metrics to measure are:

  • IOPS (Input/Output Operations Per Second): The number of read or write operations a disk can perform per second. This is crucial for handling many concurrent calls.
  • Latency: The time it takes for a single I/O operation to complete. Low latency is essential for a responsive system.

The tools `ioping` and `fio` can help you benchmark these metrics.

Step 1: Install the Benchmarking Tools

First, install `ioping` and `fio` using your distribution's package manager.

For Debian / Ubuntu
sudo apt-get update
sudo apt-get install fio ioping
For CentOS / RHEL / AlmaLinux
sudo yum install epel-release
sudo yum install fio ioping

Tool 1: `ioping` - Quick Latency Check

`ioping` is a simple tool that works like the `ping` command, but for disk latency instead of network latency. It's an excellent way to get a quick feel for how responsive your storage is.

Usage

Run the command from within the directory you want to test (e.g., your VoIPmonitor spool directory). This example sends 10 requests.

# Navigate to the directory you want to test
cd /var/spool/voipmonitor

# Run ioping
ioping -c 10 .

Interpreting the Results

4 KiB <<< . (ext4 /dev/sda2): request=1 time=426.1 us
4 KiB <<< . (ext4 /dev/sda2): request=2 time=1.06 ms
...
4 KiB <<< . (ext4 /dev/sda2): request=10 time=1.10 ms

--- . (ext4 /dev/sda2) ioping statistics ---
9 requests completed in 8.52 s, 1 iops, 4.2 KiB/s
min/avg/max/mdev = 147.7 us / 946.7 us / 1.10 ms / 284.4 us
  • Key Metric: Look at the `time=` value for each request and the final `min/avg/max` statistics.
  • What to Look For: For SSDs or NVMe drives, average latency should be well under 1 millisecond (`< 1.00 ms`). For spinning disks (HDDs), latencies of a few milliseconds are more typical. Consistently high latency spikes indicate a potential problem.

Tool 2: `fio` - Comprehensive Throughput & IOPS Test

`fio` (Flexible I/O Tester) is the industry-standard tool for advanced storage benchmarking. It can simulate various types of workloads, including the mixed read/write patterns typical of a VoIPmonitor sensor.

Warning: `fio` will create a large test file in the directory where you run it. Always run it in a directory with sufficient free space, and remember to delete the test file afterward.

Example 1: Mixed Read/Write Test

This command simulates a workload that is 75% reads and 25% writes, which is a realistic scenario for a server running both the sensor and the GUI.

# This command creates a 4GB test file named 'test'
fio --randrepeat=1 --ioengine=libaio --direct=1 --gtod_reduce=1 --name=test --filename=test --bs=4k --iodepth=64 --size=4G --readwrite=randrw --rwmixread=75

Example 2: 100% Random Read Test

This command tests pure random read performance, which is important for GUI responsiveness when loading historical data.

# This also creates a 4GB test file named 'test'
fio --randrepeat=1 --ioengine=libaio --direct=1 --gtod_reduce=1 --name=test --filename=test --bs=4k --iodepth=64 --size=4G --readwrite=randread

Interpreting the Results

The output from `fio` is very detailed, but you should focus on these key lines:

Run status group 0 (all jobs):
   READ: io=3070.4MB, aggrb=83363KB/s, minb=83363KB/s, maxb=83363KB/s, mint=37714msec, maxt=37714msec
  WRITE: io=1025.8MB, aggrb=27849KB/s, minb=27849KB/s, maxb=27849KB/s, mint=37714msec, maxt=37714msec
...
  read : io=3070.4MB, bw=83364KB/s, iops=20840, runt= 37714msec
  write: io=1025.8MB, bw=27850KB/s, iops=6962, runt= 37714msec
...
Disk stats (read/write):
  sda: ios=781939/261286 ... util=99.93%
  • Key Metrics:
   * `iops`: This is the most important number. It tells you how many read and write operations per second your storage handled. For VoIPmonitor, random write IOPS are particularly critical. A modern SSD should deliver tens of thousands of IOPS.
   * `bw` (or `aggrb`): This is the throughput or bandwidth in KB/s or MB/s. It shows how much data per second was moved.
  • What to Look For: The `util` (utilization) metric should be close to 100%. If it is, it means `fio` successfully pushed your storage to its maximum limit, and the resulting `iops` and `bw` numbers are a true representation of its peak performance.

Final Step: Clean Up

After you are finished with your tests, remember to delete the large file created by `fio`.

rm test

AI Summary for RAG

Summary: This guide explains how to benchmark disk I/O performance on a VoIPmonitor server using the standard Linux tools `ioping` and `fio`. It begins by clarifying why disk performance, particularly IOPS and latency, is critical for stable call recording. The guide provides step-by-step instructions for installing these tools on both Debian/Ubuntu and CentOS/RHEL systems. It then details the use of `ioping` as a simple tool for quick disk latency checks. The main part of the article focuses on `fio`, the flexible I/O tester, providing and explaining command-line examples for both a mixed read/write workload and a pure random read test. Crucially, it includes an "Interpreting the Results" section that instructs the user on which specific metrics to focus on in the `fio` output, such as `iops` (I/O Operations Per Second) and `bw` (bandwidth), and how to verify that the disk was pushed to its maximum (`util=100%`). The guide concludes with the important final step of deleting the test file created by `fio`. Keywords: performance, benchmark, disk, storage, i/o, iops, latency, throughput, bandwidth, fio, ioping, test, randrw, randread, `ioengine=libaio`, `direct=1` Key Questions:

  • How can I test the disk speed of my server?
  • What are `fio` and `ioping`?
  • How do I benchmark my storage for VoIPmonitor?
  • What do the `iops` and `bw` metrics in the `fio` output mean?
  • How can I check my disk latency from the command line?
  • What is a good number of IOPS for a VoIPmonitor server?
  • How to run a mixed random read/write test with `fio`?