Merge "Add toString and remove default case"
diff --git a/libs/ui/GraphicBufferAllocator.cpp b/libs/ui/GraphicBufferAllocator.cpp
index fcc2547..efe0931 100644
--- a/libs/ui/GraphicBufferAllocator.cpp
+++ b/libs/ui/GraphicBufferAllocator.cpp
@@ -111,11 +111,10 @@
ALOGD("%s", s.c_str());
}
-status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height,
- PixelFormat format, uint32_t layerCount, uint64_t usage,
- buffer_handle_t* handle, uint32_t* stride,
- uint64_t /*graphicBufferId*/, std::string requestorName)
-{
+status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format,
+ uint32_t layerCount, uint64_t usage,
+ buffer_handle_t* handle, uint32_t* stride,
+ std::string requestorName) {
ATRACE_CALL();
// make sure to not allocate a N x 0 or 0 x N buffer, since this is
@@ -175,6 +174,13 @@
}
}
+status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format,
+ uint32_t layerCount, uint64_t usage,
+ buffer_handle_t* handle, uint32_t* stride,
+ uint64_t /*graphicBufferId*/, std::string requestorName) {
+ return allocate(width, height, format, layerCount, usage, handle, stride, requestorName);
+}
+
status_t GraphicBufferAllocator::free(buffer_handle_t handle)
{
ATRACE_CALL();
diff --git a/libs/ui/include/ui/GraphicBufferAllocator.h b/libs/ui/include/ui/GraphicBufferAllocator.h
index 324d9e1..9f6159a 100644
--- a/libs/ui/include/ui/GraphicBufferAllocator.h
+++ b/libs/ui/include/ui/GraphicBufferAllocator.h
@@ -42,11 +42,16 @@
public:
static inline GraphicBufferAllocator& get() { return getInstance(); }
+ // DEPRECATED: GraphicBufferAllocator does not use the graphicBufferId
status_t allocate(uint32_t w, uint32_t h, PixelFormat format,
uint32_t layerCount, uint64_t usage,
buffer_handle_t* handle, uint32_t* stride, uint64_t graphicBufferId,
std::string requestorName);
+ status_t allocate(uint32_t w, uint32_t h, PixelFormat format, uint32_t layerCount,
+ uint64_t usage, buffer_handle_t* handle, uint32_t* stride,
+ std::string requestorName);
+
status_t free(buffer_handle_t handle);
size_t getTotalSize() const;
diff --git a/libs/ui/include/ui/GraphicBufferMapper.h b/libs/ui/include/ui/GraphicBufferMapper.h
index c401a48..83fb144 100644
--- a/libs/ui/include/ui/GraphicBufferMapper.h
+++ b/libs/ui/include/ui/GraphicBufferMapper.h
@@ -23,6 +23,7 @@
#include <memory>
#include <ui/PixelFormat.h>
+#include <ui/Rect.h>
#include <utils/Singleton.h>
@@ -36,7 +37,6 @@
// ---------------------------------------------------------------------------
class GrallocMapper;
-class Rect;
class GraphicBufferMapper : public Singleton<GraphicBufferMapper>
{
diff --git a/services/gpuservice/Android.bp b/services/gpuservice/Android.bp
index 7b8e0f8..baba64f 100644
--- a/services/gpuservice/Android.bp
+++ b/services/gpuservice/Android.bp
@@ -1,20 +1,6 @@
-filegroup {
- name: "gpuservice_sources",
- srcs: [
- "GpuService.cpp",
- "gpustats/GpuStats.cpp"
- ],
-}
-
-filegroup {
- name: "gpuservice_binary_sources",
- srcs: ["main_gpuservice.cpp"],
-}
-
cc_defaults {
name: "gpuservice_defaults",
cflags: [
- "-DLOG_TAG=\"GpuService\"",
"-Wall",
"-Werror",
"-Wformat",
@@ -22,12 +8,13 @@
"-Wunused",
"-Wunreachable-code",
],
- srcs: [
- ":gpuservice_sources",
- ],
- include_dirs: [
- "frameworks/native/vulkan/vkjson",
- "frameworks/native/vulkan/include",
+}
+
+cc_defaults {
+ name: "libgpuservice_defaults",
+ defaults: ["gpuservice_defaults"],
+ cflags: [
+ "-DLOG_TAG=\"GpuService\"",
],
shared_libs: [
"libbase",
@@ -36,17 +23,22 @@
"libgraphicsenv",
"liblog",
"libutils",
- "libvulkan",
+ "libvkjson",
],
static_libs: [
"libserviceutils",
- "libvkjson",
+ ],
+ export_static_lib_headers: [
+ "libserviceutils",
+ ],
+ export_shared_lib_headers: [
+ "libgraphicsenv",
],
}
cc_defaults {
- name: "gpuservice_production_defaults",
- defaults: ["gpuservice_defaults"],
+ name: "libgpuservice_production_defaults",
+ defaults: ["libgpuservice_defaults"],
cflags: [
"-fvisibility=hidden",
"-fwhole-program-vtables", // requires ThinLTO
@@ -56,8 +48,24 @@
},
}
+filegroup {
+ name: "libgpuservice_sources",
+ srcs: [
+ "GpuService.cpp",
+ "gpustats/GpuStats.cpp"
+ ],
+}
+
+cc_library_shared {
+ name: "libgpuservice",
+ defaults: ["libgpuservice_production_defaults"],
+ srcs: [
+ ":libgpuservice_sources",
+ ],
+}
+
cc_defaults {
- name: "gpuservice_binary",
+ name: "libgpuservice_binary",
defaults: ["gpuservice_defaults"],
shared_libs: [
"libbinder",
@@ -68,9 +76,17 @@
ldflags: ["-Wl,--export-dynamic"],
}
+filegroup {
+ name: "gpuservice_binary_sources",
+ srcs: ["main_gpuservice.cpp"],
+}
+
cc_binary {
name: "gpuservice",
- defaults: ["gpuservice_binary"],
+ defaults: ["libgpuservice_binary"],
init_rc: ["gpuservice.rc"],
srcs: [":gpuservice_binary_sources"],
+ shared_libs: [
+ "libgpuservice",
+ ],
}
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index 127a3da..d476f7b4 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -174,6 +174,7 @@
"Scheduler/VSyncDispatchTimerQueue.cpp",
"Scheduler/VSyncPredictor.cpp",
"Scheduler/VSyncModulator.cpp",
+ "Scheduler/VSyncReactor.cpp",
"StartPropertySetThread.cpp",
"SurfaceFlinger.cpp",
"SurfaceFlingerDefaultFactory.cpp",
diff --git a/services/surfaceflinger/Scheduler/VSyncReactor.cpp b/services/surfaceflinger/Scheduler/VSyncReactor.cpp
new file mode 100644
index 0000000..1398362
--- /dev/null
+++ b/services/surfaceflinger/Scheduler/VSyncReactor.cpp
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "VSyncReactor.h"
+#include "VSyncDispatch.h"
+#include "VSyncTracker.h"
+
+namespace android::scheduler {
+
+VSyncReactor::VSyncReactor(std::unique_ptr<VSyncDispatch> dispatch,
+ std::unique_ptr<VSyncTracker> tracker, size_t pendingFenceLimit)
+ : mDispatch(std::move(dispatch)),
+ mTracker(std::move(tracker)),
+ mPendingLimit(pendingFenceLimit) {}
+
+bool VSyncReactor::addPresentFence(const std::shared_ptr<FenceTime>& fence) {
+ if (!fence) {
+ return false;
+ }
+
+ nsecs_t const signalTime = fence->getCachedSignalTime();
+ if (signalTime == Fence::SIGNAL_TIME_INVALID) {
+ return true;
+ }
+
+ std::lock_guard<std::mutex> lk(mMutex);
+ if (mIgnorePresentFences) {
+ return true;
+ }
+
+ for (auto it = mUnfiredFences.begin(); it != mUnfiredFences.end();) {
+ auto const time = (*it)->getCachedSignalTime();
+ if (time == Fence::SIGNAL_TIME_PENDING) {
+ it++;
+ } else if (time == Fence::SIGNAL_TIME_INVALID) {
+ it = mUnfiredFences.erase(it);
+ } else {
+ mTracker->addVsyncTimestamp(time);
+ it = mUnfiredFences.erase(it);
+ }
+ }
+
+ if (signalTime == Fence::SIGNAL_TIME_PENDING) {
+ if (mPendingLimit == mUnfiredFences.size()) {
+ mUnfiredFences.erase(mUnfiredFences.begin());
+ }
+ mUnfiredFences.push_back(fence);
+ } else {
+ mTracker->addVsyncTimestamp(signalTime);
+ }
+
+ return false; // TODO(b/144707443): add policy for turning on HWVsync.
+}
+
+void VSyncReactor::setIgnorePresentFences(bool ignoration) {
+ std::lock_guard<std::mutex> lk(mMutex);
+ mIgnorePresentFences = ignoration;
+ if (mIgnorePresentFences == true) {
+ mUnfiredFences.clear();
+ }
+}
+
+} // namespace android::scheduler
diff --git a/services/surfaceflinger/Scheduler/VSyncReactor.h b/services/surfaceflinger/Scheduler/VSyncReactor.h
new file mode 100644
index 0000000..05fd0fd
--- /dev/null
+++ b/services/surfaceflinger/Scheduler/VSyncReactor.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <android-base/thread_annotations.h>
+#include <ui/FenceTime.h>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace android::scheduler {
+
+class VSyncDispatch;
+class VSyncTracker;
+
+// TODO (b/145217110): consider renaming.
+class VSyncReactor /* TODO (b/140201379): : public android::DispSync */ {
+public:
+ VSyncReactor(std::unique_ptr<VSyncDispatch> dispatch, std::unique_ptr<VSyncTracker> tracker,
+ size_t pendingFenceLimit);
+
+ bool addPresentFence(const std::shared_ptr<FenceTime>& fence);
+ void setIgnorePresentFences(bool ignoration);
+
+private:
+ std::unique_ptr<VSyncDispatch> const mDispatch;
+ std::unique_ptr<VSyncTracker> const mTracker;
+ size_t const mPendingLimit;
+
+ std::mutex mMutex;
+ bool mIgnorePresentFences GUARDED_BY(mMutex) = false;
+ std::vector<std::shared_ptr<FenceTime>> mUnfiredFences GUARDED_BY(mMutex);
+};
+
+} // namespace android::scheduler
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index 0c4a752..ccfa6c5 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -57,6 +57,7 @@
"VSyncDispatchTimerQueueTest.cpp",
"VSyncDispatchRealtimeTest.cpp",
"VSyncPredictorTest.cpp",
+ "VSyncReactorTest.cpp",
"mock/DisplayHardware/MockComposer.cpp",
"mock/DisplayHardware/MockDisplay.cpp",
"mock/DisplayHardware/MockPowerAdvisor.cpp",
diff --git a/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp b/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp
new file mode 100644
index 0000000..b4aebf0
--- /dev/null
+++ b/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp
@@ -0,0 +1,184 @@
+/*
+ * Copyright 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#undef LOG_TAG
+#define LOG_TAG "LibSurfaceFlingerUnittests"
+#define LOG_NDEBUG 0
+
+#include "Scheduler/VSyncDispatch.h"
+#include "Scheduler/VSyncReactor.h"
+#include "Scheduler/VSyncTracker.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <ui/Fence.h>
+#include <ui/FenceTime.h>
+#include <array>
+
+using namespace testing;
+using namespace std::literals;
+namespace android::scheduler {
+
+class MockVSyncTracker : public VSyncTracker {
+public:
+ MOCK_METHOD1(addVsyncTimestamp, void(nsecs_t));
+ MOCK_CONST_METHOD1(nextAnticipatedVSyncTimeFrom, nsecs_t(nsecs_t));
+};
+
+class VSyncTrackerWrapper : public VSyncTracker {
+public:
+ VSyncTrackerWrapper(std::shared_ptr<VSyncTracker> const& tracker) : mTracker(tracker) {}
+
+ void addVsyncTimestamp(nsecs_t timestamp) final { mTracker->addVsyncTimestamp(timestamp); }
+ nsecs_t nextAnticipatedVSyncTimeFrom(nsecs_t timePoint) const final {
+ return mTracker->nextAnticipatedVSyncTimeFrom(timePoint);
+ }
+
+private:
+ std::shared_ptr<VSyncTracker> const mTracker;
+};
+
+class MockVSyncDispatch : public VSyncDispatch {
+public:
+ MOCK_METHOD2(registerCallback, CallbackToken(std::function<void(nsecs_t)> const&, std::string));
+ MOCK_METHOD1(unregisterCallback, void(CallbackToken));
+ MOCK_METHOD3(schedule, ScheduleResult(CallbackToken, nsecs_t, nsecs_t));
+ MOCK_METHOD1(cancel, CancelResult(CallbackToken token));
+};
+
+class VSyncDispatchWrapper : public VSyncDispatch {
+public:
+ VSyncDispatchWrapper(std::shared_ptr<VSyncDispatch> const& dispatch) : mDispatch(dispatch) {}
+ CallbackToken registerCallback(std::function<void(nsecs_t)> const& callbackFn,
+ std::string callbackName) final {
+ return mDispatch->registerCallback(callbackFn, callbackName);
+ }
+
+ void unregisterCallback(CallbackToken token) final { mDispatch->unregisterCallback(token); }
+
+ ScheduleResult schedule(CallbackToken token, nsecs_t workDuration,
+ nsecs_t earliestVsync) final {
+ return mDispatch->schedule(token, workDuration, earliestVsync);
+ }
+
+ CancelResult cancel(CallbackToken token) final { return mDispatch->cancel(token); }
+
+private:
+ std::shared_ptr<VSyncDispatch> const mDispatch;
+};
+
+std::shared_ptr<FenceTime> generateInvalidFence() {
+ sp<Fence> fence = new Fence();
+ return std::make_shared<FenceTime>(fence);
+}
+
+std::shared_ptr<FenceTime> generatePendingFence() {
+ sp<Fence> fence = new Fence(dup(fileno(tmpfile())));
+ return std::make_shared<FenceTime>(fence);
+}
+
+void signalFenceWithTime(std::shared_ptr<FenceTime> const& fence, nsecs_t time) {
+ FenceTime::Snapshot snap(time);
+ fence->applyTrustedSnapshot(snap);
+}
+
+std::shared_ptr<FenceTime> generateSignalledFenceWithTime(nsecs_t time) {
+ sp<Fence> fence = new Fence(dup(fileno(tmpfile())));
+ std::shared_ptr<FenceTime> ft = std::make_shared<FenceTime>(fence);
+ signalFenceWithTime(ft, time);
+ return ft;
+}
+
+class VSyncReactorTest : public testing::Test {
+protected:
+ VSyncReactorTest()
+ : mMockDispatch(std::make_shared<MockVSyncDispatch>()),
+ mMockTracker(std::make_shared<MockVSyncTracker>()),
+ mReactor(std::make_unique<VSyncDispatchWrapper>(mMockDispatch),
+ std::make_unique<VSyncTrackerWrapper>(mMockTracker), kPendingLimit) {}
+
+ std::shared_ptr<MockVSyncDispatch> mMockDispatch;
+ std::shared_ptr<MockVSyncTracker> mMockTracker;
+ static constexpr size_t kPendingLimit = 3;
+ static constexpr nsecs_t dummyTime = 47;
+ VSyncReactor mReactor;
+};
+
+TEST_F(VSyncReactorTest, addingNullFenceCheck) {
+ EXPECT_FALSE(mReactor.addPresentFence(nullptr));
+}
+
+TEST_F(VSyncReactorTest, addingInvalidFenceSignalsNeedsMoreInfo) {
+ EXPECT_TRUE(mReactor.addPresentFence(generateInvalidFence()));
+}
+
+TEST_F(VSyncReactorTest, addingSignalledFenceAddsToTracker) {
+ EXPECT_CALL(*mMockTracker, addVsyncTimestamp(dummyTime));
+ EXPECT_FALSE(mReactor.addPresentFence(generateSignalledFenceWithTime(dummyTime)));
+}
+
+TEST_F(VSyncReactorTest, addingPendingFenceAddsSignalled) {
+ nsecs_t anotherDummyTime = 2919019201;
+
+ EXPECT_CALL(*mMockTracker, addVsyncTimestamp(_)).Times(0);
+ auto pendingFence = generatePendingFence();
+ EXPECT_FALSE(mReactor.addPresentFence(pendingFence));
+ Mock::VerifyAndClearExpectations(mMockTracker.get());
+
+ signalFenceWithTime(pendingFence, dummyTime);
+
+ EXPECT_CALL(*mMockTracker, addVsyncTimestamp(dummyTime));
+ EXPECT_CALL(*mMockTracker, addVsyncTimestamp(anotherDummyTime));
+ EXPECT_FALSE(mReactor.addPresentFence(generateSignalledFenceWithTime(anotherDummyTime)));
+}
+
+TEST_F(VSyncReactorTest, limitsPendingFences) {
+ std::array<std::shared_ptr<FenceTime>, kPendingLimit * 2> fences;
+ std::array<nsecs_t, fences.size()> fakeTimes;
+ std::generate(fences.begin(), fences.end(), [] { return generatePendingFence(); });
+ std::generate(fakeTimes.begin(), fakeTimes.end(), [i = 10]() mutable {
+ i++;
+ return i * i;
+ });
+
+ for (auto const& fence : fences) {
+ mReactor.addPresentFence(fence);
+ }
+
+ for (auto i = fences.size() - kPendingLimit; i < fences.size(); i++) {
+ EXPECT_CALL(*mMockTracker, addVsyncTimestamp(fakeTimes[i]));
+ }
+
+ for (auto i = 0u; i < fences.size(); i++) {
+ signalFenceWithTime(fences[i], fakeTimes[i]);
+ }
+ mReactor.addPresentFence(generatePendingFence());
+}
+
+TEST_F(VSyncReactorTest, ignoresPresentFencesWhenToldTo) {
+ static constexpr size_t aFewTimes = 8;
+ EXPECT_CALL(*mMockTracker, addVsyncTimestamp(dummyTime)).Times(1);
+
+ mReactor.setIgnorePresentFences(true);
+ for (auto i = 0; i < aFewTimes; i++) {
+ mReactor.addPresentFence(generateSignalledFenceWithTime(dummyTime));
+ }
+
+ mReactor.setIgnorePresentFences(false);
+ EXPECT_FALSE(mReactor.addPresentFence(generateSignalledFenceWithTime(dummyTime)));
+}
+
+} // namespace android::scheduler
diff --git a/vulkan/vkjson/Android.bp b/vulkan/vkjson/Android.bp
index a626e48..8528898 100644
--- a/vulkan/vkjson/Android.bp
+++ b/vulkan/vkjson/Android.bp
@@ -1,4 +1,4 @@
-cc_library_static {
+cc_library_shared {
name: "libvkjson",
srcs: [
"vkjson.cc",
@@ -15,11 +15,14 @@
export_include_dirs: [
".",
],
+ shared_libs: [
+ "libvulkan",
+ ],
whole_static_libs: [
"libjsoncpp",
],
- header_libs: [
- "vulkan_headers",
+ export_shared_lib_headers: [
+ "libvulkan",
],
}