test/fence.cpp - chromiumos/third_party/libcamera - Git at Google

 /* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  * Copyright (C) 2021, Google Inc.
  *
  * fence.cpp - Fence test
  */

 #include <iostream>
 #include <memory>
 #include <sys/eventfd.h>
 #include <unistd.h>

 #include <libcamera/base/event_dispatcher.h>
 #include <libcamera/base/thread.h>
 #include <libcamera/base/timer.h>
 #include <libcamera/base/unique_fd.h>
 #include <libcamera/base/utils.h>

 #include <libcamera/fence.h>
 #include <libcamera/framebuffer_allocator.h>

 #include "camera_test.h"
 #include "test.h"

 using namespace std::chrono_literals;
 using namespace libcamera;
 using namespace std;

 class FenceTest : public CameraTest, public Test
 {
 public:
 	FenceTest();

 protected:
 	int init() override;
 	int run() override;

 private:
 	int validateExpiredRequest(Request *request);
 	int validateRequest(Request *request);
 	void requestComplete(Request *request);
 	void requestRequeue(Request *request);

 	void signalFence();

 	std::unique_ptr<Fence> fence_;
 	EventDispatcher *dispatcher_;
 	UniqueFD eventFd_;
 	UniqueFD eventFd2_;
 	Timer fenceTimer_;

 	std::vector<std::unique_ptr<Request>> requests_;
 	std::unique_ptr<CameraConfiguration> config_;
 	std::unique_ptr<FrameBufferAllocator> allocator_;

 	Stream *stream_;

 	bool expectedCompletionResult_ = true;
 	bool setFence_ = true;

 	unsigned int completedRequest_;

 	unsigned int signalledRequestId_;
 	unsigned int expiredRequestId_;
 	unsigned int nbuffers_;

 	int efd2_;
 	int efd_;
 };

 FenceTest::FenceTest()
 	: CameraTest("platform/vimc.0 Sensor B")
 {
 }

 int FenceTest::init()
 {
 	/* Make sure the CameraTest constructor succeeded. */
 	if (status_ != TestPass)
 		return status_;

 	dispatcher_ = Thread::current()->eventDispatcher();

 	/*
 	 * Create two eventfds to model the fences. This is enough to support the
 	 * needs of libcamera which only needs to wait for read events through
 	 * poll(). Once native support for fences will be available in the
 	 * backend kernel APIs this will need to be replaced by a sw_sync fence,
 	 * but that requires debugfs.
 	 */
 	eventFd_ = UniqueFD(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
 	eventFd2_ = UniqueFD(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK));
 	if (!eventFd_.isValid() || !eventFd2_.isValid()) {
 		cerr << "Unable to create eventfd" << endl;
 		return TestFail;
 	}

 	efd_ = eventFd_.get();
 	efd2_ = eventFd2_.get();

 	config_ = camera_->generateConfiguration({ StreamRole::Viewfinder });
 	if (!config_ || config_->size() != 1) {
 		cerr << "Failed to generate default configuration" << endl;
 		return TestFail;
 	}

 	if (camera_->acquire()) {
 		cerr << "Failed to acquire the camera" << endl;
 		return TestFail;
 	}

 	if (camera_->configure(config_.get())) {
 		cerr << "Failed to set default configuration" << endl;
 		return TestFail;
 	}

 	StreamConfiguration &cfg = config_->at(0);
 	stream_ = cfg.stream();

 	allocator_ = std::make_unique<FrameBufferAllocator>(camera_);
 	if (allocator_->allocate(stream_) < 0)
 		return TestFail;

 	nbuffers_ = allocator_->buffers(stream_).size();
 	if (nbuffers_ < 2) {
 		cerr << "Not enough buffers available" << endl;
 		return TestFail;
 	}

 	signalledRequestId_ = nbuffers_ - 2;
 	expiredRequestId_ = nbuffers_ - 1;

 	return TestPass;
 }

 int FenceTest::validateExpiredRequest(Request *request)
 {
 	/* The last request is expected to fail. */
 	if (request->status() != Request::RequestCancelled) {
 		cerr << "The last request should have failed: " << endl;
 		return TestFail;
 	}

 	FrameBuffer *buffer = request->buffers().begin()->second;
 	std::unique_ptr<Fence> fence = buffer->releaseFence();
 	if (!fence) {
 		cerr << "The expired fence should be present" << endl;
 		return TestFail;
 	}

 	if (!fence->isValid()) {
 		cerr << "The expired fence should be valid" << endl;
 		return TestFail;
 	}

 	UniqueFD fd = fence->release();
 	if (fd.get() != efd_) {
 		cerr << "The expired fence file descriptor should not change" << endl;
 		return TestFail;
 	}

 	return TestPass;
 }

 int FenceTest::validateRequest(Request *request)
 {
 	uint64_t cookie = request->cookie();

 	/* All requests but the last are expected to succeed. */
 	if (request->status() != Request::RequestComplete) {
 		cerr << "Unexpected request failure: " << cookie << endl;
 		return TestFail;
 	}

 	/* A successfully completed request should have the Fence closed. */
 	const Request::BufferMap &buffers = request->buffers();
 	FrameBuffer *buffer = buffers.begin()->second;

 	std::unique_ptr<Fence> bufferFence = buffer->releaseFence();
 	if (bufferFence) {
 		cerr << "Unexpected valid fence in completed request" << endl;
 		return TestFail;
 	}

 	return TestPass;
 }

 void FenceTest::requestRequeue(Request *request)
 {
 	const Request::BufferMap &buffers = request->buffers();
 	const Stream *stream = buffers.begin()->first;
 	FrameBuffer *buffer = buffers.begin()->second;
 	uint64_t cookie = request->cookie();

 	request->reuse();

 	if (cookie == signalledRequestId_ && setFence_) {
 		/*
 		 * The second time this request is queued add a fence to it.
 		 *
 		 * The main loop signals it by using a timer to write to the
 		 * efd2_ file descriptor before the fence expires.
 		 */
 		std::unique_ptr<Fence> fence =
 			std::make_unique<Fence>(std::move(eventFd2_));
 		request->addBuffer(stream, buffer, std::move(fence));
 	} else {
 		/* All the other requests continue to operate without fences. */
 		request->addBuffer(stream, buffer);
 	}

 	camera_->queueRequest(request);
 }

 void FenceTest::requestComplete(Request *request)
 {
 	uint64_t cookie = request->cookie();
 	completedRequest_ = cookie;

 	/*
 	 * The last request is expected to fail as its fence has not been
 	 * signaled.
 	 *
 	 * Validate the fence status but do not re-queue it.
 	 */
 	if (cookie == expiredRequestId_) {
 		if (validateExpiredRequest(request) != TestPass)
 			expectedCompletionResult_ = false;

 		dispatcher_->interrupt();
 		return;
 	}

 	/* Validate all requests but the last. */
 	if (validateRequest(request) != TestPass) {
 		expectedCompletionResult_ = false;

 		dispatcher_->interrupt();
 		return;
 	}

 	requestRequeue(request);

 	/*
 	 * Interrupt the dispatcher to return control to the main loop and
 	 * activate the fenceTimer.
 	 */
 	dispatcher_->interrupt();
 }

 /* Callback to signal a fence waiting on the eventfd file descriptor. */
 void FenceTest::signalFence()
 {
 	uint64_t value = 1;
 	int ret;

 	ret = write(efd2_, &value, sizeof(value));
 	if (ret != sizeof(value))
 		cerr << "Failed to signal fence" << endl;

 	setFence_ = false;
 	dispatcher_->processEvents();
 }

 int FenceTest::run()
 {
 	for (const auto &[i, buffer] : utils::enumerate(allocator_->buffers(stream_))) {
 		std::unique_ptr<Request> request = camera_->createRequest(i);
 		if (!request) {
 			cerr << "Failed to create request" << endl;
 			return TestFail;
 		}

 		int ret;
 		if (i == expiredRequestId_) {
 			/* This request will have a fence, and it will expire. */
 			fence_ = std::make_unique<Fence>(std::move(eventFd_));
 			if (!fence_->isValid()) {
 				cerr << "Fence should be valid" << endl;
 				return TestFail;
 			}

 			ret = request->addBuffer(stream_, buffer.get(), std::move(fence_));
 		} else {
 			/* All other requests will have no Fence. */
 			ret = request->addBuffer(stream_, buffer.get());
 		}

 		if (ret) {
 			cerr << "Failed to associate buffer with request" << endl;
 			return TestFail;
 		}

 		requests_.push_back(std::move(request));
 	}

 	camera_->requestCompleted.connect(this, &FenceTest::requestComplete);

 	if (camera_->start()) {
 		cerr << "Failed to start camera" << endl;
 		return TestFail;
 	}

 	for (std::unique_ptr<Request> &request : requests_) {
 		if (camera_->queueRequest(request.get())) {
 			cerr << "Failed to queue request" << endl;
 			return TestFail;
 		}
 	}

 	expectedCompletionResult_ = true;

 	/* This timer serves to signal fences associated with "signalledRequestId_" */
 	Timer fenceTimer;
 	fenceTimer.timeout.connect(this, &FenceTest::signalFence);

 	/* Loop for one second. */
 	Timer timer;
 	timer.start(1000);
 	while (timer.isRunning() && expectedCompletionResult_) {
 		if (completedRequest_ == signalledRequestId_ && setFence_)
 			/*
 			 * signalledRequestId_ has just completed and it has
 			 * been re-queued with a fence. Start the timer to
 			 * signal the fence in 10 msec.
 			 */
 			fenceTimer.start(10);

 		dispatcher_->processEvents();
 	}

 	camera_->requestCompleted.disconnect();

 	if (camera_->stop()) {
 		cerr << "Failed to stop camera" << endl;
 		return TestFail;
 	}

 	return expectedCompletionResult_ ? TestPass : TestFail;
 }

 TEST_REGISTER(FenceTest)
	/* SPDX-License-Identifier: GPL-2.0-or-later */
	/*
	* Copyright (C) 2021, Google Inc.
	*
	* fence.cpp - Fence test
	*/

	#include <iostream>
	#include <memory>
	#include <sys/eventfd.h>
	#include <unistd.h>

	#include <libcamera/base/event_dispatcher.h>
	#include <libcamera/base/thread.h>
	#include <libcamera/base/timer.h>
	#include <libcamera/base/unique_fd.h>
	#include <libcamera/base/utils.h>

	#include <libcamera/fence.h>
	#include <libcamera/framebuffer_allocator.h>

	#include "camera_test.h"
	#include "test.h"

	using namespace std::chrono_literals;
	using namespace libcamera;
	using namespace std;

	class FenceTest : public CameraTest, public Test
	{
	public:
	FenceTest();

	protected:
	int init() override;
	int run() override;

	private:
	int validateExpiredRequest(Request *request);
	int validateRequest(Request *request);
	void requestComplete(Request *request);
	void requestRequeue(Request *request);

	void signalFence();

	std::unique_ptr<Fence> fence_;
	EventDispatcher *dispatcher_;
	UniqueFD eventFd_;
	UniqueFD eventFd2_;
	Timer fenceTimer_;

	std::vector<std::unique_ptr<Request>> requests_;
	std::unique_ptr<CameraConfiguration> config_;
	std::unique_ptr<FrameBufferAllocator> allocator_;

	Stream *stream_;

	bool expectedCompletionResult_ = true;
	bool setFence_ = true;

	unsigned int completedRequest_;

	unsigned int signalledRequestId_;
	unsigned int expiredRequestId_;
	unsigned int nbuffers_;

	int efd2_;
	int efd_;
	};

	FenceTest::FenceTest()
	: CameraTest("platform/vimc.0 Sensor B")
	{
	}

	int FenceTest::init()
	{
	/* Make sure the CameraTest constructor succeeded. */
	if (status_ != TestPass)
	return status_;

	dispatcher_ = Thread::current()->eventDispatcher();

	/*
	* Create two eventfds to model the fences. This is enough to support the
	* needs of libcamera which only needs to wait for read events through
	* poll(). Once native support for fences will be available in the
	* backend kernel APIs this will need to be replaced by a sw_sync fence,
	* but that requires debugfs.
	*/
	eventFd_ = UniqueFD(eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK));
	eventFd2_ = UniqueFD(eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK));
	if (!eventFd_.isValid() \|\| !eventFd2_.isValid()) {
	cerr << "Unable to create eventfd" << endl;
	return TestFail;
	}

	efd_ = eventFd_.get();
	efd2_ = eventFd2_.get();

	config_ = camera_->generateConfiguration({ StreamRole::Viewfinder });
	if (!config_ \|\| config_->size() != 1) {
	cerr << "Failed to generate default configuration" << endl;
	return TestFail;
	}

	if (camera_->acquire()) {
	cerr << "Failed to acquire the camera" << endl;
	return TestFail;
	}

	if (camera_->configure(config_.get())) {
	cerr << "Failed to set default configuration" << endl;
	return TestFail;
	}

	StreamConfiguration &cfg = config_->at(0);
	stream_ = cfg.stream();

	allocator_ = std::make_unique<FrameBufferAllocator>(camera_);
	if (allocator_->allocate(stream_) < 0)
	return TestFail;

	nbuffers_ = allocator_->buffers(stream_).size();
	if (nbuffers_ < 2) {
	cerr << "Not enough buffers available" << endl;
	return TestFail;
	}

	signalledRequestId_ = nbuffers_ - 2;
	expiredRequestId_ = nbuffers_ - 1;

	return TestPass;
	}

	int FenceTest::validateExpiredRequest(Request *request)
	{
	/* The last request is expected to fail. */
	if (request->status() != Request::RequestCancelled) {
	cerr << "The last request should have failed: " << endl;
	return TestFail;
	}

	FrameBuffer *buffer = request->buffers().begin()->second;
	std::unique_ptr<Fence> fence = buffer->releaseFence();
	if (!fence) {
	cerr << "The expired fence should be present" << endl;
	return TestFail;
	}

	if (!fence->isValid()) {
	cerr << "The expired fence should be valid" << endl;
	return TestFail;
	}

	UniqueFD fd = fence->release();
	if (fd.get() != efd_) {
	cerr << "The expired fence file descriptor should not change" << endl;
	return TestFail;
	}

	return TestPass;
	}

	int FenceTest::validateRequest(Request *request)
	{
	uint64_t cookie = request->cookie();

	/* All requests but the last are expected to succeed. */
	if (request->status() != Request::RequestComplete) {
	cerr << "Unexpected request failure: " << cookie << endl;
	return TestFail;
	}

	/* A successfully completed request should have the Fence closed. */
	const Request::BufferMap &buffers = request->buffers();
	FrameBuffer *buffer = buffers.begin()->second;

	std::unique_ptr<Fence> bufferFence = buffer->releaseFence();
	if (bufferFence) {
	cerr << "Unexpected valid fence in completed request" << endl;
	return TestFail;
	}

	return TestPass;
	}

	void FenceTest::requestRequeue(Request *request)
	{
	const Request::BufferMap &buffers = request->buffers();
	const Stream *stream = buffers.begin()->first;
	FrameBuffer *buffer = buffers.begin()->second;
	uint64_t cookie = request->cookie();

	request->reuse();

	if (cookie == signalledRequestId_ && setFence_) {
	/*
	* The second time this request is queued add a fence to it.
	*
	* The main loop signals it by using a timer to write to the
	* efd2_ file descriptor before the fence expires.
	*/
	std::unique_ptr<Fence> fence =
	std::make_unique<Fence>(std::move(eventFd2_));
	request->addBuffer(stream, buffer, std::move(fence));
	} else {
	/* All the other requests continue to operate without fences. */
	request->addBuffer(stream, buffer);
	}

	camera_->queueRequest(request);
	}

	void FenceTest::requestComplete(Request *request)
	{
	uint64_t cookie = request->cookie();
	completedRequest_ = cookie;

	/*
	* The last request is expected to fail as its fence has not been
	* signaled.
	*
	* Validate the fence status but do not re-queue it.
	*/
	if (cookie == expiredRequestId_) {
	if (validateExpiredRequest(request) != TestPass)
	expectedCompletionResult_ = false;

	dispatcher_->interrupt();
	return;
	}

	/* Validate all requests but the last. */
	if (validateRequest(request) != TestPass) {
	expectedCompletionResult_ = false;

	dispatcher_->interrupt();
	return;
	}

	requestRequeue(request);

	/*
	* Interrupt the dispatcher to return control to the main loop and
	* activate the fenceTimer.
	*/
	dispatcher_->interrupt();
	}

	/* Callback to signal a fence waiting on the eventfd file descriptor. */
	void FenceTest::signalFence()
	{
	uint64_t value = 1;
	int ret;

	ret = write(efd2_, &value, sizeof(value));
	if (ret != sizeof(value))
	cerr << "Failed to signal fence" << endl;

	setFence_ = false;
	dispatcher_->processEvents();
	}

	int FenceTest::run()
	{
	for (const auto &[i, buffer] : utils::enumerate(allocator_->buffers(stream_))) {
	std::unique_ptr<Request> request = camera_->createRequest(i);
	if (!request) {
	cerr << "Failed to create request" << endl;
	return TestFail;
	}

	int ret;
	if (i == expiredRequestId_) {
	/* This request will have a fence, and it will expire. */
	fence_ = std::make_unique<Fence>(std::move(eventFd_));
	if (!fence_->isValid()) {
	cerr << "Fence should be valid" << endl;
	return TestFail;
	}

	ret = request->addBuffer(stream_, buffer.get(), std::move(fence_));
	} else {
	/* All other requests will have no Fence. */
	ret = request->addBuffer(stream_, buffer.get());
	}

	if (ret) {
	cerr << "Failed to associate buffer with request" << endl;
	return TestFail;
	}

	requests_.push_back(std::move(request));
	}

	camera_->requestCompleted.connect(this, &FenceTest::requestComplete);

	if (camera_->start()) {
	cerr << "Failed to start camera" << endl;
	return TestFail;
	}

	for (std::unique_ptr<Request> &request : requests_) {
	if (camera_->queueRequest(request.get())) {
	cerr << "Failed to queue request" << endl;
	return TestFail;
	}
	}

	expectedCompletionResult_ = true;

	/* This timer serves to signal fences associated with "signalledRequestId_" */
	Timer fenceTimer;
	fenceTimer.timeout.connect(this, &FenceTest::signalFence);

	/* Loop for one second. */
	Timer timer;
	timer.start(1000);
	while (timer.isRunning() && expectedCompletionResult_) {
	if (completedRequest_ == signalledRequestId_ && setFence_)
	/*
	* signalledRequestId_ has just completed and it has
	* been re-queued with a fence. Start the timer to
	* signal the fence in 10 msec.
	*/
	fenceTimer.start(10);

	dispatcher_->processEvents();
	}

	camera_->requestCompleted.disconnect();

	if (camera_->stop()) {
	cerr << "Failed to stop camera" << endl;
	return TestFail;
	}

	return expectedCompletionResult_ ? TestPass : TestFail;
	}

	TEST_REGISTER(FenceTest)