Linux测试处理fps为30、1920*1080、一分钟的视频性能

美丽的神话  金牌会员 | 昨天 21:41 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 820|帖子 820|积分 2460

前置条件

模拟fps为30、1920*1080、一分钟的视频
项目CMakeLists.txt
  1. cmake_minimum_required(VERSION 3.30)
  2. project(testOpenGl)
  4. set(CMAKE_CXX_STANDARD 11)
  6. add_executable(testOpenGl main.cpp
  7.         testOpenCl.cpp
  8.         testOpenCl.h
  9.         TestCpp.cpp
  10.         TestCpp.h
  11.         TestCppThread.cpp
  12.         TestCppThread.h
  13.         TestSIMD.cpp
  14.         TestSIMD.h)
  16. # 查找OpenCL
  17. find_package(OpenCL REQUIRED)
  19. # 链接OpenCl库
  20. target_include_directories(testOpenGl PRIVATE ${OpenCL_INCLUDE_DIRS})
  21. target_link_libraries(testOpenGl PRIVATE ${OpenCL_LIBRARIES})
  23. # 检测SIMD支持并添加编译选项
  24. include(CheckCXXCompilerFlag)
  26. check_cxx_compiler_flag("-mavx" COMPILER_SUPPORTS_AVX)
  27. check_cxx_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
  29. if(COMPILER_SUPPORTS_AVX2)
  30.     target_compile_options(testOpenGl PRIVATE -mavx2)
  31. elseif (COMPILER_SUPPORTS_AVX)
  32.     target_compile_options(testOpenGl PRIVATE -mavx)
  33. else ()
  34.     message(FATAL_ERROR "AVX or AVX2 is not supported by compiler")
  35. endif ()
复制代码
C++代码

  1. //
  2. // Created by lai on 2025/1/17.
  3. //
  5. #include "TestCpp.h"
  7. #include <iostream>
  8. #include <vector>
  9. #include <random>
  10. #include <chrono>
  12. // 灰度转换函数
  13. void to_gray(const std::vector<unsigned char>& input, std::vector<unsigned char>& output, int width, int height) {
  14.     for (int i = 0; i < width * height; ++i) {
  15.         int offset = i * 3;  // RGB 分量
  16.         unsigned char r = input[offset];
  17.         unsigned char g = input[offset + 1];
  18.         unsigned char b = input[offset + 2];
  19.         // 灰度公式
  20.         output[i] = static_cast<unsigned char>(0.299f * r + 0.587f * g + 0.114f * b);
  21.     }
  22. }
  23. void TestCpp::runTest() {
  24.     const int width = 1920;         // 视频宽度
  25.     const int height = 1080;        // 视频高度
  26.     const int fps = 30;             // 帧率
  27.     const int duration = 60;        // 视频持续时间（秒）
  28.     const int frameCount = fps * duration; // 总帧数
  30.     // 模拟视频帧数据：随机生成每帧的 RGB 数据
  31.     std::vector<unsigned char> inputFrame(width * height * 3);
  32.     std::vector<unsigned char> outputFrame(width * height);
  34.     std::random_device rd;
  35.     std::mt19937 gen(rd());
  36.     std::uniform_int_distribution<> dis(0, 255);
  38.     // 开始处理
  39.     auto startTime = std::chrono::high_resolution_clock::now();
  41.     for (int frame = 0; frame < frameCount; ++frame) {
  42.         // 随机生成模拟的 RGB 数据
  43.         for (auto& pixel : inputFrame) {
  44.             pixel = dis(gen);
  45.         }
  47.         // 调用灰度转换函数
  48.         to_gray(inputFrame, outputFrame, width, height);
  50.         // 打印进度
  51.         if (frame % 30 == 0) {
  52.             std::cout << "Processed frame: " << frame + 1 << "/" << frameCount << std::endl;
  53.         }
  54.     }
  56.     auto endTime = std::chrono::high_resolution_clock::now();
  57.     double elapsedTime = std::chrono::duration<double>(endTime - startTime).count();
  59.     // 打印处理时间
  60.     std::cout << "Processed " << frameCount << " frames in " << elapsedTime << " seconds." << std::endl;
  61.     std::cout << "Average time per frame: " << (elapsedTime / frameCount) << " seconds." << std::endl;
  63. }
