From patchwork Tue Nov 30 23:36:29 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jacopo Mondi X-Patchwork-Id: 14920 Return-Path: X-Original-To: parsemail@patchwork.libcamera.org Delivered-To: parsemail@patchwork.libcamera.org Received: from lancelot.ideasonboard.com (lancelot.ideasonboard.com [92.243.16.209]) by patchwork.libcamera.org (Postfix) with ESMTPS id 1F52BBDB13 for ; Tue, 30 Nov 2021 23:35:56 +0000 (UTC) Received: from lancelot.ideasonboard.com (localhost [IPv6:::1]) by lancelot.ideasonboard.com (Postfix) with ESMTP id CEE9260738; Wed, 1 Dec 2021 00:35:55 +0100 (CET) Received: from relay8-d.mail.gandi.net (relay8-d.mail.gandi.net [217.70.183.201]) by lancelot.ideasonboard.com (Postfix) with ESMTPS id 646FD60727 for ; Wed, 1 Dec 2021 00:35:54 +0100 (CET) Received: (Authenticated sender: jacopo@jmondi.org) by relay8-d.mail.gandi.net (Postfix) with ESMTPSA id 6D6521BF206; Tue, 30 Nov 2021 23:35:53 +0000 (UTC) From: Jacopo Mondi To: libcamera-devel@lists.libcamera.org Date: Wed, 1 Dec 2021 00:36:29 +0100 Message-Id: <20211130233634.34173-7-jacopo@jmondi.org> X-Mailer: git-send-email 2.33.1 In-Reply-To: <20211130233634.34173-1-jacopo@jmondi.org> References: <20211130233634.34173-1-jacopo@jmondi.org> MIME-Version: 1.0 Subject: [libcamera-devel] [PATCH v3 06/11] test: fence: Add test for the Fence class X-BeenThere: libcamera-devel@lists.libcamera.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: libcamera-devel-bounces@lists.libcamera.org Sender: "libcamera-devel" Add a test for the Fence class by testing a Fence failure case, and by testing a successfully signalled fence capture cycle. Signed-off-by: Jacopo Mondi --- test/fence.cpp | 343 +++++++++++++++++++++++++++++++++++++++++++++++ test/meson.build | 1 + 2 files changed, 344 insertions(+) create mode 100644 test/fence.cpp diff --git a/test/fence.cpp b/test/fence.cpp new file mode 100644 index 000000000000..ee909a46b3ea --- /dev/null +++ b/test/fence.cpp @@ -0,0 +1,343 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2021, Google Inc. + * + * fence.cpp - Fence test + */ + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +#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; + void cleanup() override; + +private: + int validateExpiredRequest(Request *request); + void requestComplete(Request *request); + void signalFence(); + + std::unique_ptr fence_; + EventDispatcher *dispatcher_; + UniqueFD eventFd_; + Timer fenceTimer_; + + std::vector> requests_; + std::unique_ptr config_; + FrameBufferAllocator *allocator_; + + Stream *stream_; + + bool expectedCompletionResult_ = true; + bool expectFenceFailure_ = 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() +{ + dispatcher_ = Thread::current()->eventDispatcher(); + + eventFd_ = UniqueFD(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK)); + if (!eventFd_.isValid()) { + cerr << "Unable to create eventfd" << endl; + return TestFail; + } + + /* + * Keep a copy of the original fd value to validate that an expired + * fence has the same fd value. + */ + efd_ = eventFd_.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_ = new 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) +{ + FrameBuffer *buffer = request->buffers().begin()->second; + + std::unique_ptr fence = buffer->resetFence(); + 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 uniqueFd = fence->reset(); + int fd = uniqueFd.release(); + if (fd != efd_) { + cerr << "The expired fence file descriptor should not change" << endl; + return TestFail; + } + + close(fd); + + expectFenceFailure_ = false; + + return 0; +} + +/* Callback to signal a fence waiting on the eventfd file descriptor. */ +void FenceTest::signalFence() +{ + uint64_t value = 1; + write(efd2_, &value, sizeof(value)); + dispatcher_->processEvents(); +} + +void FenceTest::requestComplete(Request *request) +{ + uint64_t cookie = request->cookie(); + completedRequest_ = cookie; + + /* We expect the last request to fail, if it doesn't happen, test fails. */ + if (expectFenceFailure_ && cookie == expiredRequestId_ && + request->status() != Request::RequestCancelled) { + cerr << "The last request should have failed: " << cookie << endl; + + expectedCompletionResult_ = false; + dispatcher_->interrupt(); + return; + } + + /* All other requests but the last one should be completed. */ + if (expectFenceFailure_ && cookie < expiredRequestId_ && + request->status() != Request::RequestComplete) { + cerr << "All requests but last should complete: " << cookie << endl; + + expectedCompletionResult_ = false; + dispatcher_->interrupt(); + return; + } + + /* + * If the last request has failed already, all the ones queued after + * that shall complete. + */ + if (!expectFenceFailure_ && + request->status() != Request::RequestComplete) { + cerr << "Unexpected request failure: " << cookie << endl; + + expectedCompletionResult_ = false; + dispatcher_->interrupt(); + return; + } + + /* + * The last request has failed. + * Validate its fence status and do not re-queue it. + */ + if (cookie == expiredRequestId_) { + int ret = validateExpiredRequest(request); + if (ret) + expectedCompletionResult_ = false; + + dispatcher_->interrupt(); + return; + } + + const Request::BufferMap &buffers = request->buffers(); + const Stream *stream = buffers.begin()->first; + FrameBuffer *buffer = buffers.begin()->second; + + /* A succesfully completed request should have the Fence closed. */ + std::unique_ptr bufferFence = buffer->resetFence(); + if (bufferFence) { + cerr << "Unexpected valid fence in completed request" << endl; + + expectedCompletionResult_ = false; + dispatcher_->interrupt(); + return; + } + + request->reuse(); + + if (cookie == signalledRequestId_) { + /* + * The second time this request is about to be queued add + * a fence to it. + * + * The main loop should signal it by using a timer to write to + * the eventfd file descriptor before the fence expires. + */ + UniqueFD eventFd2(eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK)); + if (!eventFd2.isValid()) { + cerr << "Unable to create eventfd" << endl; + expectedCompletionResult_ = false; + return; + } + efd2_ = eventFd2.get(); + + std::unique_ptr fence = + std::make_unique(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); + + /* + * Interrupt the dispatcher to return control to the main loop and + * activate the fenceTimer + . */ + dispatcher_->interrupt(); +} + +int FenceTest::run() +{ + for (const auto &[i, buffer] : utils::enumerate(allocator_->buffers(stream_))) { + std::unique_ptr 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(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 : 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_) + /* + * 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; +} + +void FenceTest::cleanup() +{ + delete allocator_; +} + +TEST_REGISTER(FenceTest) diff --git a/test/meson.build b/test/meson.build index daaa3862cdd6..99b7e27b4bfb 100644 --- a/test/meson.build +++ b/test/meson.build @@ -40,6 +40,7 @@ internal_tests = [ ['event-dispatcher', 'event-dispatcher.cpp'], ['event-thread', 'event-thread.cpp'], ['file', 'file.cpp'], + ['fence', 'fence.cpp'], ['flags', 'flags.cpp'], ['hotplug-cameras', 'hotplug-cameras.cpp'], ['mapped-buffer', 'mapped-buffer.cpp'],