Method DecoderPipelineTest

dali/benchmark/decoder_bench.cc:26–85

class DecoderBench : public DALIBenchmark {
 public:
  void DecoderPipelineTest(benchmark::State& st,
                           int batch_size,
                           int num_thread,
                           std::string output_device,
                           const OpSpec &decoder_operator,
                           std::function<void(Pipeline&)> add_other_inputs = {}) {
    DALIImageType img_type = DALI_RGB;

    // Create the pipeline
    Pipeline pipe(
        batch_size,
        num_thread,
        0, -1,
        true,   // pipelined
        2,      // pipe length
        true);  // async

    TensorList<CPUBackend> data;
    this->MakeJPEGBatch(&data, batch_size);
    pipe.AddExternalInput("raw_jpegs");

    if (add_other_inputs)
      add_other_inputs(pipe);

    pipe.AddOperator(decoder_operator);

    // Build and run the pipeline
    vector<std::pair<string, string>> outputs = {{"images", output_device}};
    pipe.Build(outputs);

    // Run once to allocate the memory
    Workspace ws;
    pipe.SetExternalInput("raw_jpegs", data);
    pipe.Run();
    pipe.Outputs(&ws);

    while (st.KeepRunning()) {
      if (st.iterations() == 1) {
        // We will start the processing for the next batch
        // immediately after issueing work to the gpu to
        // pipeline the cpu/copy/gpu work
        pipe.SetExternalInput("raw_jpegs", data);
        pipe.Run();
      }

      pipe.SetExternalInput("raw_jpegs", data);
      pipe.Run();
      pipe.Outputs(&ws);

      if (st.iterations() == st.max_iterations) {
        // Block for the last batch to finish
        pipe.Outputs(&ws);
      }
    }

    // WriteCHWBatch<float16>(ws.Output<GPUBackend>(0), 128, 1, "img");
    int num_batches = st.iterations() + 1;
    st.counters["FPS"] = benchmark::Counter(batch_size*num_batches,