复制代码
C++多线程

  1. //
  2. // Created by lai on 2025/1/17.
  3. //
  5. #include "TestCppThread.h"
  8. #include <iostream>
  9. #include <vector>
  10. #include <random>
  11. #include <chrono>
  12. #include <thread>
  14. // 灰度转换函数，每个线程处理一部分图像
  15. void to_gray_chunk(const std::vector<unsigned char>& input, std::vector<unsigned char>& output, int width, int height, int start, int end) {
  16.     for (int i = start; i < end; ++i) {
  17.         int offset = i * 3;  // RGB 分量
  18.         unsigned char r = input[offset];
  19.         unsigned char g = input[offset + 1];
  20.         unsigned char b = input[offset + 2];
  21.         // 灰度公式
  22.         output[i] = static_cast<unsigned char>(0.299f * r + 0.587f * g + 0.114f * b);
  23.     }
  24. }
  26. void TestCppThread::runTest() {
  27.     const int width = 1920;         // 视频宽度
  28.     const int height = 1080;        // 视频高度
  29.     const int fps = 30;             // 帧率
  30.     const int duration = 60;        // 视频持续时间（秒）
  31.     const int frameCount = fps * duration; // 总帧数
  32.     const int numThreads = std::thread::hardware_concurrency(); // 获取可用线程数
  34.     // 模拟视频帧数据：随机生成每帧的 RGB 数据
  35.     std::vector<unsigned char> inputFrame(width * height * 3);
  36.     std::vector<unsigned char> outputFrame(width * height);
  38.     std::random_device rd;
  39.     std::mt19937 gen(rd());
  40.     std::uniform_int_distribution<> dis(0, 255);
  42.     // 开始处理
  43.     auto startTime = std::chrono::high_resolution_clock::now();
  45.     for (int frame = 0; frame < frameCount; ++frame) {
  46.         // 随机生成模拟的 RGB 数据
  47.         for (auto& pixel : inputFrame) {
  48.             pixel = dis(gen);
  49.         }
  51.         // 启动多个线程来处理图像
  52.         std::vector<std::thread> threads;
  53.         int chunkSize = width * height / numThreads; // 每个线程处理的像素块大小
  54.         for (int t = 0; t < numThreads; ++t) {
  55.             int start = t * chunkSize;
  56.             int end = (t == numThreads - 1) ? (width * height) : (start + chunkSize); // 最后一个线程处理剩余的像素
  57.             threads.emplace_back(to_gray_chunk, std::cref(inputFrame), std::ref(outputFrame), width, height, start, end);
  58.         }
  60.         // 等待所有线程完成
  61.         for (auto& t : threads) {
  62.             t.join();
  63.         }
  65.         // 打印进度
  66.         if (frame % 30 == 0) {
  67.             std::cout << "Processed frame: " << frame + 1 << "/" << frameCount << std::endl;
  68.         }
  69.     }
  71.     auto endTime = std::chrono::high_resolution_clock::now();
  72.     double elapsedTime = std::chrono::duration<double>(endTime - startTime).count();
  74.     // 打印处理时间
  75.     std::cout << "Processed " << frameCount << " frames in " << elapsedTime << " seconds." << std::endl;
  76.     std::cout << "Average time per frame: " << (elapsedTime / frameCount) << " seconds." << std::endl;
  78. }
复制代码
CPU版本的Opencl

cmake中添加
  1. # 查找OpenCL
  2. find_package(OpenCL REQUIRED)
  4. # 链接OpenCl库
  5. target_include_directories(testOpenGl PRIVATE ${OpenCL_INCLUDE_DIRS})
  6. target_link_libraries(testOpenGl PRIVATE ${OpenCL_LIBRARIES})
