为什么测试解码提升很小？而且与官方demo 使用的api不一样

[hacktmz]

环境 20核cpu cuda 10.2 T4 单卡

def get_image(image_url): if not image_url: return None try: image_url = parse.unquote(image_url) response = requests.get(image_url) if response.status_code != 200: print("get image filed!!!!!!") return " " return response.content except Exception as e: print(e) raise

def test_load_img(image, count): start = cv2.getTickCount() for num in range(0, count): np_image = np.frombuffer(bytearray(image), np.uint8) cv_image = cv2.imdecode(np_image, cv2.IMREAD_COLOR) end1 = cv2.getTickCount() print("load img1 base line = %s" % ((end1 - start) / cv2.getTickFrequency())) return cv_image

def test_load_img_nvjpeg(image, count): from nvjpeg import NvJpeg nj = NvJpeg() start = cv2.getTickCount() for num in range(0, count): np_image = np.asarray(bytearray(image), dtype="uint8") # cv_image = cv2.imdecode(np_image, cv2.IMREAD_COLOR) cv_image = nj.decode(np_image) end1 = cv2.getTickCount() print("load img nvjpeg base line = %s" % ((end1 - start) / cv2.getTickFrequency())) return cv_image

if name == "main": image = get_image("http://cdn.weipaitang.com/img/20200313rli2rh7p-jdgj-7vyi-91qd-584099256046-W3024H4032") if image != "": count = 100 test_load_img_nvjpeg(image, count) cv_image = test_load_img(image, count)

结果为： opencv 14秒 pynvjpeg 12.6秒 （确定观察到GPU的使用率，没有任何报错）

[hacktmz]

然后官方的解码demo 是这样写的，里面的api为什么跟pynvjpeg完全不一样

int decode_images(const FileData &img_data, const std::vector<size_t> &img_len, std::vector<nvjpegImage_t> &out, decode_params_t &params, double &time) { CHECK_CUDA(cudaStreamSynchronize(params.stream)); cudaEvent_t startEvent = NULL, stopEvent = NULL; float loopTime = 0;

CHECK_CUDA(cudaEventCreate(&startEvent, cudaEventBlockingSync)); CHECK_CUDA(cudaEventCreate(&stopEvent, cudaEventBlockingSync));

std::vector<const unsigned char*> batched_bitstreams; std::vector<size_t> batched_bitstreams_size; std::vector<nvjpegImage_t> batched_output;

// bit-streams that batched decode cannot handle std::vector<const unsigned char*> otherdecode_bitstreams; std::vector<size_t> otherdecode_bitstreams_size; std::vector<nvjpegImage_t> otherdecode_output;

// if(params.hw_decode_available){ // for(int i = 0; i < params.batch_size; i++){ // // extract bitstream meta data to figure out whether a bit-stream can be decoded // nvjpegJpegStreamParseHeader(params.nvjpeg_handle, (const unsigned char *)img_data[i].data(), img_len[i], params.jpeg_streams[0]); // int isSupported = -1; // nvjpegDecodeBatchedSupported(params.nvjpeg_handle, params.jpeg_streams[0], &isSupported);

// if(isSupported == 0){ // batched_bitstreams.push_back((const unsigned char *)img_data[i].data()); // batched_bitstreams_size.push_back(img_len[i]); // batched_output.push_back(out[i]); // } else { // otherdecode_bitstreams.push_back((const unsigned char *)img_data[i].data()); // otherdecode_bitstreams_size.push_back(img_len[i]); // otherdecode_output.push_back(out[i]); // } // } // } else { for(int i = 0; i < params.batch_size; i++) { otherdecode_bitstreams.push_back((const unsigned char *)img_data[i].data()); otherdecode_bitstreams_size.push_back(img_len[i]); otherdecode_output.push_back(out[i]); } // }

CHECK_CUDA(cudaEventRecord(startEvent, params.stream));

if(batched_bitstreams.size() > 0)
 {
      CHECK_NVJPEG(
           nvjpegDecodeBatchedInitialize(params.nvjpeg_handle, params.nvjpeg_state,
                                        batched_bitstreams.size(), 1, params.fmt));

     CHECK_NVJPEG(nvjpegDecodeBatched(
         params.nvjpeg_handle, params.nvjpeg_state, batched_bitstreams.data(),
         batched_bitstreams_size.data(), batched_output.data(), params.stream));
 }

if(otherdecode_bitstreams.size() > 0)
{
      CHECK_NVJPEG(nvjpegStateAttachDeviceBuffer(params.nvjpeg_decoupled_state, params.device_buffer));
      int buffer_index = 0;
      CHECK_NVJPEG(nvjpegDecodeParamsSetOutputFormat(params.nvjpeg_decode_params, params.fmt));
      for (int i = 0; i < params.batch_size; i++) {
          CHECK_NVJPEG(
              nvjpegJpegStreamParse(params.nvjpeg_handle, otherdecode_bitstreams[i], otherdecode_bitstreams_size[i],
              0, 0, params.jpeg_streams[buffer_index]));

          CHECK_NVJPEG(nvjpegStateAttachPinnedBuffer(params.nvjpeg_decoupled_state,
              params.pinned_buffers[buffer_index]));

          CHECK_NVJPEG(nvjpegDecodeJpegHost(params.nvjpeg_handle, params.nvjpeg_decoder, params.nvjpeg_decoupled_state,
              params.nvjpeg_decode_params, params.jpeg_streams[buffer_index]));

          CHECK_CUDA(cudaStreamSynchronize(params.stream));

          CHECK_NVJPEG(nvjpegDecodeJpegTransferToDevice(params.nvjpeg_handle, params.nvjpeg_decoder, params.nvjpeg_decoupled_state,
              params.jpeg_streams[buffer_index], params.stream));

          buffer_index = 1 - buffer_index; // switch pinned buffer in pipeline mode to avoid an extra sync

          CHECK_NVJPEG(nvjpegDecodeJpegDevice(params.nvjpeg_handle, params.nvjpeg_decoder, params.nvjpeg_decoupled_state,
              &otherdecode_output[i], params.stream));

      }
}

CHECK_CUDA(cudaEventRecord(stopEvent, params.stream));

CHECK_CUDA(cudaEventSynchronize(stopEvent)); CHECK_CUDA(cudaEventElapsedTime(&loopTime, startEvent, stopEvent)); time = static_cast(loopTime);

return EXIT_SUCCESS; }

[zeng-qinghui]

• 中文原文

1. 为什么测试解码提升很小？

   GPU硬解码在编解码速度上是比CPU快的，但是处理过程中多了 host to device 和 device to host 内存复制时间。所以在处理小图片的速度不理想。由于GPU核心数远远多于CPU核心数，所以使用多线程也有利于获得更好的结果。

2. 与官方demo 使用的api不一样

   pynvjpeg旨在使用nvjpeg的编解码功能，实现兼容opencv的接口。

• English Translation

1. Why the decoding time is similar?

   GPU hard decoding is faster than CPU in encoding and decoding process, but there is a process names host to device or device to host memory copying spends time. For the reason, the decoding/encoding time is similar, especially decoding/encoding small pictures . Using multi-threading, The GPU should got the more better score than CPU.

2. The API is different from the official demo

   PyNvjpeg is designed to be compatible with OpenCV.