/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2021, Google Inc. * * 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 libcamera; using namespace std; using namespace std::chrono_literals; 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(); 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; /* * Request IDs track the number of requests that have completed. They * are one-based, and don't wrap. */ unsigned int completedRequestId_; 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; } completedRequestId_ = 0; /* * All but two requests are queued without a fence. Request * expiredRequestId_ will be queued with a fence that we won't signal * (which is then expected to expire), and request signalledRequestId_ * will be queued with a fence that gets signalled. Select nbuffers_ * and nbuffers_ * 2 for those two requests, to space them by a few * frames while still not requiring a long time for the test to * complete. */ expiredRequestId_ = nbuffers_; signalledRequestId_ = nbuffers_ * 2; 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; request->reuse(); if (completedRequestId_ == signalledRequestId_ - nbuffers_ && setFence_) { /* * This is the request that will be used to test fence * signalling when it completes next time. Add a fence to it, * using efd2_. The main loop will signal the fence 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) { completedRequestId_++; /* * Request expiredRequestId_ is expected to fail as its fence has not * been signalled. * * Validate the fence status but do not re-queue it. */ if (completedRequestId_ == expiredRequestId_) { if (validateExpiredRequest(request) != TestPass) expectedCompletionResult_ = false; dispatcher_->interrupt(); return; } /* Validate all other requests. */ 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_ - 1) { /* This request will have a fence, and it will expire. */ std::unique_ptr<Fence> 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 long enough for all requests to complete, allowing 500ms per * request. */ Timer timer; timer.start(500ms * (signalledRequestId_ + 1)); while (timer.isRunning() && expectedCompletionResult_ && completedRequestId_ <= signalledRequestId_ + 1) { if (completedRequestId_ == signalledRequestId_ - 1 && setFence_) /* * The request just before signalledRequestId_ has just * completed. Request signalledRequestId_ has been * queued with a fence, and libcamera is likely already * waiting on the fence, or will soon. Start the timer * to signal the fence in 10 msec. */ fenceTimer.start(10ms); dispatcher_->processEvents(); } camera_->requestCompleted.disconnect(); if (camera_->stop()) { cerr << "Failed to stop camera" << endl; return TestFail; } return expectedCompletionResult_ ? TestPass : TestFail; } TEST_REGISTER(FenceTest)