复制代码
测试代码
  1. //
  2. // Created by lai on 2025/1/16.
  3. //
  4. #include "testOpenCl.h"
  6. #include <chrono>
  7. #include <CL/cl.h>
  8. #include <iostream>
  9. #include <vector>
  10. #include <random>
  12. // OpenCL 内核代码
  13. const char* kernelSource = R"(
  14. __kernel void to_gray(
  15.     __global unsigned char* input,
  16.     __global unsigned char* output,
  17.     const int width,
  18.     const int height)
  19. {
  20.     int id = get_global_id(0);  // 每个线程处理一个像素
  21.     if (id < width * height) {
  22.         int offset = id * 3;  // RGB 分量
  23.         unsigned char r = input[offset];
  24.         unsigned char g = input[offset + 1];
  25.         unsigned char b = input[offset + 2];
  26.         // 灰度公式
  27.         output[id] = (unsigned char)(0.299f * r + 0.587f * g + 0.114f * b);
  28.     }
  29. }
  30. )";
  31. void TestOpenCl::runTests() {
  32.     const int width = 1920;         // 视频宽度
  33.     const int height = 1080;        // 视频高度
  34.     const int fps = 30;             // 帧率
  35.     const int duration = 60;        // 视频持续时间（秒）
  36.     const int frameCount = fps * duration; // 总帧数
  38.     // 模拟视频帧数据：随机生成每帧的 RGB 数据
  39.     std::vector<unsigned char> inputFrame(width * height * 3);
  40.     std::vector<unsigned char> outputFrame(width * height);
  42.     std::random_device rd;
  43.     std::mt19937 gen(rd());
  44.     std::uniform_int_distribution<> dis(0, 255);
  46.     // 初始化 OpenCL
  47.     cl_int err;
  48.     cl_platform_id platform;
  49.     clGetPlatformIDs(1, &platform, nullptr);
  51.     cl_device_id device;
  52.     clGetDeviceIDs(platform, CL_DEVICE_TYPE_CPU, 1, &device, nullptr);
  54.     cl_context context = clCreateContext(nullptr, 1, &device, nullptr, nullptr, &err);
  55.     cl_command_queue queue = clCreateCommandQueue(context, device, 0, &err);
  57.     cl_program program = clCreateProgramWithSource(context, 1, &kernelSource, nullptr, &err);
  58.     clBuildProgram(program, 1, &device, nullptr, nullptr, nullptr);
  60.     cl_kernel kernel = clCreateKernel(program, "to_gray", &err);
  62.     // 创建 OpenCL 缓冲区
  63.     cl_mem inputBuffer = clCreateBuffer(context, CL_MEM_READ_ONLY, inputFrame.size(), nullptr, &err);
  64.     cl_mem outputBuffer = clCreateBuffer(context, CL_MEM_WRITE_ONLY, outputFrame.size(), nullptr, &err);
  66.     // 开始处理
  67.     auto startTime = std::chrono::high_resolution_clock::now();
  69.     for (int frame = 0; frame < frameCount; ++frame) {
  70.         // 随机生成模拟的 RGB 数据
  71.         for (auto& pixel : inputFrame) {
  72.             pixel = dis(gen);
  73.         }
  75.         // 写入数据到 OpenCL 缓冲区
  76.         clEnqueueWriteBuffer(queue, inputBuffer, CL_TRUE, 0, inputFrame.size(), inputFrame.data(), 0, nullptr, nullptr);
  78.         // 设置内核参数
  79.         clSetKernelArg(kernel, 0, sizeof(cl_mem), &inputBuffer);
  80.         clSetKernelArg(kernel, 1, sizeof(cl_mem), &outputBuffer);
  81.         clSetKernelArg(kernel, 2, sizeof(int), &width);
  82.         clSetKernelArg(kernel, 3, sizeof(int), &height);
  84.         // 定义工作区大小
  85.         size_t globalSize = width * height;
  87.         // 执行内核
  88.         clEnqueueNDRangeKernel(queue, kernel, 1, nullptr, &globalSize, nullptr, 0, nullptr, nullptr);
  90.         // 读取处理后的灰度数据
  91.         clEnqueueReadBuffer(queue, outputBuffer, CL_TRUE, 0, outputFrame.size(), outputFrame.data(), 0, nullptr, nullptr);
  93.         // 打印进度
  94.         if (frame % 30 == 0) {
  95.             std::cout << "Processed frame: " << frame + 1 << "/" << frameCount << std::endl;
  96.         }
  97.     }
  99.     auto endTime = std::chrono::high_resolution_clock::now();
  100.     double elapsedTime = std::chrono::duration<double>(endTime - startTime).count();
  102.     // 打印处理时间
  103.     std::cout << "Processed " << frameCount << " frames in " << elapsedTime << " seconds." << std::endl;
  104.     std::cout << "Average time per frame: " << (elapsedTime / frameCount) << " seconds." << std::endl;
  106.     // 释放 OpenCL 资源
  107.     clReleaseMemObject(inputBuffer);
  108.     clReleaseMemObject(outputBuffer);
  109.     clReleaseKernel(kernel);
  110.     clReleaseProgram(program);
  111.     clReleaseCommandQueue(queue);
  112.     clReleaseContext(context);
  113. }
