基准测试

概述

此应用程序演示了如何正确测量处理 VPI 任务所花费的时间。它遵循了 基准测试方法 章节中描述的简化版本。

简而言之，此示例返回 5x5 高斯滤波器 算法执行时间的一系列测量值的中位数。每次测量包括运行该算法 50 次并取平均运行时间。这种批量测量和取中位数的形式可以得到更稳定的运行时间值，因为它排除了外部干扰因素。

说明

用法是

./vpi_sample_05_benchmark <backend>

其中

• backend: 可以是 cpu、cuda 或 pva；它定义了将执行处理的后端。

这是一个示例

./vpi_sample_05_benchmark cuda

这是使用 CUDA 后端。尝试其他后端以查看它们之间的处理时间差异。

结果

注意

下面显示的基准测试结果仅用于演示目的，因此，我们在此处不指定所使用的硬件。您应该在要从中收集基准测试信息的平台上运行此示例。

CPU 后端

输入尺寸：1920 x 1080
图像格式：VPI_IMAGE_FORMAT_U16
算法：5x5 高斯滤波器
每次调用的大概运行时间：2.368492 毫秒

CUDA 后端

输入尺寸：1920 x 1080
图像格式：VPI_IMAGE_FORMAT_U16
算法：5x5 高斯滤波器
每次调用的大概运行时间：0.043012 毫秒

PVA 后端

输入尺寸：1920 x 1080
图像格式：VPI_IMAGE_FORMAT_U16
算法：5x5 高斯滤波器
NVMEDIA_ARRAY: 53, 版本 2.1
NVMEDIA_VPI : 172, 版本 2.4
每次调用的大概运行时间：1.692010 毫秒

源代码

为了方便起见，这里提供了也安装在 samples 目录中的代码。

语言 C++

#include <vpi/Event.h>
#include <vpi/Image.h>
#include <vpi/Status.h>
#include <vpi/Stream.h>
#include <vpi/algo/GaussianFilter.h>

#include <algorithm>
#include <cstdio>
#include <iostream>
#include <sstream>
#include <vector>

#define CHECK_STATUS(STMT) \
 do \
 { \
 VPIStatus status = (STMT); \
 if (status != VPI_SUCCESS) \
 { \
 char buffer[VPI_MAX_STATUS_MESSAGE_LENGTH]; \
 vpiGetLastStatusMessage(buffer, sizeof(buffer)); \
 std::ostringstream ss; \
 ss << "" #STMT "\n"; \
 ss << vpiStatusGetName(status) << ": " << buffer; \
 throw std::runtime_error(ss.str()); \
 } \
 } while (0);

int main(int argc, char *argv[])
{
 VPIImage image = NULL;
 VPIImage blurred = NULL;
 VPIStream stream = NULL;

 VPIEvent evStart = NULL;
 VPIEvent evStop = NULL;

 int retval = 0;

 try
 {
 // 1. Processing of command line parameters -----------

 if (argc != 2)
 {
 throw std::runtime_error(std::string("Usage: ") + argv[0] + " <cpu|pva|cuda>");
 }

 std::string strBackend = argv[1];

 // Parse the backend
 VPIBackend backend;

 if (strBackend == "cpu")
 {
 backend = VPI_BACKEND_CPU;
 }
 else if (strBackend == "cuda")
 {
 backend = VPI_BACKEND_CUDA;
 }
 else if (strBackend == "pva")
 {
 backend = VPI_BACKEND_PVA;
 }
 else
 {
 throw std::runtime_error("Backend '" + strBackend +
 "' not recognized, it must be either cpu, cuda or pva.");
 }

 // 2. Initialization stage ----------------------

 // Create the stream for only the target backend.
 uint64_t streamFlags = (uint64_t)backend | VPI_REQUIRE_BACKENDS;
 CHECK_STATUS(vpiStreamCreate(streamFlags, &stream));

 int width = 1920, height = 1080;
 VPIImageFormat imgFormat = VPI_IMAGE_FORMAT_U16;

 std::cout << "Input size: " << width << " x " << height << '\n'
 << "Image format: " << vpiImageFormatGetName(imgFormat) << '\n'
 << "Algorithm: 5x5 Gaussian Filter on " << strBackend << std::endl;

 // Memory flags set to guarantee top performance.
 // Only the benchmarked backend is enabled, and memories
 // are guaranteed to be used by only one stream.
 uint64_t memFlags = (uint64_t)backend | VPI_EXCLUSIVE_STREAM_ACCESS;

 // Create image with zero content
 CHECK_STATUS(vpiImageCreate(width, height, imgFormat, memFlags, &image));

 // Create a temporary image convolved with a low-pass filter.
 CHECK_STATUS(vpiImageCreate(width, height, imgFormat, memFlags, &blurred));

 // Create the events we'll need to get timing info
 CHECK_STATUS(vpiEventCreate(backend, &evStart));
 CHECK_STATUS(vpiEventCreate(backend, &evStop));

 // 3. Gather timings --------------------

 const int BATCH_COUNT = 20;
 const int AVERAGING_COUNT = 50;

 // Collect measurements for each execution batch
 std::vector<float> timingsMS;
 for (int batch = 0; batch < BATCH_COUNT; ++batch)
 {
 // Record stream queue when we start processing
 CHECK_STATUS(vpiEventRecord(evStart, stream));

 // Get the average running time within this batch.
 for (int i = 0; i < AVERAGING_COUNT; ++i)
 {
 // Call the algorithm to be measured.
 CHECK_STATUS(vpiSubmitGaussianFilter(stream, backend, image, blurred, 5, 5, 1, 1, VPI_BORDER_ZERO));
 }

 // Record stream queue just after blurring
 CHECK_STATUS(vpiEventRecord(evStop, stream));

 // Wait until the batch processing is done
 CHECK_STATUS(vpiEventSync(evStop));

 float elapsedMS;
 CHECK_STATUS(vpiEventElapsedTimeMillis(evStart, evStop, &elapsedMS));
 timingsMS.push_back(elapsedMS / AVERAGING_COUNT);
 }

 // 4. Performance analysis ----------------------

 // Get the median of the measurements so that outliers aren't considered.
 nth_element(timingsMS.begin(), timingsMS.begin() + timingsMS.size() / 2, timingsMS.end());
 float medianMS = timingsMS[timingsMS.size() / 2];

 printf("Approximated elapsed time per call on %s: %f ms\n", strBackend.c_str(), medianMS);
 }
 catch (std::exception &e)
 {
 std::cerr << e.what() << std::endl;
 retval = 1;
 }

 // 4. Clean up -----------------------------------

 // Destroy stream first, it'll make sure all processing
 // submitted to it is finished.
 vpiStreamDestroy(stream);

 // Now we can destroy other VPI objects, since they aren't being
 // used anymore.
 vpiImageDestroy(image);
 vpiImageDestroy(blurred);
 vpiEventDestroy(evStart);
 vpiEventDestroy(evStop);

 return retval;
}