This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

Vcpuperf

The vcpuperf utility measures your server's CPU processing speed and compares it against benchmarks for common server CPUs.

The vcpuperf utility measures your server's CPU processing speed and compares it against benchmarks for common server CPUs. The utility performs a CPU test and measures the time it takes to complete the test. The lower the number scored on the test, the better the performance of the CPU.

The vcpuperf utility also checks the high and low load times to determine if CPU throttling is enabled. If a server's low-load computation time is significantly longer than the high-load computation time, CPU throttling may be enabled. CPU throttling is a power-saving feature. However, CPU throttling can reduce the performance of your server. Vertica recommends disabling CPU throttling to enhance server performance.

Syntax

vcpuperf [-q]

Options

-q
Run in quiet mode. Quiet mode displays only the CPU Time, Real Time, and high and low load times.

Returns

  • CPU Time: the amount of time it took the CPU to run the test.

  • Real Time: the total time for the test to execute.

  • High load time: The amount of time to run the load test while simulating a high CPU load.

  • Low load time: The amount of time to run the load test while simulating a low CPU load.

Example

The following example shows a CPU that is running slightly slower than the expected time on a Xeon 5670 CPU that has CPU throttling enabled.

[root@node1 bin]# /opt/vertica/bin/vcpuperf
Compiled with: 4.1.2 20080704 (Red Hat 4.1.2-52) Expected time on Core 2, 2.53GHz: ~9.5s
Expected time on Nehalem, 2.67GHz: ~9.0s
Expected time on Xeon 5670, 2.93GHz: ~8.0s

This machine's time:
  CPU Time: 8.540000s
  Real Time:8.710000s

Some machines automatically throttle the CPU to save power.
  This test can be done in <100 microseconds (60-70 on Xeon 5670, 2.93GHz).
  Low load times much larger than 100-200us or much larger than the corresponding high load time
    indicate low-load throttling, which can adversely affect small query / concurrent performance.

This machine's high load time: 67 microseconds.
This machine's low load time: 208 microseconds.

Understanding vcpuperf results across Vertica versions

You might observe higher CPU times when running the vcpuperf utility with Vertica versions 25.3 and later than with Vertica 23.x. This discrepancy does not indicate a degradation in CPU performance on newer servers or in newer Vertica versions. The vcpuperf utility is highly sensitive to the compiler used to build it. The vcpuperf executable included with Vertica 23.x was compiled using GCC 7.3.1, whereas the executable used with Vertica 25.3 was compiled with GCC 12.2.1. Significant differences in generated machine code between compiler versions mean that results from binaries built with different GCC versions are not directly comparable. Therefore, higher CPU time reported by vcpuperf in Vertica 25.3 may reflect changes to the vcpuperf toolchain rather than an actual CPU performance issue. To make meaningful comparisons, do one of the following:

  • Always use the same vcpuperf executable version.
  • Ensure that results are properly calibrated for comparability when comparing across different Vertica releases.

Interpreting vcpuperf benchmark results

The vcpuperf utility is a micro-benchmark designed to assess CPU performance. However, its results require careful interpretation, especially when comparing across different Vertica versions or environments.

Understanding vcpuperf sensitivity

Different versions of the vcpuperf executable, particularly those shipped with different Vertica releases, may have been compiled with different compiler versions (e.g., GCC 7.3.1 versus GCC 12.2.1). The key factors influencing vcpuperf results are:

  • Compiler version: Significant changes in compiler versions can drastically alter the generated machine code. This includes variations in instruction selection, scheduling, loop handling, register allocation, and CPU tuning.
  • CPU throttling: Machines might automatically throttle the CPU to save power. A low-load time significantly higher than the corresponding high-load time, particularly when it exceeds 100–200 microseconds, can indicate low-load throttling. This throttling can adversely affect small-query and concurrent performance.

Limitations of direct comparison

Due to its compiler sensitivity, vcpuperf results from binaries built with different compiler versions are not directly comparable. For example, higher vcpuperf numbers observed in Vertica 25.3 compared to Vertica 23.x do not necessarily indicate a degradation in CPU performance or a hardware problem. Instead, such discrepancies often reflect a change in the vcpuperf toolchain. Benchmark results for C/C++ workloads can vary due to compiler and optimization changes. Therefore, compiler-related variations in benchmark outcomes might not reflect changes in the underlying hardware or processor performance.

Guidance for interpreting results

To ensure accurate and meaningful interpretation of vcpuperf results, consider the following guidelines:

  • Avoid direct comparison across Vertica versions: Do not directly compare vcpuperf results obtained from different Vertica versions if the underlying vcpuperf executable was built with different compiler or toolchain versions.
  • Calibrate for comparability: If direct comparison across different vcpuperf binaries or compiler versions is unavoidable, ensure that results are properly calibrated for comparability. This may involve establishing new baseline expectations for each specific vcpuperf binary and compiler combination.
  • Focus on trends within a single environment: vcpuperf is most effective for identifying performance changes within a consistent environment using the same vcpuperf binary. Monitor trends and significant deviations from an established baseline on a specific system.
  • Identify throttling: Compare the reported low load and high load times. A low load time significantly greater than the high load time or much greater than 100-200 microseconds can indicate CPU throttling.

When reviewing vcpuperf benchmark results, consider the effect of toolchain and compiler differences, as they can contribute to observed performance variations independent of hardware changes.