复制代码
内存对齐的SIMD指令集

cmake添加
  1. # 检测SIMD支持并添加编译选项
  2. include(CheckCXXCompilerFlag)
  4. check_cxx_compiler_flag("-mavx" COMPILER_SUPPORTS_AVX)
  5. check_cxx_compiler_flag("-mavx2" COMPILER_SUPPORTS_AVX2)
  7. if(COMPILER_SUPPORTS_AVX2)
  8.     target_compile_options(testOpenGl PRIVATE -mavx2)
  9. elseif (COMPILER_SUPPORTS_AVX)
  10.     target_compile_options(testOpenGl PRIVATE -mavx)
  11. else ()
  12.     message(FATAL_ERROR "AVX or AVX2 is not supported by compiler")
  13. endif ()
复制代码
  1. //
  2. // Created by lai on 2025/1/17.
  3. //
  5. #include "TestSIMD.h"
  7. #include <iostream>
  8. #include <vector>
  9. #include <random>
  10. #include <chrono>
  11. #include <immintrin.h> // SIMD 指令集
  12. #include <cstdlib>  // 用于posix_memalign
  14. void to_gray_simd(const unsigned char* input, unsigned char* output, int width, int height) {
  15.     const int pixelCount = width * height;
  16.     const __m256 scale_r = _mm256_set1_ps(0.299f); // 红色通道的权重
  17.     const __m256 scale_g = _mm256_set1_ps(0.587f); // 绿色通道的权重
  18.     const __m256 scale_b = _mm256_set1_ps(0.114f); // 蓝色通道的权重
  20.     int i = 0;
  21.     for (; i <= pixelCount - 8; i += 8) {
  22.         // 加载 8 组 RGB 像素
  23.         __m256i pixel_r = _mm256_loadu_si256((__m256i*)&input[i * 3]);  // 确保内存对齐
  24.         __m256i pixel_g = _mm256_loadu_si256((__m256i*)&input[i * 3 + 1]);
  25.         __m256i pixel_b = _mm256_loadu_si256((__m256i*)&input[i * 3 + 2]);
  27.         // 转换为浮点数以便计算
  28.         __m256 r_f = _mm256_cvtepi32_ps(pixel_r);
  29.         __m256 g_f = _mm256_cvtepi32_ps(pixel_g);
  30.         __m256 b_f = _mm256_cvtepi32_ps(pixel_b);
  32.         // 灰度转换公式
  33.         __m256 gray_f = _mm256_add_ps(
  34.             _mm256_add_ps(_mm256_mul_ps(r_f, scale_r), _mm256_mul_ps(g_f, scale_g)),
  35.             _mm256_mul_ps(b_f, scale_b));
  37.         // 转回整数
  38.         __m256i gray_i = _mm256_cvtps_epi32(gray_f);
  40.         // 存储结果
  41.         _mm256_storeu_si256((__m256i*)&output[i], gray_i);
  42.     }
  44.     // 处理剩余像素（非对齐部分）
  45.     for (; i < pixelCount; ++i) {
  46.         int offset = i * 3;
  47.         unsigned char r = input[offset];
  48.         unsigned char g = input[offset + 1];
  49.         unsigned char b = input[offset + 2];
  50.         output[i] = static_cast<unsigned char>(0.299f * r + 0.587f * g + 0.114f * b);
  51.     }
  52. }
  54. void TestSIMD::runTest() {
  55.     const int width = 1920;         // 视频宽度
  56.     const int height = 1080;        // 视频高度
  57.     const int fps = 30;             // 帧率
  58.     const int duration = 60;        // 视频持续时间（秒）
  59.     const int frameCount = fps * duration; // 总帧数
  60.     size_t size = width * height * 3 * sizeof(unsigned char);
  62.     // 模拟视频帧数据：随机生成每帧的 RGB 数据
  63.     // 使用posix_memalign分配对齐内存
  64.     unsigned char* inputFrame;
  65.     unsigned char* outputFrame;
  66.     int alignment = 32; // 使用32字节对齐
  67.     int resultInput = posix_memalign((void**)&inputFrame, alignment, size);
  68.     int resultOutput = posix_memalign((void**)&outputFrame, alignment, size);
  69.     if (resultInput != 0 || resultOutput != 0) {
  70.         std::cerr << "memory allocation failed" << std::endl;
  71.         return;
  72.     }
  75.     std::random_device rd;
  76.     std::mt19937 gen(rd());
  77.     std::uniform_int_distribution<> dis(0, 255);
  79.     // 开始处理
  80.     auto startTime = std::chrono::high_resolution_clock::now();
  82.     for (int frame = 0; frame < frameCount; ++frame) {
  83.         // 随机生成模拟的 RGB 数据
  84.         for (int i = 0; i < width * height * 3; ++i) {
  85.             inputFrame[i] = dis(gen);
  86.         }
  88.         // 使用 SIMD 转换灰度
  89.         to_gray_simd(inputFrame, outputFrame, width, height);
  91.         // 打印进度
  92.         if (frame % 30 == 0) {
  93.             std::cout << "Processed frame: " << frame + 1 << "/" << frameCount << std::endl;
  94.         }
  95.     }
  97.     auto endTime = std::chrono::high_resolution_clock::now();
  98.     double elapsedTime = std::chrono::duration<double>(endTime - startTime).count();
  100.     // 打印处理时间
  101.     std::cout << "Processed " << frameCount << " frames in " << elapsedTime << " seconds." << std::endl;
  102.     std::cout << "Average time per frame: " << (elapsedTime / frameCount) << " seconds." << std::endl;
  103. }
复制代码
结论

  1. C++
  2. Processed 1800 frames in 251.789 seconds.
  3. Average time per frame: 0.139883 seconds.
  5. C++ thread
  6. Processed 1800 frames in 229.571 seconds.
  7. Average time per frame: 0.12754 seconds.
  9. CPU版本POCL的OPENCL
  10. Processed 1800 frames in 233.25 seconds.
  11. Average time per frame: 0.129583 seconds.
  13. SIMD 内存对齐以后
  14. Processed 1800 frames in 191.015 seconds.
  15. Average time per frame: 0.106119 seconds.
复制代码
SIMD的性能明显由于其他几项，但是还需要测试GPU版本的OPencl和多线程指令集优化对性能的提拔

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

美丽的神话

金牌会员
这个人很懒什么都没写!

楼主热帖

标签云

挺好的 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表