IO Measurement

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`?