Benchmarking my OnNewBuffer

[sgayda2]

I am attempting to benchmark my callback, this is done using google benchmark library that looks something like this:

void BM_OnNewBufferCallback(benchmark::State& state) {
  const int kWidth = state.range(0);
  const int kHeight = state.range(1);

  GError* error = nullptr;

  const std::string device_id = ...

  ArvDevice* device = arv_fake_device_new(device_id.c_str(), &error);
  ArvFakeCamera* fake_camera = arv_fake_device_get_fake_camera(
      reinterpret_cast<ArvFakeDevice*>(device));

  // Set the camera resolution.
  ASSERT_TRUE(arv_fake_camera_write_register(fake_camera, 0x100, kWidth));
  ASSERT_TRUE(arv_fake_camera_write_register(fake_camera, 0x104, kHeight));

  // Set the camera pixel format to RGB_8_PACKED.
  ASSERT_TRUE(arv_fake_camera_write_register(
      fake_camera, 0x128, ARV_PIXEL_FORMAT_RGB_8_PACKED));

  auto fill_pattern_callback = [](ArvBuffer*, void*, guint32, guint32,
                                  guint32) {
    // Nothing to do here as the buffer is already filled with valid data.
    // We still need this callback since the alternative is a default callback
    // that fills the buffer with gradient data that we don't want for our test.
  };
  arv_fake_camera_set_fill_pattern(fake_camera, fill_pattern_callback,
                                        nullptr, nullptr);

  ArvStream* stream =
      arv_device_create_stream(device, nullptr, nullptr, nullptr, &error);

  const int payload_size = arv_fake_camera_get_payload(fake_camera);

  void* image_data = ...
  void* callback_data = ...

  for (auto _ : state) {
    ArvBuffer* buffer = arv_buffer_new(payload_size, image_data);
    arv_fake_camera_fill_buffer(fake_camera, buffer, nullptr);
    arv_stream_push_output_buffer(stream, buffer);

    OnNewBufferCallback(stream, callback_data);
  }
}

I have intentionally omitted all the error handling for ease of readability. I have two main concerns, one is that the only way i was able to get this to work was by using arv_stream_push_output_buffer which is a private function. The second concern, which i did not have enough time to explore was an alternative to using an empty fill pattern callback.

I am unable to use the fake thread streaming that is currently available because the benchmark library controls the looping and i would like to avoid extra threads if possible, so i need to feed the callback the new buffer directly and allow the for loop to handle repeated runs of the code.

My feature request is for assistance on how to make this work with the public APIs or alternatively to make the extra method part of the public APIs. I have discussed this with Marco Feuerstein and he suggested reaching out and starting a discussion to figure out next steps.

[feuerste]

@EmmanuelP ,
@sgayda2 is a colleague of mine who also started to use aravis. Do you see a way to move arv_stream_push_output_buffer to the public interface (we could open a PR for this) or even a better solution to Stoyan's problem described above?
Thanks a lot for your thoughts and help!

[EmmanuelP]

Hi,

I am not sure to understand what you are trying to achieve. What do you mean by “to benchmark my callback” ? Is it a benchmark of the execution time of a callback for a new-buffer signal, i.e. OnNewBufferCallback ? If you are worried by the time taken by arv_stream_[try_pop, push]_buffer, they are simple call to g_async_queue[try_pop,push]. They should be pretty instant compared to any data processing time in your callback.

[EmmanuelP]

aravis/src/arvstream.c

Lines 98 to 107 in 28e0cb1

	void
	arv_stream_push_buffer (ArvStream *stream, ArvBuffer *buffer)
	{
	ArvStreamPrivate *priv = arv_stream_get_instance_private (stream);
	g_return_if_fail (ARV_IS_STREAM (stream));
	g_return_if_fail (ARV_IS_BUFFER (buffer));
	g_async_queue_push (priv->input_queue, buffer);
	}

aravis/src/arvstream.c

Lines 149 to 157 in 28e0cb1

	ArvBuffer *
	arv_stream_try_pop_buffer (ArvStream *stream)
	{
	ArvStreamPrivate *priv = arv_stream_get_instance_private (stream);
	g_return_val_if_fail (ARV_IS_STREAM (stream), NULL);
	return g_async_queue_try_pop (priv->output_queue);
	}

[sgayda2]

To further explain, I am trying to benchmark my own code, the callback code, i am not too worried about the code run by aravis. I want to make my callback as fast as possible and so I run it and see how long it takes, make optimizations and see if that improves the time.

To that end, i need to effectively run my code under more controlled conditions, which means calling my code with a fake stream and synthetic data on demand. To achieve this, i was using arv_stream_push_output_buffer to add a buffer to the stream that is being used by the callback as a means to inject my synthetic data into the stream and therefore into the callback. This method however is not publicly available, and I don't want to rely on it. As for using arv_stream_push_buffer that adds the buffer to the input queue which is used as free buffers when new data comes in and will not do what I need.

The sample code i provided above is the controlled conditions:

    ArvBuffer* buffer = arv_buffer_new(payload_size, image_data);
    arv_fake_camera_fill_buffer(fake_camera, buffer, nullptr);
    arv_stream_push_output_buffer(stream, buffer);

    OnNewBufferCallback(stream, callback_data);

As you can see I create a buffer, fill it with image_data and then pass it along to the output buffer of the stream. Then when I call my callback code OnNewBufferCallback it will pull the buffer from the stream, process it, and i will record the time it takes for that processing. In order for my callback to work as expected I need to be able to inject the synthetic data into the stream. I don't know what the best way to do that is, aside from using the private arv_stream_push_output_buffer method.

If you have a better alternative to inject the synthetic data/buffer into the stream, that would be great!

[EmmanuelP]

I would be more willing to accept a patch that add setters to ArvBuffer that would allow implementing arv_fake_camera_fill_buffer by yourself. Then you just have to call a modified version of OnNewBuffer that takes a buffer as one of its parameter.